diff --git a/Aetheria.State.Verify/Program.cs b/Aetheria.State.Verify/Program.cs index 62a9f980e..ec019a194 100644 --- a/Aetheria.State.Verify/Program.cs +++ b/Aetheria.State.Verify/Program.cs @@ -59,6 +59,7 @@ RequireNoDeadPopupShells(root); RequirePlayerSettingsEveSurface(root); RequireVerseHostSettingsAuthority(root); RequireClientTargetBootAuthority(root); +RequireClientRuntimeConformanceContract(root); RequireVerseReplicaTool(root); RequireVerseSettingsShellAndBridge(root); RequireTypedStatRecipeOperations(root); @@ -604,6 +605,7 @@ Console.WriteLine("NameTools editor shell: the remaining name helper window lowe Console.WriteLine("Verse client state authority: Unity gameplay/UI read typed state through the shared Verse client instead of direct store spelunking"); Console.WriteLine("Verse host authority: daemon-owned typed verse host settings now drive provider advertisement, operations telemetry, and served Verse discovery"); Console.WriteLine("Client target boot authority: Unity boot resolves the active Verse through a typed client target instead of local path folklore"); +Console.WriteLine("Client runtime conformance: Hermodr is the generic Eve RTS check; Godot is the generic Eve ARPG check"); Console.WriteLine("Verse replica authority: remote client targets resolve to cache-only replica .cc files fed from the daemon"); Console.WriteLine("Verse settings shell: client target edits and Verse-host visibility commands lower through typed Eve surfaces"); Console.WriteLine("Main-menu Verse document access: the Unity Eve shell composes daemon-owned verse identity from typed documents instead of ad-libbing local menu copy"); @@ -10038,6 +10040,77 @@ static void RequireClientTargetBootAuthority(string root) } } +static void RequireClientRuntimeConformanceContract(string root) +{ + var conformancePath = Path.Combine(root, "Aetheria.State", "docs", "client-runtime-conformance.md"); + var authorityPlanPath = Path.Combine(root, "Aetheria.State", "docs", "verse-authority-implementation-plan.md"); + var ergonomicsPlanPath = Path.Combine(root, "Aetheria.State", "docs", "cultmesh-ergonomics-staged-migration-plan.md"); + + var conformance = File.Exists(conformancePath) + ? File.ReadAllText(conformancePath) + : throw new InvalidOperationException("Client runtime conformance contract is missing."); + var authorityPlan = File.Exists(authorityPlanPath) + ? File.ReadAllText(authorityPlanPath) + : throw new InvalidOperationException("Verse authority implementation plan is missing."); + var ergonomicsPlan = File.Exists(ergonomicsPlanPath) + ? File.ReadAllText(ergonomicsPlanPath) + : throw new InvalidOperationException("CultMesh ergonomics staged migration plan is missing."); + + var requiredContractSymbols = new[] + { + "Hermodr | Unspecialized Eve/browser lowering sanity check for the RTS surface.", + "Electron | Player-facing Starbridge RTS client.", + "Unity | Current ARPG reference client and demolition target.", + "Godot | Future unspecialized Eve/runtime parity target for the ARPG surface.", + "No daemon-side `Godot` mode, `Electron` mode, `Hermodr` mode, or `Unity`", + "No Aetheria-specific Hermodr plugin for RTS map semantics.", + "Godot lowers the ARPG contract without inheriting Unity authority." + }; + var missingContractSymbols = requiredContractSymbols + .Where(symbol => !conformance.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (missingContractSymbols.Length > 0) + { + throw new InvalidOperationException( + "Client runtime conformance contract no longer names the runtime authority map: " + + string.Join(", ", missingContractSymbols)); + } + + var requiredPlanSymbols = new[] + { + "Hermodr is the unspecialized Eve sanity check for the RTS surface", + "player-facing RTS client", + "future unspecialized Eve parity target for the ARPG surface", + "Hermodr must be able to reconstruct the RTS surface from Eve plus daemon API", + "Any daemon-side `Godot` behavior branch would be the wrong cut" + }; + var missingPlanSymbols = requiredPlanSymbols + .Where(symbol => !authorityPlan.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (missingPlanSymbols.Length > 0) + { + throw new InvalidOperationException( + "Verse authority plan no longer preserves Hermodr/Electron/Godot/Unity conformance roles: " + + string.Join(", ", missingPlanSymbols)); + } + + var requiredErgonomicsSymbols = new[] + { + "Hermodr can reconstruct the RTS gameplay surface as an unspecialized Eve", + "Electron may be the shipped RTS shell but cannot own private", + "Godot can become the ARPG equivalent conformance target" + }; + var missingErgonomicsSymbols = requiredErgonomicsSymbols + .Where(symbol => !ergonomicsPlan.Contains(symbol, StringComparison.Ordinal)) + .ToArray(); + if (missingErgonomicsSymbols.Length > 0) + { + throw new InvalidOperationException( + "CultMesh ergonomics plan no longer carries the client runtime conformance gate: " + + string.Join(", ", missingErgonomicsSymbols)); + } +} + static void RequireVerseReplicaTool(string root) { var replicaToolProjectPath = Path.Combine(root, "Aetheria.State.Replica", "Aetheria.State.Replica.csproj"); diff --git a/Aetheria.State/docs/client-runtime-conformance.md b/Aetheria.State/docs/client-runtime-conformance.md new file mode 100644 index 000000000..44515356e --- /dev/null +++ b/Aetheria.State/docs/client-runtime-conformance.md @@ -0,0 +1,56 @@ +# Aetheria Client Runtime Conformance + +This is the client-runtime authority map for removing Unity as a privileged +gameplay body without replacing it with a new privileged runtime. + +The daemon owns Aetheria game state, simulation, generated level content, +assets, render-field declarations, Eve/CultUI surfaces, and typed operations. +Client runtimes lower those surfaces and submit typed operations. A runtime may +own presentation, input hardware, local caches, native buffers, and frame +timing. It must not own gameplay truth merely because it can draw the game. + +## Runtime Roles + +| Runtime | Role | Pass condition | +| --- | --- | --- | +| Hermodr | Unspecialized Eve/browser lowering sanity check for the RTS surface. | It reconstructs the Aetheria RTS gameplay surface from daemon-advertised Eve surfaces, typed state pointers, typed operations, render-field declarations, and CultMesh CDN assets without Aetheria-specific renderer code. | +| Electron | Player-facing Starbridge RTS client. | It renders the same daemon-authored RTS surface through the shared Eve package, with only app shell, launch, packaging, and runtime ergonomics outside Eve. | +| Unity | Current ARPG reference client and demolition target. | It behaves as a renderer/input shell over daemon state and Eve/CultUI surfaces; remaining GameObject, UI Toolkit, camera, input, and presentation adapters are classified shims or renderer-owned concerns. | +| Godot | Future unspecialized Eve/runtime parity target for the ARPG surface. | It reconstructs the ARPG gameplay surface from daemon API plus Eve/CultUI/render-field specs and CultMesh CDN assets, not from a Unity port or daemon-side Godot mode. | + +Hermodr is the purity test for the RTS surface. Electron is the shipped RTS +client. Those are different jobs. If Electron can display something Hermodr +cannot reconstruct from Eve plus daemon API, either Electron is using a private +shortcut or Eve/CultMesh is missing a reusable primitive. + +Godot has the same relationship to the ARPG surface that Hermodr has to the RTS +surface. It should prove the ARPG client can be rebuilt from generic Eve, +CultMesh state, daemon-owned assets, and engine-native lowering. It should not +inherit Unity scene authority, Unity coordinate leakage, Unity UI Toolkit +assumptions, or Unity-only gameplay adapters. + +## Forbidden Shapes + +- No daemon-side `Godot` mode, `Electron` mode, `Hermodr` mode, or `Unity` + behavior branch for gameplay state. +- No renderer-local Aetheria compensator that changes game behavior instead of + being promoted into Eve/CultMesh or daemon-authored state. +- No Aetheria-specific Hermodr plugin for RTS map semantics. +- No Godot port of Unity scene code as the ARPG authority. +- No Electron-only field, asset, or command interpretation that Hermodr cannot + consume through shared Eve/CultMesh primitives. + +## Acceptance Gates + +1. The daemon publishes the RTS surface as Eve/CultUI plus typed state pointers, + operation handles, render-field declarations, and CultMesh CDN asset refs. +2. Hermodr lowers that RTS surface without Aetheria-specific renderer code. +3. Electron renders the same RTS surface through the shared Eve package. +4. The daemon publishes the ARPG surface with the same kind of portable surface + contract. +5. Unity consumes the ARPG contract as a renderer/input shell, with remaining + shims listed for deletion. +6. Godot lowers the ARPG contract without inheriting Unity authority. + +Until those gates pass, Aetheria is daemon-authoritative in pieces, not free of +Unity as a complete client dependency. diff --git a/Aetheria.State/docs/cultmesh-ergonomics-staged-migration-plan.md b/Aetheria.State/docs/cultmesh-ergonomics-staged-migration-plan.md index 3134b6e3e..09a5f541a 100644 --- a/Aetheria.State/docs/cultmesh-ergonomics-staged-migration-plan.md +++ b/Aetheria.State/docs/cultmesh-ergonomics-staged-migration-plan.md @@ -586,6 +586,13 @@ The migration is MVP-complete when: - Eve/CultUI surfaces use typed state pointers and typed operation handles. - Aetheria exposes current stats, inventory, equipment, selection, objects viewport, gravity viewport, and authority-aware operations as typed surfaces. - Unity and browser clients can point at the same Verse and observe/interact with the same simulation according to authority policy. +- Hermodr can reconstruct the RTS gameplay surface as an unspecialized Eve + lowering from daemon API, Eve/CultUI, render-field declarations, and CultMesh + CDN assets; Electron may be the shipped RTS shell but cannot own private + gameplay interpretation. +- Godot can become the ARPG equivalent conformance target by lowering the + daemon-authored ARPG Eve/CultUI contract, not by inheriting Unity scene + authority or triggering daemon-side runtime branches. - Co-located clients can use native slab views where available. - Remote clients use the same facade shape over network routes. - Locality is visible in diagnostics, not application logic. diff --git a/Aetheria.State/docs/verse-authority-implementation-plan.md b/Aetheria.State/docs/verse-authority-implementation-plan.md index 5e0e088c9..d23bc9817 100644 --- a/Aetheria.State/docs/verse-authority-implementation-plan.md +++ b/Aetheria.State/docs/verse-authority-implementation-plan.md @@ -590,15 +590,23 @@ Notes: Status: active. Stage 7A through 7C are implemented for the Electron proving surface; Stage 7D.4 is the current gate after the initial shared C# facade and -typed Unity command reroute. +typed Unity command reroute. The client-runtime conformance contract in +`Aetheria.State/docs/client-runtime-conformance.md` is now the live role map: +Hermodr is the unspecialized Eve sanity check for the RTS surface. Electron is +the player-facing RTS client. Unity is the current ARPG reference shell. Godot +is the future unspecialized Eve parity target for the ARPG surface. -Owner: Unity and Electron runtime clients. +Owner: daemon-authored client surfaces, with Unity and Electron as current +product runtimes and Hermodr/Godot as generic Eve conformance targets. Build: Stage 7 is the client parity stage. It is not an RTS feature pass. Its job is to make Unity and Electron use the same local Verse shape before any more -gameplay is added. +gameplay is added, while keeping the generic conformance question explicit: +Hermodr must be able to reconstruct the RTS surface from Eve plus daemon API +without Aetheria-specific lowering, and Godot must eventually do the same for +the ARPG surface. Implementation slices: @@ -638,6 +646,29 @@ Implementation slices: - neither runtime reads a peer viewport as authoritative gameplay. 7. Only after the parity smoke passes, begin Stage 8 Unity shell demolition. +Hermodr/Electron distinction: + +- Hermodr is a browser/Eve lowering sanity check. It should discover Aetheria + through Odin/CultMesh, fetch daemon-owned surfaces/state/assets, and lower the + RTS gameplay surface without Aetheria-specific map or command code. +- Electron is the Starbridge RTS application shell. It may own launch, + packaging, player-facing ergonomics, and runtime app concerns, but the surface + it renders must be the same Eve/CultMesh contract Hermodr can lower. +- If Electron displays or commands gameplay through a path Hermodr cannot + reconstruct from Eve plus daemon API, the private path is architectural debt. + +Unity/Godot distinction: + +- Unity remains the current ARPG reference and demolition target. It may keep + presentation, input, camera, GameObject, and UI Toolkit adapters only while + they lower daemon-authored state and surfaces. +- Godot is not a Unity port target. It is the ARPG equivalent of the Hermodr + check: a new runtime should reconstruct the ARPG surface from Eve/CultUI, + typed state, typed operations, render-field specs, and CultMesh CDN assets. +- Any daemon-side `Godot` behavior branch would be the wrong cut. If Godot needs + a special gameplay hint, that hint belongs in daemon-authored Eve/CultMesh + surface state or a reusable Eve/CultMesh primitive. + Shared runtime configuration: - verse id;