test(eui-neo): un-gate both window members to all three platforms

Both members were [target.'cfg(linux)']-gated, which made them compile to
`int main() { return 0; }` on macOS and Windows — trivially green, zero
coverage, and it left `glfw_app_main.cpp` uncompiled on every platform after
all.

imgui-window and gui-stack are linux-only because they pull the X11 packages
directly. compat.eui-neo and compat.glfw are not, and the four existing
eui-neo members already build on every runner. Audited before un-gating:
every core/ header these TUs reach (window_types, window_backend,
render_backend, primitive_geometry, render_surface, platform, input_state,
input_types, ime_bridge) is platform-clean — no windows.h, no Cocoa, no GL —
and every GLFW entry point used is portable. core::releaseInputQueue reaches
eui_ime_uninstall_message_filter, which ime_bridge.c defines on all three.

Also add GLFW_INCLUDE_NONE before <GLFW/glfw3.h>, as core/input/input_state.h
does, so GLFW does not pull a GL header of its own choosing (GL/gl.h on
Windows, the deprecated OpenGL/gl.h on macOS).

Drop the redundant `glfw = "3.4"` from both members. mcpp propagates a
transitive dependency's include_dirs and link inputs to the consumer, and
compat.eui-neo already depends on compat.glfw everywhere — verified by
removing the line and rebuilding. Matches the existing convention:
eui-neo-sdl2 includes <SDL.h>/<curl/curl.h> and eui-neo-vulkan calls
vkEnumerateInstanceVersion, neither re-declaring those packages.

macOS/Windows are CI-verified only; there is no runner for either here. The
opt-in windowed run stays linux-only (both runners are headless), same as
imgui-window.

Descriptor comment fix while re-probing the encoding: it claimed "there is no
`default-features = false` (mcpp#242)". Wrong — #242 shipped in 0.0.98. The
accurate statement is that its seedDefault gate is manifest-side and a
`default` feature declared in an xpkg DESCRIPTOR is never seeded at all, so
the consumer has nothing to switch off. Re-probed with
`default = { defines = { ... } }` and a plain consumer: macro absent on
0.0.109.

MCPP_VERSION deliberately stays at 0.0.109: #242 (0.0.98), #243 (0.0.99) and
#233/#240 (0.0.97/0.0.98) are all at or below the pin, and nothing in
2026.7.27.1 .. 2026.7.29.2 touches feature semantics, so a bump buys no
simplification here.

Author: Sunrisepeak

.agents/docs/2026-07-30-eui-neo-window-and-app-main-members.md

@@ -39,14 +39,28 @@ per consuming project).
 | `eui-neo-window` | off | hand-written `main()` in the test TU | `core::window`, OpenGL backend, `ScopedRenderBackend`, paced loop, freetype text |
 | `eui-neo-app-main` | **on** | upstream `glfw_app_main.cpp` | the feature's source compiles; `main` really comes from the package |
 
-Both are `[target.'cfg(linux)']`-gated, matching `imgui-window`, `gui-stack` and the
-rest of the X11/GLFW stack in this index. Off-Linux they declare no dependencies and
-the test TU compiles to `int main() { return 0; }`.
-
-Both declare `compat.glfw` **directly** rather than leaning on the transitive edge:
-each calls GLFW itself (`glfwPollEvents`/`glfwWindowShouldClose` in one,
-`glfwSetWindowShouldClose` in the other), because EUI's `core::window` facade
-exposes no event-pump entry point.
+Both build on **all three platforms**, deliberately not `cfg`-gated. `imgui-window`
+and `gui-stack` are linux-only because they pull the X11 packages directly;
+`compat.eui-neo` and `compat.glfw` are not, and the four existing eui-neo members
+already build on every runner. Audited before un-gating: every `core/` header these
+TUs reach (`window_types.h`, `window_backend.h`, `render_backend.h`,
+`primitive_geometry.h`, `render_surface.h`, `platform.h`, `input_state.h`,
+`input_types.h`, `ime_bridge.h`) is platform-clean — no `windows.h`, no Cocoa, no GL
+— and every GLFW entry point used is portable. `core::releaseInputQueue` reaches
+`eui_ime_uninstall_message_filter`, which `ime_bridge.c` defines on all three
+platforms.
+
+Both add `GLFW_INCLUDE_NONE` before `<GLFW/glfw3.h>`, as `core/input/input_state.h`
+does, so GLFW does not pull a GL header of its own choosing (`GL/gl.h` on Windows,
+the deprecated `OpenGL/gl.h` on macOS). EUI reaches GL through `compat.glad`.
+
+Neither re-declares `compat.glfw`, even though both call GLFW directly (EUI's
+`core::window` facade exposes no event-pump entry point). mcpp propagates a
+transitive dependency's `include_dirs` and link inputs to the consumer, and
+`compat.eui-neo` already depends on `compat.glfw` on every platform. Verified by
+dropping the line and rebuilding both members. This matches the existing
+convention: `eui-neo-sdl2` includes `<SDL.h>` and `<curl/curl.h>`, `eui-neo-vulkan`
+calls `vkEnumerateInstanceVersion`, and neither declares those packages.
 
 ## Why the run is opt-in
 
@@ -126,15 +140,41 @@ by running it:
 Neither is a descriptor bug; both are upstream behaviour a consumer must know, and
 neither was discoverable from the headless members.
 
+## Why the mcpp pin does NOT move
+
+Checked before writing any of this, because the encoding in this descriptor is ugly
+enough to be worth re-testing against a newer client. `MCPP_VERSION` stays at
+**0.0.109**.
+
+The three capabilities that could simplify `compat.eui-neo` all landed **at or before
+0.0.109**, which is already the pin: `default-features = false` (#242, 0.0.98),
+feature→feature forwarding (#243, 0.0.99), obj-path disambiguation (#233/#240,
+0.0.97/0.0.98). The four releases after it — `2026.7.27.1`, `.28.2`, `.29.1`,
+`.29.2` — carry the date-based version scheme, the private-glibc `LD_LIBRARY_PATH`
+fix (#291), 4-segment version parsing, xlings pin hygiene, `[build].defines` before
+the P1689 scan (#297), the musl/MinGW `build.mcpp` host helper (#298), `mcpp add`
+index validation (#307) and SemVer routing (#309). `git log v0.0.109..HEAD` over the
+feature/resolver/plan sources returns nothing that touches feature semantics.
+
+One correction to the descriptor's own comment while re-probing: it claimed "there is
+no `default-features = false` (mcpp#242)". That is wrong — #242 shipped in 0.0.98.
+The accurate statement is that its `seedDefault` gate is **manifest**-side, and a
+`default` feature declared in an xpkg **descriptor** is never seeded at all, so the
+consumer has nothing to switch off. Re-probed by giving the package
+`default = { defines = { "MCPP_PROBE_DEFAULT_APPLIED=1" } }` and checking the macro
+from a plain consumer TU: absent on 0.0.109. The generated-header + forced-`-include`
+encoding therefore stays as it is. Worth filing upstream as a descriptor-side gap in
+#242's coverage.
+
 ## Verification
 
 Local, mcpp **0.0.109** (matching `validate.yml` `env.MCPP_VERSION`), linux-x86_64,
 gcc 16.1.0, X11 display with NVIDIA GL 4.6.
 
 ```
                               headless        MCPP_RUN_WINDOW=1
-eui-neo-window                ok (0.08s)      ok (60 frames, 120 rect / 120 text draws)
-eui-neo-app-main              ok (0.07s)      ok (60 frames, 118 rect / 118 text draws)
+eui-neo-window                ok (0.08s)      ok (60 frames in 0.98s, 120 rect / 120 text draws)
+eui-neo-app-main              ok (0.08s)      ok (60 frames, 118 rect / 118 text draws)
 eui-neo            (existing) ok
 eui-neo-markdown   (existing) ok
 ```
@@ -143,10 +183,25 @@ eui-neo-markdown   (existing) ok
 `check_cross_package_refs.lua` all pass on the touched descriptor. The descriptor
 change is comment-only.
 
+**macOS and Windows are CI-verified only.** There is no runner for either here, so
+the build+link half of both members on those platforms is asserted by the
+`workspace (macos)` / `workspace (windows)` legs, not locally. Two things are new
+there and worth watching on the first run:
+
+* `glfw_app_main.cpp` has never been compiled on any platform. Its Windows half
+  (`<mmsystem.h>`, `GLFW_EXPOSE_NATIVE_WIN32`, `glfw3native.h`, `timeBeginPeriod`,
+  `MonitorFromWindow`, `EnumDisplaySettingsW`) needs `-lwinmm` and `-luser32`, both
+  already in the descriptor's `windows.ldflags`.
+* these are the first members to link `compat.glfw` off Linux from their **own** code
+  rather than through `compat.eui-neo`, which exercises the macOS
+  `Cocoa`/`IOKit`/`CoreFoundation` frameworks and the Windows `-lgdi32` from a
+  consumer link.
+
 ## Not done
 
 * `app-main-sdl2` stays uncovered. It is the same shape against `compat.sdl2`, and
   covering it means a fifth window member for one `sources` line; worth doing if the
   SDL2 window backend gains real users.
-* macOS/Windows only get the build+link half, same as `imgui-window`. The opt-in run
-  has been exercised on linux-x86_64 only.
+* The **opt-in windowed run** has been exercised on linux-x86_64 only. macOS and
+  Windows runners are headless, so they get build+link only — same as
+  `imgui-window`.

pkgs/e/compat.eui-neo.lua

@@ -174,10 +174,18 @@ package = {
         -- / else-GLFW. Define both halves of either pair and the first one
         -- silently wins, ignoring what the consumer asked for.
         --
-        -- mcpp features are purely additive and there is no
-        -- `default-features = false` (mcpp#242). The obvious encodings all
-        -- fail on 0.0.109, each in its own way — all three verified with
-        -- probes, because each failure is silent:
+        -- mcpp features are purely additive here. `default-features = false`
+        -- does exist (mcpp#242, since 0.0.98) — but its `seedDefault` gate lives
+        -- on the MANIFEST side, and a `default` feature declared in an xpkg
+        -- DESCRIPTOR is never seeded to begin with, so there is nothing for the
+        -- consumer to switch off. Re-probed on 0.0.109 by giving this package a
+        -- `default = { defines = {...} }` and checking the macro from a plain
+        -- consumer: absent. Unchanged in the newest mcpp (2026.7.29.2) — nothing
+        -- has touched the feature system since 0.0.109, so a version bump buys
+        -- no simplification of the encoding below.
+        --
+        -- The obvious encodings all fail on 0.0.109, each in its own way — all
+        -- three verified with probes, because each failure is silent:
         --
         --   * `default = { defines/sources/deps = … }` is INERT. Not
         --     "suppressed when features are named" — never applied at all. A

tests/examples/eui-neo-app-main/mcpp.toml

@@ -10,18 +10,24 @@
 # enables `app-main` may not contain any translation unit of its own that
 # defines main(). See the note in pkgs/e/compat.eui-neo.lua.
 #
-# Linux-only (cfg): the whole X11/GLFW/GL stack is linux-gated across this
-# index, matching tests/examples/imgui-window. Off-Linux the member has no
-# dependencies and the test TU compiles to a no-op.
+# ALL THREE PLATFORMS, deliberately not cfg-gated. `app-main` selects upstream's
+# GLFW entry point, which is the default window backend on every platform, and
+# nothing in it is linux-specific — but until this member existed it was compiled
+# on NONE of them, so the windows `-fno-char8_t` / winmm+user32+pdh half of the
+# descriptor and the macOS Cocoa link were both unexercised for that TU.
 #
-# compat.glfw is a DIRECT dependency because the test TU calls
-# glfwSetWindowShouldClose() itself to bound the opt-in window run.
+# compat.glfw is NOT re-declared here even though this TU calls
+# glfwSetWindowShouldClose()/glfwGetCurrentContext() itself to bound the opt-in
+# window run: mcpp propagates a transitive dependency's `include_dirs` and link
+# inputs to the consumer, and compat.eui-neo already depends on compat.glfw on
+# every platform. Same convention as tests/examples/eui-neo-sdl2 and
+# eui-neo-vulkan, which include <SDL.h> / <vulkan/vulkan.h> without re-declaring
+# either.
 #
 # The `compat` index redirect is inherited from the workspace root.
 [package]
 name = "eui-neo-app-main-tests"
 version = "0.1.0"
 
-[target.'cfg(linux)'.dependencies.compat]
+[dependencies.compat]
 eui-neo = { version = "0.5.3", features = ["app-main"] }
-glfw = "3.4"

tests/examples/eui-neo-app-main/tests/app_main.cpp

@@ -22,13 +22,22 @@
 //     point belongs to the package, the gate cannot live in main() — it lives in
 //     a namespace-scope constructor, which runs before it. Headless CI links the
 //     real binary, executes the guard, and exits 0.
-#if defined(__linux__)
-
+//
+// Builds on all three platforms: GLFW is upstream's default window backend
+// everywhere, and nothing below is platform-specific.
 #include <eui_neo.h>
 
 #include "core/render/render_backend.h"
 
+// GLFW would otherwise pull a GL header of its own choosing (GL/gl.h on Windows,
+// the deprecated OpenGL/gl.h on macOS). EUI reaches GL through compat.glad, so
+// this TU wants the GLFW API and nothing else — the same thing
+// core/input/input_state.h does before its own include.
+#ifndef GLFW_INCLUDE_NONE
+#define GLFW_INCLUDE_NONE
+#endif
 #include <GLFW/glfw3.h>
+
 import std;
 
 namespace {
@@ -162,11 +171,3 @@ void compose(eui::Ui& ui, const eui::Screen& screen) {
 }
 
 } // namespace app
-
-#else
-
-// Off-Linux the member declares no dependencies, so there is nothing to link
-// against and no package-supplied main() either — this TU has to provide one.
-int main() { return 0; }
-
-#endif

tests/examples/eui-neo-window/mcpp.toml

@@ -8,19 +8,30 @@
 # construction (json + platform flags), so window creation, the OpenGL backend,
 # the text/freetype path and the render loop were previously uncovered.
 #
-# Linux-only (cfg), matching tests/examples/imgui-window and the rest of the
-# X11/GLFW stack in this index. The window run needs a display and is opt-in
-# (MCPP_RUN_WINDOW=1); headless CI compiles + links the whole loop and returns 0.
+# ALL THREE PLATFORMS, deliberately not cfg-gated. Unlike tests/examples/
+# imgui-window and gui-stack — linux-only because they pull the X11 packages
+# directly — compat.eui-neo and compat.glfw both build on linux/macosx/windows,
+# and the four existing eui-neo members already prove that on every runner. What
+# was never compiled anywhere is a CONSUMER translation unit that includes
+# core/window, core/render and <GLFW/glfw3.h>, which is exactly what this member
+# is. None of the headers it reaches carry platform-specific includes.
 #
-# compat.glfw is a DIRECT dependency, not just a transitive one: this project's
-# own translation unit calls glfwPollEvents()/glfwWindowShouldClose(), because
-# EUI's core::window facade exposes no event-pump entry point.
+# The window run needs a display and is opt-in (MCPP_RUN_WINDOW=1); headless CI
+# compiles + links the whole loop on each OS and returns 0.
+#
+# compat.glfw is NOT re-declared here even though this TU calls glfwPollEvents()
+# and glfwWindowShouldClose() itself (EUI's core::window facade exposes no
+# event-pump entry point). mcpp propagates a transitive dependency's
+# `include_dirs` and link inputs to the consumer, so the edge through
+# compat.eui-neo is enough — verified by dropping the line and rebuilding. Same
+# convention as tests/examples/eui-neo-sdl2 (`#include <SDL.h>`, `<curl/curl.h>`)
+# and eui-neo-vulkan (`vkEnumerateInstanceVersion`), neither of which re-declares
+# what it reaches through a feature.
 #
 # The `compat` index redirect is inherited from the workspace root.
 [package]
 name = "eui-neo-window-tests"
 version = "0.1.0"
 
-[target.'cfg(linux)'.dependencies.compat]
+[dependencies.compat]
 eui-neo = "0.5.3"
-glfw = "3.4"

tests/examples/eui-neo-window/tests/window.cpp

@@ -16,15 +16,24 @@
 // The window run needs a display, so it is opt-in via MCPP_RUN_WINDOW=1, exactly
 // as in tests/examples/imgui-window. Headless CI compiles and links the whole
 // loop — which is where a descriptor regression would surface — and returns 0.
-#if defined(__linux__)
-
+//
+// Builds on all three platforms. Every core/ header below is platform-clean (no
+// windows.h, no Cocoa, no GL), and every GLFW entry point used here is portable,
+// so there is no reason to cfg-gate this the way the X11-consuming members are.
 #include <eui_neo.h>
 
 #include "core/input/input_state.h"
 #include "core/platform/platform.h"
 #include "core/render/render_backend.h"
 #include "core/window/window_backend.h"
 
+// GLFW would otherwise pull a GL header of its own choosing (GL/gl.h on Windows,
+// the deprecated OpenGL/gl.h on macOS). EUI reaches GL through compat.glad, so
+// this TU wants the GLFW API and nothing else — the same thing
+// core/input/input_state.h does before its own include.
+#ifndef GLFW_INCLUDE_NONE
+#define GLFW_INCLUDE_NONE
+#endif
 #include <GLFW/glfw3.h>
 
 import std;
@@ -304,9 +313,3 @@ int main() {
     std::println("compat.eui-neo[own main]: linked; window run is opt-in (MCPP_RUN_WINDOW=1)");
     return 0;
 }
-
-#else
-
-int main() { return 0; }
-
-#endif