@vgai/engine 0.5.22 → 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:
@@ -341,6 +332,10 @@ export function createGame(opts) {
      *  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
@@ -425,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) {
@@ -455,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
@@ -480,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;
@@ -507,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) {
@@ -532,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))
@@ -548,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))
@@ -583,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
@@ -610,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 —
@@ -665,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
@@ -713,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
@@ -761,7 +778,10 @@ export function createGame(opts) {
             for (const listener of systemAdapterListeners)
                 listener();
         },
-        installDeclaredSystemAdapters(rootId, slots) {
+        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'}).`);
@@ -771,6 +791,11 @@ export function createGame(opts) {
                     '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,
@@ -801,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)
@@ -826,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 ` +
@@ -837,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.
@@ -888,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.');
@@ -984,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":"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;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;AAkCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,OAAO,EACtB,IAAI,EAAE,YAAY,EAClB,IAAI,GAAE,gBAAqB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAqDtB"}
+{"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,10 +12,11 @@
 // 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.
+// .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';
@@ -63,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;
@@ -164,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({

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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"}

package/dist/runtime/mount-manifest.js

@@ -1,8 +1,8 @@
 // The standalone manifest-mount helper: an ENGINE-side generalization of
 // `examples/tri-world/src/main.ts`'s hand-built `RootMountSpec[]`.
 //
-// `resolveAllRoots`/`resolveRootAdapter` (`packages/editor/src/
-// adapter-resolver.ts`) already do this translation for the EDITOR, but they
+// `resolveAllRoots`/`resolveRootBinding` (`packages/editor/src/
+// binding-resolver.ts`) already do this translation for the EDITOR, but they
 // are Vite-coupled by construction (`/@fs/` dynamic imports of project files
 // through the dev server, §0.1/§0.5 of the design doc) — unusable from a
 // plain static build. This module mirrors their per-kind dispatch
@@ -17,16 +17,12 @@
 // type-only import): this file never value-imports
 // `pixi.js`, `react`, or `react-dom` — a
 // canvas or react world's adapter is ALWAYS supplied already-constructed via
-// `entries[id].adapter` (the caller's own module graph built it). Threejs is
-// different: `three`/
-// `SetupThreeRootAdapter` are already unconditional dependencies of every
-// caller of `createGameRuntime`, so wrapping a `setup` with
-// `fromSetup` here adds no NEW bundle weight — only pixi/react are avoided.
+// `entries[id].adapter` (the caller's own module graph built it), so no
+// surface's library is pulled into a game that has no world on it.
 import { assertNever } from '../adapter/adapter-surface';
 import { declaredRoots } from '../adapter/manifest-interpreter';
 // Value-imported from the implementer's OWN path, not the type-only
 // `../adapter` barrel (P-6).
-import { fromSetup } from '../adapter/setup-three-root-adapter';
 import { loadGameManifest, } from '../manifest/load';
 import { createGameRuntime } from './create-runtime';
 import { maybeInstallDebugBridge } from './debug-bridge';
@@ -104,8 +100,8 @@ export function resolveManifest(raw) {
     return loadGameManifest(raw);
 }
 // ---------------------------------------------------------------------------
-// Per-kind entry -> adapter resolution (mirrors `resolveRootAdapter`'s
-// per-identity dispatch, `packages/editor/src/adapter-resolver.ts`)
+// Per-kind entry -> adapter resolution (mirrors `resolveRootBinding`'s
+// per-identity dispatch, `packages/editor/src/binding-resolver.ts`)
 // ---------------------------------------------------------------------------
 function resolveThreeAdapter(world, entry) {
     if (entry?.adapter)
@@ -125,17 +121,15 @@ function resolveThreeAdapter(world, entry) {
     }
     // type === 'default'
     if (world.entry !== undefined) {
-        if (!entry?.setup) {
-            throw new Error(`mountManifestRoots: world "${world.id}" (three) declares \`entry\` "${world.entry}" ` +
-                `— supply entries["${world.id}"] = { kind: 'three', setup } (the entry module's ` +
-                "exported `setup` function) or { kind: 'three', adapter } for full control. Got " +
-                `${entry === undefined ? 'no entry at all' : 'an entry with neither `setup` nor `adapter`'}.`);
-        }
-        return fromSetup(world.id, entry.setup);
+        throw new Error(`mountManifestRoots: world "${world.id}" (three) declares \`entry\` "${world.entry}" ` +
+            `— supply entries["${world.id}"] = { kind: 'three', adapter } (for a default-exported ` +
+            'world, build it with `resolveR3FEntryAdapter(entryModule, worldId)` from ' +
+            '`@vgai/engine/world3d-react`). Got ' +
+            `${entry === undefined ? 'no entry at all' : 'an entry with no `adapter`'}.`);
     }
     // Unreachable in practice: `load.ts`'s `checkAdapterSceneEntryRules` requires
     // `entry` for every 'default' THREE adapter world at manifest-load time (and
-    // rejects `scene` outright — the `.vscn.json` format was removed in WO-8).
+    // rejects any other content declaration on one outright).
     throw new Error(`mountManifestRoots: world "${world.id}" is default-three with no \`entry\` — this ` +
         'should have been rejected by manifest validation.');
 }
@@ -167,6 +161,12 @@ function buildRootMountSpec(world, entry) {
         id: world.id,
         zOrder: world.zOrder,
         pausable: world.pausable,
+        // `root` is this file's own resolved manifest record; the rest — the
+        // parsed `vgai.adapter.ts`, the entry namespace, the entry's declared
+        // debug/systems bindings — only the caller who loaded the entry can know.
+        ...(entry?.declaration === undefined
+            ? {}
+            : { declaration: { root: world, ...entry.declaration } }),
     };
     // `entry`'s `kind` is guaranteed to agree with `world.kind` past the guard
     // above (or `entry` is `undefined`) — TS can't narrow a `Record` lookup

package/dist/runtime/playtest.d.ts

@@ -0,0 +1,22 @@
+/**
+ * WHO IS PLAYING, and under what identity — the host's own declaration for one
+ * private play run or coordinated team test.
+ *
+ * Its own module because it is a PUBLISHED path: a project's Colyseus
+ * networking adapter (the `colyseus` capability, copied into every game) names
+ * this type, so it must live somewhere that survives. The engine never joins a
+ * room and never couples this authoring identity to a networking library —
+ * games may pass `roomKey` as a Colyseus filter/join option, and that is the
+ * whole of the coupling.
+ */
+/** Host-supplied identity for one private play run or coordinated team test.
+ * Games may pass `roomKey` as a Colyseus filter/join option; the engine never
+ * joins a room or couples this authoring identity to a networking library. */
+export interface PlaytestContext {
+    readonly mode: 'private' | 'team';
+    readonly id: string;
+    readonly roomKey: string;
+    readonly revision: number | null;
+    readonly participantId: string | null;
+}
+//# sourceMappingURL=playtest.d.ts.map

package/dist/runtime/playtest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playtest.d.ts","sourceRoot":"","sources":["../../src/runtime/playtest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;8EAE8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC"}