acdream/docs/plans/2026-07-25-modern-runtime-slice-j.md

Modern runtime Slice J — presentation-independent runtime

Status: J0–J4 COMPLETE; J5 ACTIVE Parent: 2026-07-24-modern-runtime-architecture.md, Slice J Authorization: the user approved Slices F–L, including the otherwise-frozen Slice J gameplay-owner moves, on 2026-07-24 Purpose: move the existing authoritative client kernel into a presentation-independent assembly without creating a second world, changing retail behavior, or making the graphical host a special case.

Slice J is a lifetime-group campaign, not one large move. Each sub-slice keeps the graphical client on the same owner instance, establishes host parity, and deletes the replaced App production path before the next group moves.

1. Fixed invariants

1. RuntimeEntityDirectory is the sole server-GUID/incarnation/local-ID owner. LiveEntityRuntime is the exact-key App projection host. There is never a second GUID map or synchronized gameplay world.
2. Runtime types do not reference AcDream.App, either UI assembly, Silk.NET, OpenAL, Arch, ImGui, a native window, or an OpenGL resource.
3. App projection state is keyed by runtime-issued local entity identity plus incarnation. It may not recover or mirror server GUID ownership.
4. The accepted update order, packet ordering, timestamp gates, outbound cadence, and retail-shaped gameplay algorithms do not change during the extraction.
5. Contracts expose borrowed/immutable views, typed commands, and ordered deltas. They do not expose App render components or deep per-frame object graphs.
6. All clocks, queues, random sources, diagnostics identity, plugin behavior, and mutable caches that can differ between sessions are instance-scoped.
7. Immutable prepared content may be shared. Session state and mutable query scratch may not.
8. Every new owner participates in the structural teardown protocol in parent plan §9.2.1 through acquisition leases and exact acknowledgements.
9. A headless construction path is proved after every coherent move. “No window” means no App, Silk, OpenAL, retained UI, particle, or render assembly is loaded—not a hidden graphical process.
10. Slice I is closed: production collision is flat-authoritative and retains no parsed collision graph. J1 contracts adapt that final canonical owner shape; they may not reintroduce a graph fallback or mirrored collision authority.

2. Target dependency direction

AcDream.App ───────────────► AcDream.Runtime
AcDream.Headless (Slice K) ─► AcDream.Runtime
                               ├──► AcDream.Core.Net
                               ├──► AcDream.Core
                               ├──► AcDream.Content
                               └──► AcDream.Plugin.Abstractions

AcDream.Runtime -X► AcDream.App / AcDream.UI.* / Silk.NET / OpenAL / Arch

Runtime-emitted entity events contain incarnation, transform, flags, and property deltas only. An App-side projection adapter translates them into IRenderScene journal operations. Render vocabulary never enters Runtime.

3. Teardown transaction

The exact order is:

1. cancel scheduler/session generations and make commands inert;
2. detach producers, drain accepted ordered events, and poison queues;
3. withdraw and acknowledge graphical presentation;
4. retire session residence and GPU-backed owners through existing fences;
5. dispose the process-owned immutable ContentStore only after every runtime and host has completed.

Completed stages never replay. Failure retains the exact remaining suffix. Logout, reset, mid-portal disconnect, reconnect replacement, construction rollback, and native close all traverse the same transaction.

4. Execution slices

J0 — boundary, plan, and dependency enforcement

Completed 2026-07-25.

• Add AcDream.Runtime and AcDream.Runtime.Tests.
• Permit references only to Core, Core.Net, Content, and Plugin.Abstractions.
• Add App → Runtime as the future host dependency; Runtime never references App.
• Add direct-reference, dependency-closure, source-project, and assembly-load guards that fail if a presentation/backend dependency enters Runtime.
• Add only an assembly boundary marker; do not introduce a facade GameRuntime, mirror state, or move behavior in J0.
• Pin this lifetime-group plan and parent-plan teardown protocol.

Gate: Release build and full tests pass; the Runtime test process loads no App, UI, Silk, OpenAL, Arch, or ImGui assembly; graphical behavior is byte-for-byte unchanged because no runtime path changed.

Evidence: four focused dependency tests pass, the Release solution builds with zero errors, and the complete Release suite passes 8,406 tests with five pre-existing skips. Exact rollback:

git revert b632672e5ccabfb44c551e08f1c411ab2669c44a

J1 — read, command, event, clock, and lifecycle contracts

Completed 2026-07-25 at 854d9e9c.

• Define IGameRuntimeView, typed command interfaces, ordered event/delta records, instance clock, lifecycle states, generation tokens, and teardown acknowledgements.
• Build App adapters over the current owners first. Adapters borrow; they do not copy mutable collections or own lifetime.
• Add a normalized parity trace of accepted inbound events, runtime commands, state revisions, and lifecycle edges.
• Prove press-time graphical input reaches the same current owners through the command contract with no extra frame of latency.

Gate: adapter and direct-host traces are identical over deterministic session, entity, inventory, chat, movement, and portal fixtures; no canonical owner has moved yet.

Result:

• AcDream.Runtime owns immutable borrowed-view contracts, typed commands, ordered deltas, an instance clock, generation tokens, lifecycle snapshots, and retryable teardown acknowledgements.
• Focused App adapters borrow the current canonical owners. They create no second GUID map, state store, command queue, or frame boundary.
• Startup plus press-time selection, movement, and combat input now traverse the typed command seam synchronously and still mutate the exact same owners.
• Runtime tests pass 13/13, App tests pass 3,838 with three skips, and the complete Release solution passes 8,424 tests with five skips.
• The exact-binary connected gate at logs/connected-world-gate-20260725-190953/report.json passed six capped world checkpoints plus a fresh uncapped reconnect. Both processes exited gracefully with no failures.

Exact rollback:

git revert 854d9e9cd13092bd5aaa3cf025d73eeb4600e9f8

J2 — session lifetime and ordered transport group

Completed 2026-07-25 at 75930787.

Detailed execution plan: 2026-07-25-modern-runtime-slice-j2.md.

• Remove App presentation dependencies from LiveSessionController, LiveSessionHost, lifecycle host, event router, and command router.
• Move the same owner instances into Runtime with Core.Net transport and instance-scoped clocks/queues.
• Preserve bind-before-connect, publish-after-EnterWorld, exact generation rechecks, receive ordering, ack placement, graceful F653/disconnect, and retryable replacement.
• Let App provide only endpoint credentials, presentation bindings, and graphical lifecycle acknowledgements.

Gate: connected login/logout/reconnect and malformed/reentrant lifecycle suites produce the same packet/order trace; no-window construction can connect and disconnect without loading App or a backend.

Result: Runtime now owns the one WorldSession generation, ordered inbound route, connect/enter/tick/replace transaction, and exact retryable teardown acknowledgement. App keeps only connection-option conversion, graphical callbacks, and one borrowed inertable UI command projection. The Release build, 79 Runtime tests, 3,776 App tests / 3 skips, 8,428 complete tests / 5 skips, and the exact-binary seven-checkpoint connected gate pass with graceful exits. Evidence: ../research/2026-07-25-slice-j2-session-lifetime-closeout.md.

Exact rollback:

git revert 75930787741db40a83eab8663e4464dce8d687ba

J3 — canonical identity, properties, and object-table group

Detailed execution plan: 2026-07-25-modern-runtime-slice-j3.md.

Completed 2026-07-26. Runtime owns accepted entity wire state and the only canonical identity/incarnation/local-ID directory. App's LiveEntityProjectionStore and every materialized presentation/spatial workset are keyed by exact RuntimeEntityKey; the temporary GUID-shaped compatibility view is deleted. RuntimeEntityObjectLifetime now owns the exact entity directory and live ClientObjectTable; App, routing, interaction, and UI borrow both. Exact J3.5 binary ce3ac310 publishes one committed per-generation Runtime entity/object delta stream, issues identity before App hydration, and supplies direct allocation-free views to graphical and no-window hosts. App reconstructs neither entity nor inventory state/events. J3.6 at 119b7c11 makes every canonical commit, callback, teardown receipt, reset, and direct disposal failure-safe and proves the full owner ledger converges to zero. Its 8,484 Release tests / 5 skips, exact seven-checkpoint lifecycle/reconnect gate, and canonical nine-stop route pass. Evidence: ../research/2026-07-26-slice-j3-6-lifetime-closeout.md.

• Strip renderer, particle, Wb, and streaming components from the canonical record into an App projection store keyed only by local identity/incarnation.
• Move LiveEntityRuntime, accepted spawn/state/property timestamps, ClientObjectTable, container/inventory indices, vitals, enchantments, spell state, target/combat state, and their exact teardown into Runtime.
• Emit ordered create/update/rebucket/hidden/withdraw/delete deltas.
• Keep DAT-backed visual hydration, render registrations, effects, lights, paperdoll, selection markers, and radar projections in App.

Gate: GUID reuse, equal-generation updates, parent/child identity, inventory/container mutations, Hidden, delete/recreate, and portal teardown match current traces; App has no server-GUID ownership.

J4 — chat, inventory, magic, and gameplay-state services

Completed 2026-07-26.

Detailed execution plan: 2026-07-26-modern-runtime-slice-j4.md.

• Move canonical chat history/channel state, inventory transactions, spell and component state, enchantments, vitals, skills/attributes, and gameplay cooldown state by coherent owner groups.
• Keep retained panel layout, text shaping, icons, paperdoll rendering, and status-bar presentation in App.
• Route plugins and future bots through the same typed command/event surface as graphical UI.

Gate: deterministic command/response traces and graphical ViewModel revisions match; no Runtime type references UI abstractions.

J4.1 completed at c9d25ade: Runtime now owns the exact chat transcript, reply/retell targets, negotiated Turbine rooms, friends, and squelch state. Graphical UI, devtools, command routing, plugins/current-runtime projections, and no-window consumers borrow that one graph. Its 152 Runtime tests, 3,765 App tests / 3 skips, 8,494 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J4.2 completed at 011efbea: Runtime owns external-container, item-mana, shortcut/component, shared-busy, use-reservation, and one-request-at-a-time state while borrowing J3's exact object table. Its 157 Runtime tests, 3,770 App tests / 3 skips, 8,515 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J4.3 completed at d02a12ce: RuntimeCharacterState owns the coupled spellbook and local player sheet; content, routing, retained UI, reset, and shutdown borrow it, and the duplicate desired-component snapshot is gone. Its 162 Runtime tests, 3,772 App tests / 3 skips, 8,522 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J4.4 completed at dcb61efb: Runtime owns character options and server run/jump projections, exposes exact borrowed J4 gameplay views, and routes retained UI plus future no-window hosts through one synchronous generation-gated state-command seam. Its 169 Runtime tests, 3,777 App tests / 3 skips, 8,534 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J4.5 completed at 89e6b207: Runtime owns the one shortcut manager, graphical command effects flow through the exact Runtime inventory/character owners, the item-use UI cannot construct a second transaction gate, and the combined failure-safe ownership ledger converges. Its 175 Runtime tests, 3,780 App tests / 3 skips, 8,544 complete Release tests / 5 skips, exact-binary lifecycle/reconnect gate, and canonical nine-stop route pass. Evidence: ../research/2026-07-26-slice-j4-5-gameplay-state-closeout.md.

Detailed execution begins with a source-ownership inventory. Move one coherent lifetime group at a time in this order:

1. chat history/channel/command state;
2. inventory transaction and gameplay item-use state that is not already canonical in RuntimeEntityObjectLifetime;
3. learned spells, formulas/components, enchantments, and cast/cooldown state;
4. vitals, skills, attributes, advancement, and character-option state;
5. plugin/bot borrowed views and typed commands over those same owners;
6. delete every replaced App owner/adapter, then run the combined no-window, graphical parity, teardown, Release, lifecycle/reconnect, and nine-stop gates.

Panel trees, text layout, icons, 3-D paperdolls, status bars, and animation/VFX remain App presentation. The inventory object collection already moved in J3; J4 must borrow it rather than create another inventory model.

J5 — movement, physics, interaction, and combat group

Active 2026-07-26. Detailed execution begins with a source/owner inventory and a named-retail ordering matrix. Each coherent move must preserve the accepted connected interaction, facing, projectile, and collision behavior. The executable sub-slice ledger, presentation boundary, acceptance gates, and rollback discipline live in 2026-07-26-modern-runtime-slice-j5.md.

J5.1 completed at b298f99f. RuntimeActionState owns the one exact selection, combat, and temporary target-mode graph. Program, plugins, retained UI, session routing, typed commands/views, and shutdown borrow its children; the App interaction-state class and private controller fallback are gone. Its 182 Runtime tests, 3,779 App tests / 3 skips, 8,550 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J5.2 completed at f5f7b417. Runtime now owns the use throttle and exact use/appraisal/pickup transaction identities, typed ordered interaction FIFO, and post-arrival pickup token while borrowing J4's sole busy/request gate. App retains picking, movement/transport, lighting, toasts, drag/drop, and pending-slot presentation. Its 197 Runtime tests, 3,775 App tests / 3 skips, 8,561 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J5.3 completed at 20df9d15: Runtime owns the exact attack, target, combat-mode, and spell-cast intent children while App bars, input adapters, content queries, and transport borrow them. Its 223 Runtime tests, 3,754 App tests / 3 skips, 8,566 complete Release tests / 5 skips, and exact-binary seven-checkpoint lifecycle/reconnect gate pass. J5.4 completed at aa3f4a60: Runtime owns the exact local movement controller, construction seam, autorun latch, typed view, and outbound MTS/jump/AP cadence; App input and direct commands borrow the same owner. Its 303 Runtime tests, 3,716 App tests / 3 skips, 8,575 complete Release tests / 5 skips, exact-binary lifecycle/reconnect gate, and canonical nine-stop movement route pass. J5.5 completed at 7e6033d0: Runtime owns the per-session engine/cache/ scratch/shadow/collision/body/host/remote/workset graph; App publishes prepared collision and projects committed snapshots. Its 314 Runtime tests, 3,718 App tests / 3 skips, 8,588 complete Release tests / 5 skips, exact-binary lifecycle/reconnect gate, and canonical nine-stop collision/ movement route pass. J5.6 projectile runtime is next. Evidence: ../research/2026-07-26-slice-j5-1-canonical-action-state.md and ../research/2026-07-26-slice-j5-2-interaction-transactions.md and ../research/2026-07-26-slice-j5-3-combat-magic-intent.md and ../research/2026-07-26-slice-j5-4-local-movement-ownership.md and ../research/2026-07-26-slice-j5-5-physics-remote-ownership.md.

• Move presentation-free movement interpretation, authoritative/predicted physics state, selection identity, approach/use transactions, combat intent, projectiles, and outbound movement cadence.
• Replace input and camera dependencies with typed commands and runtime views.
• Keep camera, mouse look, selection markers/highlight, combat/spell bars, animated pose composition, sounds, and particles in App.
• Share immutable flat collision content while retaining per-session transition scratch.

Gate: bit-identical collision/trajectory fixtures, target-facing and auto-approach traces, outbound packet timing, combat/magic commands, and graphical feel gates remain unchanged.

J6 — world, portal, environment, and projection handshake

• Move authoritative teleport/session cell identity, world clock, weather state, and reveal-generation state required by gameplay.
• Keep streaming publication, terrain/EnvCell rendering, portal tunnel, materialization VFX, sky drawing, audio, and UI in App.
• Define the destination-ready/withdrawal acknowledgements between Runtime and the graphical or headless host without making visual readiness gameplay authority.

Gate: fresh login, repeated recall/portal, world edge, dungeon, reconnect, and mid-portal disconnect traces match; the graphical screenshots remain accepted.

J7 — one GameRuntime composition root

• Compose all moved lifetime groups into one instance-scoped GameRuntime.
• Make GameWindow/App own exactly one Runtime instance plus presentation adapters.
• Delete temporary direct-owner adapters and every superseded App production path.
• Register all Runtime and App projection owners with structural acquisition leases and the exact teardown transaction.

Gate: graphical connected lifecycle/resource routes pass with no mirrored state, no extra update latency, and no performance regression.

J8 — no-window integration and Slice J closeout

• Build a transport/content test host that constructs Runtime directly.
• Connect, enter world, receive chat/inventory/world updates, move, use, fight/cast through deterministic fixtures, portal, log out, reconnect, and tear down without loading App/Silk/OpenAL/UI.
• Add cancellation, failure injection, same-process multiple-instance isolation, credential-safe diagnostics, and zero-presentation-allocation gates.
• Update architecture, milestone, roadmap, issue/divergence ledgers, and durable memory.

Final gate: Release build/full tests, connected graphical route, no-window integration, resource teardown, packet/order/timing parity, and the user visual matrix all pass. Slice K may then build the Linux multi-session host without another gameplay extraction.

5. Commit order

1. arch(runtime): establish presentation-independent boundary
2. feat(runtime): define borrowed views commands and ordered events
3. refactor(runtime): move session lifetime and ordered transport
4. refactor(runtime): move canonical entity and property ownership
5. refactor(runtime): move gameplay state services
6. refactor(runtime): move movement physics interaction and combat
7. refactor(runtime): separate world authority from presentation
8. refactor(runtime): compose one graphical game runtime
9. test(runtime): close no-window parity and teardown

Each commit is independently buildable and retains an exact rollback command in this plan before its connected gate.