@vgai/engine 0.5.21 → 0.5.23

package/dist/runtime/game.js

@@ -16,7 +16,7 @@ import { createDebugRegistry, DebugError, registerDebugRegistry, } from './debug
 import { createGameplayRngTrap, registerGameplayRngTrapControl } from './gameplay-rng-trap';
 import { createStateBridge } from './state-bridge';
 /**
- * WO-P13 — the tail of `PHASE_ORDER` that presents rather than simulates, and
+ * The tail of `PHASE_ORDER` that presents rather than simulates, and
  * therefore runs once per DISPLAY frame (`runRenderFrameImpl`) rather than
  * once per fixed substep. The same two phases `runTicks`' `skipRenderPhases`
  * fast-forward skips and `render-control.ts`'s `renderOnce()` drives — one
@@ -31,7 +31,7 @@ const DISPLAY_RATE_PHASES = PHASE_ORDER.filter((phase) => phase === SystemPhase.
  * slice or later ones) gets identical throw behavior.
  */
 export function createRootInstance(init) {
-    const { id, kind, pausable = true, adapter, mounted, scene, stage, container, physics, collisions, physics2d, camera, frame, } = init;
+    const { id, kind, pausable = true, adapter, mounted, scene, stage, container, physics, collisions, physics2d, camera, frame, binding = null, } = init;
     // A three world with no scene has nothing for `threeScene()` to return —
     // fail loudly HERE, at construction, rather than letting `threeScene()`
     // throw its generic "not a three world" message later for a world whose
@@ -64,11 +64,11 @@ export function createRootInstance(init) {
     // read, so this wraps `mounted.dispose` in place (mutating the SAME mount
     // object every holder of `mounted` shares — calling `mounted.dispose()`
     // directly, exactly like calling `world.mounted.dispose()`, trips this)
-    // to flip a private flag, and wraps the frame hooks so they silently no-op
-    // once that flag is set. `runFrame` itself needs no knowledge of disposal
-    // — a disposed world is skipped by construction from the next call
-    // onward. (The opaque-world `mounted.update` fallback path is unaffected
-    // by this guard — no opaque-mount two-world scenario exists yet to need it.)
+    // to flip a flag this instance exposes as `disposed`, and wraps the frame
+    // hooks so they silently no-op once it is set. `runFrame` reads `disposed`
+    // and skips the world outright, which is what also covers the OPAQUE
+    // `mounted.update` fallback — the path every three root takes now that a
+    // mount is a plain `RootAdapter` with no phase-partitioned entry point.
     let disposed = false;
     const originalDispose = mounted.dispose.bind(mounted);
     mounted.dispose = () => {
@@ -100,6 +100,10 @@ export function createRootInstance(init) {
         physics2d,
         camera,
         frame: guardedFrame,
+        binding,
+        get disposed() {
+            return disposed;
+        },
         threeScene() {
             if (kind !== 'three' || !scene) {
                 throw new Error(`RootInstance "${id}" (kind: ${kind}): threeScene() requested but this world is not ` +
@@ -130,22 +134,6 @@ export function createRootInstance(init) {
         },
     };
 }
-/**
- * Type guard for whether a `MountedThreeRoot` is a first-party
- * `SetupThreeRootAdapter` mount (has a live `GameContext` at `.ctx`). Used to
- * decide whether a world's `physics`/`collisions`/`camera` can be populated
- * from it — an external
- * adapter's mount has none of these first-party handles.
- *
- * Checks the `firstParty: true` brand (checklist item 1), NOT `'ctx' in
- * mounted` — a foreign mount may carry an unrelated `ctx` key, so a
- * structural `'ctx' in mounted` check would misfire. The probe is a plain property read, not an
- * `instanceof`/value import of `setup-three-root-adapter.ts` — the
- * `MountedSetupThreeRoot` import above stays type-only.
- */
-export function isFirstPartyMounted(mounted) {
-    return mounted.firstParty === true;
-}
 /**
  * Read an owner's Rapier handles, treating an absent pair as "this owner holds
  * no rigid bodies" — the honest reading for a world (R3F, or a bare
@@ -162,15 +150,14 @@ function readRapierHandles(owner) {
  * only *when*; this is the *what*, and it lives here because it is the runtime
  * that knows about Rapier and shared geometry.
  *
- * The order mirrors `adapter/setup-three-root-adapter.ts`'s world teardown for
+ * The order mirrors `adapter/world3d-react/r3f-root-factory.tsx`'s world teardown for
  * ONE subtree. Within the physics step,
  * `rapierWorld.removeRigidBody(body)` comes BEFORE `physics.remove(node)`: the
  * registry's `remove()` only drops index entries, so reversing the two leaks
  * the Rapier body.
  *
- * `owners` is every world that could own part of the subtree — `createGame`
- * passes all of its first-party three roots as their `GameContext`, a bare
- * adapter mount passes its own ctx. `physics.get` is a no-op for a node the
+ * `owners` is every world that could own part of the subtree. `physics.get`
+ * is a no-op for a node the
  * owner does not own, so offering the subtree to each is safe.
  *
  * Safe on an object already removed or already disposed: `removeFromParent` on
@@ -212,13 +199,17 @@ export function disposeDebrisSubtree(obj, owners) {
     }
 }
 /**
- * The {@link DebrisOwner}s one registered world contributes: its `GameContext`
- * when the mount is first-party, else nothing. Written as a standalone function
+ * The {@link DebrisOwner}s one registered world contributes. Written as a
+ * standalone function
  * so `createGame`'s clock disposer is one line and the "which mounts count"
  * rule has exactly one home.
  */
-function debrisOwnersOf(world) {
-    return isFirstPartyMounted(world.mounted) ? [world.mounted.ctx] : [];
+function debrisOwnersOf(_world) {
+    // No mount carries first-party Rapier handles: physics is a declared
+    // system built inside the world's own tree, and the library owns its
+    // bodies' lifecycles there. The owner list stays as the disposal seam's
+    // shape; today it is always empty.
+    return [];
 }
 /**
  * Construct the (host-internal) Game shell. Callers: `createGameRuntime`
@@ -233,7 +224,7 @@ export function createGame(opts) {
     const input = new InputManager();
     const stateBridge = createStateBridge();
     // D15 (T-D15.1) — the game-scoped seeded-random surface every world's
-    // `ctx.random` aliases (see `setup-three-root-adapter.ts`'s `ctx.random =
+    // `ctx.random` aliases (see `world3d-react/r3f-root-factory.tsx`'s `ctx.random =
     // ...`, wired the same way `ctx.debug` is just below). Constructed
     // unconditionally (cheap — a handful of closures) regardless of whether
     // this project ever declares `determinism.seededRandom`; only the BOOT
@@ -266,7 +257,7 @@ export function createGame(opts) {
     // the CURRENT values.
     let tick = 0;
     let simT = 0;
-    // WO-P13 — the display-rate half. `renderAlpha` is the last alpha
+    // The display-rate half. `renderAlpha` is the last alpha
     // `runRenderFrameImpl` presented at (0 until a host drives one); the set is
     // the `RenderStepped`-shaped registry `Game.onRenderStep` feeds. Deliberately
     // NOT beside `tick`/`simT` in meaning: neither of these ever advances sim
@@ -282,7 +273,7 @@ export function createGame(opts) {
     //
     // The disposer is supplied HERE rather than inside the clock because
     // `core/sim-clock.ts` deliberately knows nothing about Rapier or shared
-    // geometry. It mirrors `setup-three-root-adapter.ts`'s world teardown
+    // geometry. It mirrors `world3d-react/r3f-root-factory.tsx`'s world teardown
     // ordering for ONE subtree.
     const simClock = createSimClock({
         // Every mount that could own part of the subtree is offered it:
@@ -335,7 +326,17 @@ export function createGame(opts) {
     // above's "once per game instance" idiom.
     const warnedSystemAdapterKeys = new Set();
     const systemAdapterListeners = new Set();
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one cohesive merge-with-collision-report walk (per-world × per-key); splitting the collision-warn branch out would obscure that it's part of the same pass, not reduce real complexity
+    /** Per-root slots installed by `installDeclaredSystemAdapters` — the native
+     *  module surface's static `systems` declaration. Merged BEFORE the same
+     *  root's live `mounted.systems` below, so during migration a lingering
+     *  component registration for a declared slot is shadowed (with the
+     *  standard warning) rather than silently winning by running later. */
+    const declaredSystemAdapters = new Map();
+    /** Per-root POSITIVE ABSENCES from the same declaration — `absent(reason)`
+     *  slots. Nothing binds them (there is nothing to bind); they are kept so a
+     *  reader can tell an answered absence from an unasked question. */
+    const declaredAbsences = new Map();
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one cohesive merge-with-collision-report walk (per-world × per-source × per-key); splitting the collision-warn branch out would obscure that it's part of the same pass, not reduce real complexity
     function computeSystemAdapters() {
         // Debug is game-scoped: React hooks, probes, and the built-in time
         // provider all register with the one registry created above, regardless
@@ -345,10 +346,7 @@ export function createGame(opts) {
         // intentional shared registration it is.
         const result = { debug: debugRegistry.adapter };
         const ownerRootId = new Map([['debug', '(game)']]);
-        for (const world of roots) {
-            const adapters = world.mounted.systems;
-            if (!adapters)
-                continue;
+        const merge = (owner, adapters, quietKeys) => {
             for (const key of Object.keys(adapters)) {
                 if (adapters[key] === undefined)
                     continue;
@@ -360,18 +358,35 @@ export function createGame(opts) {
                     // collision, so it must never warn.
                     if (result[key] === adapters[key])
                         continue;
+                    // A world's own DECLARED slot overriding that same world's
+                    // substrate-seeded default (the three lane pre-seeds physics/audio/
+                    // renderDebug into `mounted.systems`) is the door working as
+                    // intended, not a collision — same silence `ctx.
+                    // registerSystemAdapter` gives the same override. Cross-root
+                    // collisions still warn.
+                    if (quietKeys?.has(key))
+                        continue;
                     if (!warnedSystemAdapterKeys.has(key)) {
                         warnedSystemAdapterKeys.add(key);
                         // biome-ignore lint/suspicious/noConsole: structured, greppable — mirrors this file's own reportGateShortfallOnce's deliberate direct console.warn just above
-                        console.warn(`[game] systemAdapters: "${key}" is registered by both world "${existingOwner}" and ` +
-                            `world "${world.id}" — the FIRST registration ("${existingOwner}") wins; the later ` +
+                        console.warn(`[game] systemAdapters: "${key}" is registered by both ${existingOwner} and ` +
+                            `${owner} — the FIRST registration (${existingOwner}) wins; the later ` +
                             'one is shadowed (game-scoped system adapters).');
                     }
                     continue;
                 }
                 // biome-ignore lint/suspicious/noExplicitAny: SystemAdapters is a plain optional-field record; the per-key copy is correct by construction (same key on both sides), just not expressible without a cast
                 result[key] = adapters[key];
-                ownerRootId.set(key, world.id);
+                ownerRootId.set(key, owner);
+            }
+        };
+        for (const world of roots) {
+            const declared = declaredSystemAdapters.get(world.id);
+            if (declared)
+                merge(`world "${world.id}" (declared systems export)`, declared);
+            const adapters = world.mounted.systems;
+            if (adapters) {
+                merge(`world "${world.id}"`, adapters, declared ? new Set(Object.keys(declared)) : undefined);
             }
         }
         return result;
@@ -405,6 +420,14 @@ export function createGame(opts) {
     // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: fans out TWO independent capability gates (loop, audio) with the same "call it, else report once" shape per world — splitting the two gates into separate loops would duplicate the fan-out, not reduce real complexity
     function setRootGates(next) {
         for (const world of roots) {
+            // A disposed world stays in `roots` (there is no `unregisterRoot`), and
+            // its adapter's `setPaused`/`systems.audio` reach a renderer, ticker or
+            // audio graph that `dispose()` already released — the same reason
+            // `runFrame`/`runRenderFrame`/`runTicks` skip it. Without this, a
+            // pause/resume after a partial teardown calls into freed resources, and
+            // the audio leg re-mutes a context that no longer exists.
+            if (world.disposed)
+                continue;
             if (!world.pausable)
                 continue; // pausable:false roots are untouched by design
             if (world.mounted.drivesOwnLoop) {
@@ -435,14 +458,14 @@ export function createGame(opts) {
         if (rngTrapEnabled)
             rngTrap.enable();
         profiler.beginFrame();
-        // D15/T-D15.4 + WO-P13: the render-phase skip. Two callers set it, for the
+        // The render-phase skip. Two callers set it, for the
         // same reason — this substep is not the thing that paints. `runTicks`'s
         // `render: 'none'|'last'` fast-forward sets it on every tick it doesn't
         // want to paint (see `runTicks`'s doc comment on `GameInternal`), and a
         // DISPLAY-RATE host sets it on every substep because `runRenderFrame`
-        // paints once per real frame instead. Unlike `onlyFrozen` below it is no
-        // longer internal-only: it is part of the public `GameInternal.runFrame`
-        // signature, since an external host is now one of those two callers.
+        // paints once per real frame instead. Unlike `onlyFrozen` below it is not
+        // internal-only: it is part of the public `GameInternal.runFrame`
+        // signature, since an external host is one of those two callers.
         const skipRenderPhases = frameOpts?.skipRenderPhases ?? false;
         // `onlyFrozen` is internal-only (not part of the public `GameInternal.runFrame`
         // signature — no external caller sets it) — `Game.play.step()` below is the
@@ -460,6 +483,8 @@ export function createGame(opts) {
         inputFrameActive = false;
         for (let i = 0; i < n; i++) {
             const world = roots[i];
+            if (world.disposed)
+                continue;
             if (onlyFrozen) {
                 if (paused && world.pausable && !world.mounted.drivesOwnLoop) {
                     inputFrameActive = true;
@@ -487,6 +512,8 @@ export function createGame(opts) {
         if (!onlyFrozen) {
             for (let i = 0; i < n; i++) {
                 const world = roots[i];
+                if (world.disposed)
+                    continue;
                 if (!world.mounted.drivesOwnLoop)
                     continue;
                 if (!paused || !world.pausable || !world.mounted.setPaused) {
@@ -512,6 +539,8 @@ export function createGame(opts) {
                     systems.runPhase(phase, dt);
                 for (let i = 0; i < n; i++) {
                     const world = roots[i];
+                    if (world.disposed)
+                        continue;
                     if (world.mounted.drivesOwnLoop)
                         continue;
                     if (!(paused && world.pausable))
@@ -528,6 +557,8 @@ export function createGame(opts) {
             }
             for (let i = 0; i < n; i++) {
                 const world = roots[i];
+                if (world.disposed)
+                    continue;
                 if (world.mounted.drivesOwnLoop)
                     continue;
                 if (!(paused && world.pausable))
@@ -563,6 +594,8 @@ export function createGame(opts) {
                     systems.runPhase(phase, dt);
                     for (let i = 0; i < n; i++) {
                         const world = roots[i];
+                        if (world.disposed)
+                            continue;
                         if (world.mounted.drivesOwnLoop)
                             continue;
                         // D10/T7.6: a `pausable` world under an active pause
@@ -590,6 +623,8 @@ export function createGame(opts) {
             }
             for (let i = 0; i < n; i++) {
                 const world = roots[i];
+                if (world.disposed)
+                    continue;
                 if (world.mounted.drivesOwnLoop)
                     continue;
                 // A fully-frozen world gets no `endFrame`/opaque-`update` call either —
@@ -645,7 +680,7 @@ export function createGame(opts) {
             rngTrap.disable();
     }
     /**
-     * WO-P13 — one display frame's PRESENTATION pass. See
+     * One display frame's PRESENTATION pass. See
      * `GameInternal.runRenderFrame`'s doc comment for the contract; this is the
      * `preRender`+`render` slice of `runFrameImpl`'s phase loop, lifted out and
      * driven by the loop's own per-real-frame callback instead of by the substep
@@ -693,6 +728,8 @@ export function createGame(opts) {
             systems.runPhase(phase, displayDt);
             for (let i = 0; i < n; i++) {
                 const world = roots[i];
+                if (world.disposed)
+                    continue;
                 if (world.mounted.drivesOwnLoop)
                     continue;
                 // D10/T7.6, carried over verbatim in substance: a frozen world still
@@ -741,6 +778,26 @@ export function createGame(opts) {
             for (const listener of systemAdapterListeners)
                 listener();
         },
+        get declaredSystemAbsences() {
+            return [...declaredAbsences.values()].flat();
+        },
+        installDeclaredSystemAdapters(rootId, slots, absent = []) {
+            if (!roots.some((w) => w.id === rootId)) {
+                throw new Error(`installDeclaredSystemAdapters: no mounted root is named "${rootId}" ` +
+                    `(mounted: ${roots.map((w) => `"${w.id}"`).join(', ') || 'none'}).`);
+            }
+            if (declaredSystemAdapters.has(rootId)) {
+                throw new Error(`installDeclaredSystemAdapters: root "${rootId}" already installed its declared ` +
+                    'systems — a declaration is static and installs exactly once per mount.');
+            }
+            declaredSystemAdapters.set(rootId, slots);
+            // ALWAYS set, never merge: a re-install (an HMR of the entry's `systems`
+            // table) that dropped an `absent()` marker must also drop the recorded
+            // absence, or the coverage report keeps printing a game statement the
+            // game no longer makes.
+            declaredAbsences.set(rootId, absent);
+            gameInternal.notifySystemAdaptersChanged();
+        },
         input,
         state: stateBridge,
         play: {
@@ -769,6 +826,11 @@ export function createGame(opts) {
                 // not paused, nothing here runs — step() is a whole-call no-op.
                 if (paused) {
                     for (const world of roots) {
+                        // Same disposed-world guard `runFrameImpl` (and `setRootGates`)
+                        // make: a disposed world's `mounted.step` drives a loop whose
+                        // resources are already freed.
+                        if (world.disposed)
+                            continue;
                         if (!world.pausable || !world.mounted.drivesOwnLoop)
                             continue;
                         if (!world.mounted.setPaused)
@@ -794,8 +856,8 @@ export function createGame(opts) {
             // `endFrame` called once per registration) and double-dispose-wrapped
             // (`createRootInstance` wraps `mounted.dispose` in place — a second
             // wrap would flip `disposed` and call through on ITS OWN wrapped
-            // `originalDispose`, which is harmless today only by accident of
-            // `SetupThreeRootAdapter.dispose` being idempotent; a foreign adapter
+            // `originalDispose`, which would be harmless only if the adapter's
+            // dispose happened to be idempotent; a foreign adapter
             // has no such guarantee). Reject it outright instead.
             if (roots.some((w) => w.mounted === world.mounted)) {
                 throw new Error(`Game.registerRoot: world "${world.id}" shares its \`mounted\` object with an ` +
@@ -805,14 +867,14 @@ export function createGame(opts) {
             roots.push(world);
             gameInternal.notifySystemAdaptersChanged();
             // Notify state-bridge subscribers THE INSTANT the world list changes —
-            // not just at the next completed `runFrame`. Root-cause fix for the
-            // "roots: " (empty) hang in `36-r3f-first-party.spec.ts` on CI (gate
-            // 4): `mountAllRootSpecs` (`create-runtime.ts`) mounts roots
+            // not just at the next completed `runFrame`. Otherwise a UI that lists
+            // worlds hangs on an empty list: `mountAllRootSpecs`
+            // (`create-runtime.ts`) mounts roots
             // SEQUENTIALLY, and a react world's `adapter.mount()`
             // (`resolveDefaultReactAdapter`/`mountOneReactRoot`) renders its tree —
             // synchronously in some React builds, but React 19's concurrent
             // renderer does NOT guarantee a synchronous first commit (see
-            // `r3f-adapter.tsx`'s own doc comment on `onCreated`) — BEFORE the
+            // `r3f-root-factory.tsx`'s own doc comment on `onCreated`) — BEFORE the
             // caller calls `registerRoot` for that very world. A `useWorldState`
             // selector reading `g.roots` can therefore render for the first time
             // while `roots` is still missing entries that register moments later.
@@ -856,15 +918,11 @@ export function createGame(opts) {
             // world mount), eroding the signal for a genuinely un-observable
             // ingested world.
             // A HOST-DRIVEN mount (`drivesOwnLoop: false`, notably the R3F adapter)
-            // is observable through `Game.state` even though it does not carry the
-            // classic scene adapter's `firstParty` brand: it ticks inside
-            // `runFrame`, so the frame-versioned bridge covers it. Requiring a
+            // is observable through `Game.state` when it ticks inside
+            // `runFrame` — the frame-versioned bridge covers it. Requiring a
             // foreign-world `observe` bridge there produces a false warning while
             // the canonical bridge is already live.
-            if (!isFirstPartyMounted(world.mounted) &&
-                world.mounted.drivesOwnLoop &&
-                world.kind !== 'dom' &&
-                !world.mounted.observe) {
+            if (world.mounted.drivesOwnLoop && world.kind !== 'dom' && !world.mounted.observe) {
                 console.warn(`[game] world "${world.id}" (kind: ${world.kind}, adapter: "${world.adapter.id}"): ` +
                     'no state bridge — this mounted game has no `observe` (RootStateObserver); ' +
                     'react HUDs/useRootObservation cannot subscribe to its state.');
@@ -952,7 +1010,7 @@ export function createGame(opts) {
             // root's `mounted.dispose()`, whereas a per-root teardown may be ending
             // just one sub-session while sibling roots keep running (see the
             // disposed-world guard in `runFrame`). It used to be disposed from
-            // `setup-three-root-adapter.ts`'s teardown, which meant disposing one of
+            // `world3d-react/r3f-root-factory.tsx`'s teardown, which meant disposing one of
             // two three roots froze `now()` for the whole Game, rejected the other
             // world's pending `delay`s and turned its `after()` calls into silent
             // no-ops. Note the asymmetry that gives the bug away: `seededRandom` and

package/dist/runtime/mount-game.d.ts

@@ -80,22 +80,6 @@ export declare function isAdapterRegistered(kind: string): boolean;
  * registry without cross-test leakage.
  */
 export declare function __clearAdapterSurfaceRegistryForTests(): void;
-/**
- * A ready-to-register {@link AdapterSurfaceFactory} for `kind: 'three'` roots
- * that follow the first-party entry-module convention (`export const
- * adapter` and/or `export async function setup`). Threejs is safe to
- * ship as an exported convenience (unlike canvas/react) because `three`/
- * `SetupThreeRootAdapter` are already unconditional engine dependencies —
- * see `mount-manifest.ts`'s header comment. Still never auto-registered:
- * the registry itself stays zero-policy (see this file's header comment) —
- * a caller opts in with `registerAdapter('three', defaultThreeAdapterFactory)`.
- *
- * Resolution mirrors `mount-manifest.ts`'s own `resolveThreeAdapter` branch
- * order: an entry module's `adapter` export wins outright; else its `setup`
- * export (wrapping via `fromSetup` happens inside `mountManifestRoots`
- * itself — this factory just returns the `MountEntry` shape).
- */
-export declare const defaultThreeAdapterFactory: AdapterSurfaceFactory;
 export interface MountGameOptions {
     /** Explicit per-world entries, same shape `mountManifestRoots` accepts —
      *  ALWAYS wins over a registered kind factory for that world id (backward

package/dist/runtime/mount-game.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount-game.d.ts","sourceRoot":"","sources":["../../src/runtime/mount-game.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,UAAU,EAAuC,MAAM,kBAAkB,CAAC;AAQxF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;6DACyD;IACzD,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD;;;mFAG+E;IAC/E,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC;gEAC4D;IAC5D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED,+EAA+E;AAC/E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAClC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,4BAA4B,KAC9B,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAQtC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAUlF;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D;AAcD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,qBAexC,CAAC;AAMF,MAAM,WAAW,gBAAgB;IAC/B;;;kEAG8D;IAC9D,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC;CACrE;AAyBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,WAAW,CAAC,CA6CtB"}
+{"version":3,"file":"mount-game.d.ts","sourceRoot":"","sources":["../../src/runtime/mount-game.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,KAAK,UAAU,EAAuC,MAAM,kBAAkB,CAAC;AAOxF;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;6DACyD;IACzD,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD;;;mFAG+E;IAC/E,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC;gEAC4D;IAC5D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED,+EAA+E;AAC/E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAClC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,4BAA4B,KAC9B,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAQtC;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAUlF;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,qCAAqC,IAAI,IAAI,CAE5D;AAMD,MAAM,WAAW,gBAAgB;IAC/B;;;kEAG8D;IAC9D,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC;CACrE;AA+BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAqDtB"}

package/dist/runtime/mount-game.js

@@ -12,11 +12,14 @@
 // callers register, but it registers NONE itself. In particular there is no
 // built-in 'canvas'/'react' registration here (that would require this file
 // to value-import `pixi.js`/`react`/`react-dom`, exactly what `mount-manifest
-// .ts` forbids); a project that has a canvas or react world MUST register a
-// factory for that kind itself — see `defaultThreeAdapterFactory` below for why
-// even the 'three' convenience export is a plain function the CALLER
-// registers, not something this module wires up automatically.
-import { installNativeDebugBindings, nativeDebugBindingFromEntryModule, } from '../adapter/native-debug-module';
+// .ts` forbids); a project that has a three, canvas, or react world MUST
+// register a factory for that kind itself — the factories live with the
+// modules that own their dependencies (`r3fRootFactory` in
+// `@engine/world3d-react`, its Pixi twin in `@engine/canvas-react`), never
+// wired up here automatically.
+import { declaredRoots } from '../adapter/manifest-interpreter';
+import { installNativeDebugBindings, installNativeSystemsBindings, nativeDebugBindingFromEntryModule, nativeSystemsBindingFromEntryModule, } from '../adapter/native-debug-module';
+import { publishDevInstruments } from '../dev/instruments';
 import { mountManifestRoots, resolveManifest } from './mount-manifest';
 import { assertExportedOrInEditor } from './unexported-game-trap';
 // ---------------------------------------------------------------------------
@@ -61,44 +64,12 @@ export function isAdapterRegistered(kind) {
 export function __clearAdapterSurfaceRegistryForTests() {
     registry.clear();
 }
-/**
- * A ready-to-register {@link AdapterSurfaceFactory} for `kind: 'three'` roots
- * that follow the first-party entry-module convention (`export const
- * adapter` and/or `export async function setup`). Threejs is safe to
- * ship as an exported convenience (unlike canvas/react) because `three`/
- * `SetupThreeRootAdapter` are already unconditional engine dependencies —
- * see `mount-manifest.ts`'s header comment. Still never auto-registered:
- * the registry itself stays zero-policy (see this file's header comment) —
- * a caller opts in with `registerAdapter('three', defaultThreeAdapterFactory)`.
- *
- * Resolution mirrors `mount-manifest.ts`'s own `resolveThreeAdapter` branch
- * order: an entry module's `adapter` export wins outright; else its `setup`
- * export (wrapping via `fromSetup` happens inside `mountManifestRoots`
- * itself — this factory just returns the `MountEntry` shape).
- */
-export const defaultThreeAdapterFactory = (world, ctx) => {
-    const mod = ctx.entryModule;
-    if (mod?.adapter)
-        return { kind: 'three', adapter: mod.adapter };
-    if (mod?.setup)
-        return { kind: 'three', setup: mod.setup };
-    if (world.entry !== undefined) {
-        throw new Error(`defaultThreeAdapterFactory: entry module "${world.entry}" for world "${world.id}" exports ` +
-            'neither `adapter` nor `setup` — every first-party entry module exports at least one ' +
-            '(export one from the declared entry module).');
-    }
-    throw new Error(`defaultThreeAdapterFactory: world "${world.id}" declares no \`entry\` — a three root is ` +
-        'authored as a TSX/R3F world module; point `entry` at it.');
-};
 /** True for the one shape `mountManifestRoots` can ALREADY mount with zero
  *  `entries[id]` at all.
  *
- *  WO-8: nothing is self-sufficient any more. The one shape that was — a plain
- *  `default`-adapter, SCENE-driven, no-`entry` three world, which
- *  `resolveThreeAdapter`'s scene branch could mount from the manifest alone —
- *  died with the `.vscn.json` format. `load.ts` now rejects a three root with no
+ *  NOTHING is self-sufficient: `load.ts` rejects a three root with no
  *  `entry` outright, so every world needs a registered factory or an explicit
- *  entry, and this predicate is retained only to keep the loud-degrade error the
+ *  entry. This predicate is retained so the loud-degrade error stays the
  *  documented outcome rather than a silent skip. */
 function worldIsSelfSufficient(_world) {
     return false;
@@ -109,6 +80,12 @@ function nativeDebugForEntry(world, entryModule) {
     const binding = nativeDebugBindingFromEntryModule(world.id, entryModule);
     return binding ? [binding] : [];
 }
+function nativeSystemsForEntry(world, entryModule) {
+    if (entryModule === undefined || world.adapter.type !== 'builtin')
+        return [];
+    const binding = nativeSystemsBindingFromEntryModule(world.id, entryModule, world.surface);
+    return binding ? [binding] : [];
+}
 /**
  * Mount every world declared by a `vgai.project.json` manifest onto `host
  * .container`, resolving each world's kind through the `registerAdapter`
@@ -137,7 +114,8 @@ export async function mountGameFromManifest(manifestInput, host, opts = {}) {
     const manifest = resolveManifest(manifestInput);
     const entries = { ...opts.entries };
     const nativeDebug = [];
-    for (const world of manifest.roots) {
+    const nativeSystems = [];
+    for (const world of declaredRoots(manifest)) {
         if (entries[world.id] !== undefined)
             continue; // explicit entry always wins
         const factory = registry.get(world.adapter.identity);
@@ -146,6 +124,7 @@ export async function mountGameFromManifest(manifestInput, host, opts = {}) {
                 ? await host.loadEntryModule(world.entry)
                 : undefined;
             nativeDebug.push(...nativeDebugForEntry(world, entryModule));
+            nativeSystems.push(...nativeSystemsForEntry(world, entryModule));
             entries[world.id] = await factory(world, { host, entryModule });
             continue;
         }
@@ -154,7 +133,7 @@ export async function mountGameFromManifest(manifestInput, host, opts = {}) {
         throw new Error(`mountGameFromManifest: root "${world.id}" (adapter "${world.adapter.identity}") has no registered ` +
             `adapter factory and no explicit entries["${world.id}"] — call ` +
             `registerAdapter("${world.adapter.identity}", factory) before mounting (see ` +
-            '`defaultThreeAdapterFactory` for a worked three example), or pass ' +
+            '`r3fRootFactory` in `@vgai/engine/world3d-react` for the worked three factory), or pass ' +
             `opts.entries["${world.id}"] directly (see mount-manifest.ts's \`MountEntry\`).`);
     }
     const session = await mountManifestRoots({
@@ -166,5 +145,11 @@ export async function mountGameFromManifest(manifestInput, host, opts = {}) {
         headless: host.headless,
     });
     installNativeDebugBindings(session.game, nativeDebug);
+    installNativeSystemsBindings(session.game, nativeSystems);
+    // The universal instruments are host furniture on EVERY mount path — the
+    // editor installs them in its own bindings pass; the standalone composer
+    // installs them here. The disposer is deliberately dropped: the set's one
+    // resource lives on this Game and dies with it.
+    publishDevInstruments(session.game);
     return session;
 }

package/dist/runtime/mount-manifest.d.ts

@@ -1,8 +1,9 @@
+import type { RootDeclaration } from '../adapter/binding';
 import type { RootAdapter } from '../adapter/root-adapter';
 import { type ResolvedGameManifest } from '../manifest/load';
 import { type GameSession } from './create-runtime';
 import { type DebugBridgeWindowTarget } from './debug-bridge';
-import type { GameSetupFn, PlaytestContext } from './types';
+import type { PlaytestContext } from './playtest';
 /**
  * A caller-supplied entry for a `kind: 'three'` world — two ways to satisfy
  * it, matching the two shapes `resolveDefaultThreeAdapter` supports (an
@@ -11,20 +12,27 @@ import type { GameSetupFn, PlaytestContext } from './types';
  *  - `{ adapter }` — a fully-constructed {@link RootAdapter} (first-party or
  *    not). Always wins if present, regardless of the world's `entry` field —
  *    full caller control, including for a `{ module }`-adapter world
- *    (mountManifestRoots cannot import an arbitrary module path itself).
- *  - `{ setup }` — for an `entry`-declaring world: the project's own
- *    `entry` module's exported `setup` function (the same `GameSetupFn`
- *    shape `loadProjectScripts` extracts editor-side). Wrapped in a
- *    `SetupThreeRootAdapter` here, mirroring `resolveDefaultThreeAdapter`'s
- *    entry branch exactly.
- *
- * The former third shape, `{ componentRegistry }` for a `scene`-declaring
- * world, went with the `.vscn.json` format in WO-8.
+ *    (mountManifestRoots cannot import an arbitrary module path itself —
+ *    for a default-exported world, build the adapter with
+ *    `resolveR3FEntryAdapter(entryModule, worldId)` from
+ *    `@vgai/engine/world3d-react` and pass it here).
  */
-export interface ThreeMountEntry {
+export interface ThreeMountEntry extends MountEntryDeclaration {
     readonly kind: 'three';
     readonly adapter?: RootAdapter | undefined;
-    readonly setup?: GameSetupFn | undefined;
+}
+/**
+ * The half of a root's binding declaration a CALLER holds — everything in
+ * `adapter/binding.ts`'s {@link RootDeclaration} except `root`, which this
+ * file already has from the manifest it just resolved.
+ *
+ * Optional throughout, and absent is the honest state for a caller who built
+ * an adapter by hand out of its own module graph: there is no entry namespace
+ * to report a static surface for, so the root registers with `binding: null`
+ * rather than one describing a module nobody loaded.
+ */
+export interface MountEntryDeclaration {
+    readonly declaration?: Omit<RootDeclaration, 'root'> | undefined;
 }
 /**
  * A caller-supplied entry for a `kind: 'canvas'` world — ALWAYS a
@@ -34,7 +42,7 @@ export interface ThreeMountEntry {
  * `pixi.js`, which it deliberately never does (see this file's header
  * comment).
  */
-export interface PixiMountEntry {
+export interface PixiMountEntry extends MountEntryDeclaration {
     readonly kind: 'canvas';
     readonly adapter: RootAdapter<'canvas'>;
 }
@@ -51,7 +59,7 @@ export interface PixiMountEntry {
  * itself (see this file's header comment) — building the adapter is
  * entirely the caller's job.
  */
-export interface ReactMountEntry {
+export interface ReactMountEntry extends MountEntryDeclaration {
     readonly kind: 'dom';
     readonly adapter: RootAdapter<'dom'>;
 }

package/dist/runtime/mount-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mount-manifest.d.ts","sourceRoot":"","sources":["../../src/runtime/mount-manifest.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mount-manifest.d.ts","sourceRoot":"","sources":["../../src/runtime/mount-manifest.ts"],"names":[],"mappings":"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"}