@vgai/engine 0.5.21 → 0.5.23

package/dist/runtime/create-runtime.js

@@ -1,54 +1,55 @@
 import * as THREE from 'three';
 import { assertNever } from '../adapter/adapter-surface';
+import { createRootBinding } from '../adapter/binding';
 import { createAssetCache } from '../assets';
 import { createGameLoop } from '../core/game-loop';
 import { createHostRenderer } from '../setup/setup-renderer';
+import { getDebugRegistry } from './debug-registry';
 // TYPE-ONLY: `create-runtime.ts` must never value-import `pixi.js` — a canvas
 // `RootMountSpec`'s `adapter` is supplied ALREADY-CONSTRUCTED by the caller, so
 // the host only ever needs the seam's types.
-import { createGame, createRootInstance, isFirstPartyMounted, } from './game';
+import { createGame, createRootInstance, } from './game';
 import { createInputRouter, stackOrder } from './input-router';
 import { installRenderControlHarness, isRenderModeRequested } from './render-control';
-/**
- * Register a three world for a freshly-mounted game onto the Game shell. Shared
- * by `createGameRuntime` and every headless test harness
- * (`test/game-root.test.ts`, `test/frame-order.test.ts`,
- * `test/game-two-roots.test.ts`) so there is exactly one code path for this
- * wiring. `physics`/`collisions`/`camera`/`frame` are populated from the mount's
- * first-party `GameContext`/ `MountedSetupThreeRoot` when available, left
- * `undefined` otherwise (an external adapter's mount has none of these
- * first-party handles — `frame` in particular is what makes
- * `GameInternal.runFrame` fall back to a single opaque
- * `mounted.update` call per substep for such a world).
- */
-function firstPartyExtras(mounted) {
-    if (!isFirstPartyMounted(mounted))
-        return {};
-    return {
-        physics: mounted.ctx.physics,
-        collisions: mounted.ctx.collisions,
-        camera: mounted.ctx.camera,
-        frame: mounted.frame,
-    };
-}
 /**
  * Register a three world onto the Game shell. `opts.id` defaults to
  * `'main'`; multi-root callers pass an explicit id. This is the one
  * registration path for a three world, whatever its id.
  */
 export function registerThreeRoot(game, adapter, mounted, opts) {
+    const pausable = opts?.pausable ?? true;
     const world = createRootInstance({
         id: opts?.id ?? 'main',
         kind: 'three',
-        pausable: opts?.pausable ?? true,
+        pausable,
         adapter,
         mounted,
         scene: mounted.scene,
-        ...firstPartyExtras(mounted),
+        binding: bindRoot(game, opts?.declaration, {
+            surface: 'three',
+            adapter: adapter,
+        }, mounted, pausable),
     });
     game.registerRoot(world);
     return world;
 }
+/**
+ * Complete the root's binding at the first moment it CAN be completed: the
+ * declaration is what the resolver knew, `mounted`/`adapter`/`pausable` are
+ * what mounting produced, and the debug registry is the game's own. Nothing
+ * here loads or fabricates — see `createRootBinding`.
+ */
+function bindRoot(game, declaration, adapter, mounted, pausable) {
+    if (!declaration)
+        return null;
+    return createRootBinding({
+        ...declaration,
+        adapter,
+        mounted,
+        pausable,
+        debugRegistry: getDebugRegistry(game),
+    });
+}
 /**
  * Register a canvas world onto the Game shell — the pixi analog of
  * {@link registerThreeRoot}. `adapter` is the seam's own
@@ -58,13 +59,15 @@ export function registerThreeRoot(game, adapter, mounted, opts) {
  */
 export function registerPixiRoot(game, adapter, mounted, opts) {
     const id = opts?.id ?? 'main';
+    const pausable = opts?.pausable ?? true;
     const world = createRootInstance({
         id,
         kind: 'canvas',
-        pausable: opts?.pausable ?? true,
+        pausable,
         adapter,
         mounted,
         stage: mounted.stage,
+        binding: bindRoot(game, opts?.declaration, { surface: 'canvas', adapter }, mounted, pausable),
     });
     game.registerRoot(world);
     return world;
@@ -81,13 +84,15 @@ export function registerPixiRoot(game, adapter, mounted, opts) {
  * needs `.id`, so this passes through with zero cast.
  */
 export function registerReactRoot(game, adapter, mounted, container, opts) {
+    const pausable = opts?.pausable ?? true;
     const world = createRootInstance({
         id: opts?.id ?? 'main',
         kind: 'dom',
-        pausable: opts?.pausable ?? true,
+        pausable,
         adapter,
         mounted,
         container,
+        binding: bindRoot(game, opts?.declaration, { surface: 'dom', adapter }, mounted, pausable),
     });
     game.registerRoot(world);
     return world;
@@ -106,9 +111,8 @@ export async function createGameRuntime(config) {
 // Universal root host
 // ---------------------------------------------------------------------------
 /** A stand-in `THREE.WebGLRenderer` for headless (`headless:true`) three
- *  roots — mirrors `SetupThreeRootAdapter.mount`'s own `headlessComposer`
- *  pattern (`adapter/setup-three-root-adapter.ts`): a headless first-party
- *  mount never calls a render-phase method on `host.renderer` at all, so
+ *  roots: a headless mount never calls a render-phase method on
+ *  `host.renderer` at all, so
  *  this only needs to satisfy the handful of calls THIS file itself makes
  *  (`setPixelRatio`/`setClearColor`/`setSize` at mount, `dispose`/
  *  `forceContextLoss` at teardown) — never a real GL call. Node conformance
@@ -122,6 +126,46 @@ function createHeadlessRendererStub() {
         forceContextLoss() { },
     };
 }
+/**
+ * Reclaim ONE mounted root: its adapter, the renderer this file constructed for
+ * it (including the WebGL context — a browser keeps only a handful alive, so
+ * `dispose()` alone is not enough), and its stacked surface element.
+ *
+ * ONE body, TWO callers, deliberately: the session's `fullCleanup` (a normal
+ * stop) and `mountAllRootSpecs`'s partial-mount ROLLBACK (a later root's mount
+ * rejected, so the roots that already mounted must not survive the rejection).
+ * Those two must never drift — a rollback that reclaims less than a stop is how
+ * a failed play leaves a live renderer and a lost GL context behind with no
+ * handle anywhere able to reach it.
+ *
+ * Throws only what the adapter's own `dispose()` throws; every caller wraps it
+ * per entry so one bad root cannot abort the rest of the teardown.
+ */
+function disposeMountedRoot(entry, container) {
+    try {
+        entry.mounted.dispose();
+    }
+    finally {
+        // Renderer + surface release run even when the adapter's dispose threw:
+        // the GL context is the scarce resource, and the caller still sees the
+        // error (this rethrows through the `finally`).
+        entry.renderer?.dispose();
+        entry.renderer?.forceContextLoss();
+        // Remove from the element's CURRENT parent, not the mount-time
+        // `container`: the editor's Game panel re-parents the live surfaces
+        // when its mount element swaps (fill <-> device preset, W2c), and
+        // `container.removeChild` would throw NotFoundError after such a move.
+        // `container` remains the fallback for hosts whose element stand-ins
+        // never wire `parentNode` (headless unit fixtures); an element already
+        // detached by such a host is a no-op via the catch.
+        try {
+            (entry.element.parentNode ?? container).removeChild(entry.element);
+        }
+        catch {
+            /* already detached — nothing to remove */
+        }
+    }
+}
 /** Mount one three `RootMountSpec` (canvas + renderer construction, per
  *  D5 §1/§4, then `registerThreeRoot`). Split out of
  *  `createRootsGameRuntime` purely to keep that function's own branching
@@ -175,7 +219,11 @@ async function mountOneThreeRoot(spec, ctx) {
         game,
     };
     const mounted = await spec.adapter.mount(host);
-    registerThreeRoot(game, spec.adapter, mounted, { id: spec.id, pausable: spec.pausable });
+    registerThreeRoot(game, spec.adapter, mounted, {
+        id: spec.id,
+        pausable: spec.pausable,
+        declaration: spec.declaration,
+    });
     return {
         mountedEntry: { id: spec.id, kind: 'three', element: canvas, mounted, renderer },
         routerEntry: { id: spec.id, zOrder: spec.zOrder ?? 0, canvas, hitTest: spec.hitTest },
@@ -186,7 +234,7 @@ async function mountOneThreeRoot(spec, ctx) {
  *  `mountOneThreeRoot` above.
  *
  *  Unlike `mountOneThreeRoot`, this needs no explicit `canvas.style.width`/
- *  `.height` re-assertion (E4.R1). `pixi-surface.ts` constructs its
+ *  `.height` re-assertion. The canvas surface constructs its
  *  `Application` with `autoDensity: true`, which makes PIXI ITSELF re-stamp
  *  `canvas.style.width`/`.height` (real CSS px, matching the LOGICAL
  *  width/height passed to `resize()`) on every `app.renderer.resize()` call —
@@ -215,6 +263,7 @@ async function mountOnePixiRoot(spec, ctx) {
     registerPixiRoot(game, spec.adapter, mounted, {
         id: spec.id,
         pausable: spec.pausable,
+        declaration: spec.declaration,
     });
     return {
         mountedEntry: {
@@ -271,6 +320,7 @@ layer) {
     registerReactRoot(game, spec.adapter, mounted, layer, {
         id: spec.id,
         pausable: spec.pausable,
+        declaration: spec.declaration,
     });
     return {
         mountedEntry: {
@@ -289,8 +339,8 @@ layer) {
  * per D5 §1, z-order/ties exactly matching
  * `manifest/load.ts`'s sort, ONE `Game`, and registers every world onto it
  * via `registerThreeRoot`/`registerPixiRoot`/`registerReactRoot` — the
- * SAME wiring `test/game-three-plus-pixi.test.ts` proves by hand for the
- * three/pixi pair. Worlds MOUNT in `roots` ARRAY order ("manifest
+ * SAME wiring `test/create-runtime-worlds.test.ts` proves for the
+ * three/canvas pair. Worlds MOUNT in `roots` ARRAY order ("manifest
  * declaration order" — the frame/registration axis), independent of
  * `zOrder` (the canvas-stacking/rendering axis) — the two orders can differ
  * and both are honored correctly.
@@ -344,37 +394,60 @@ function installDefaultRootDevGlobals(game) {
  * comment).
  */
 async function mountAllRootSpecs(mountSpecs, bottomId, inputs) {
-    const { surfacesById, ...shared } = inputs;
+    const { surfacesById, container, ...shared } = inputs;
     const mountedEntries = [];
     const routerEntries = [];
-    for (const spec of mountSpecs) {
-        const isBottom = spec.id === bottomId;
-        if (spec.kind === 'dom') {
-            const layer = surfacesById.get(spec.id);
-            const { mountedEntry } = await mountOneReactRoot(spec, shared.game, layer);
+    try {
+        for (const spec of mountSpecs) {
+            const isBottom = spec.id === bottomId;
+            if (spec.kind === 'dom') {
+                const layer = surfacesById.get(spec.id);
+                const { mountedEntry } = await mountOneReactRoot(spec, shared.game, layer);
+                mountedEntries.push(mountedEntry);
+                continue;
+            }
+            const canvas = surfacesById.get(spec.id);
+            const oneCtx = { ...shared, canvas, isBottom };
+            let mountedEntry;
+            let routerEntry;
+            if (spec.kind === 'three') {
+                ({ mountedEntry, routerEntry } = await mountOneThreeRoot(spec, oneCtx));
+            }
+            else if (spec.kind === 'canvas') {
+                ({ mountedEntry, routerEntry } = await mountOnePixiRoot(spec, oneCtx));
+            }
+            else {
+                // Exhaustiveness guard (§7.4-2): 'react' was already handled by the
+                // early `continue` above, so only a hypothetical 4th `AdapterSurface` can
+                // reach here — fail loudly rather than silently defaulting. `spec`
+                // itself (not `spec.kind`) is what TS has narrowed to `never`, since
+                // `RootMountSpec` is a discriminated union at the object level.
+                assertNever(spec, 'create-runtime mount loop');
+            }
             mountedEntries.push(mountedEntry);
-            continue;
-        }
-        const canvas = surfacesById.get(spec.id);
-        const oneCtx = { ...shared, canvas, isBottom };
-        let mountedEntry;
-        let routerEntry;
-        if (spec.kind === 'three') {
-            ({ mountedEntry, routerEntry } = await mountOneThreeRoot(spec, oneCtx));
+            routerEntries.push(routerEntry);
         }
-        else if (spec.kind === 'canvas') {
-            ({ mountedEntry, routerEntry } = await mountOnePixiRoot(spec, oneCtx));
-        }
-        else {
-            // Exhaustiveness guard (§7.4-2): 'react' was already handled by the
-            // early `continue` above, so only a hypothetical 4th `AdapterSurface` can
-            // reach here — fail loudly rather than silently defaulting. `spec`
-            // itself (not `spec.kind`) is what TS has narrowed to `never`, since
-            // `RootMountSpec` is a discriminated union at the object level.
-            assertNever(spec, 'create-runtime mount loop');
+    }
+    catch (err) {
+        // PARTIAL MOUNT ROLLBACK. Roots mount sequentially, so a rejection from
+        // root N leaves roots 1..N-1 fully live — renderer, WebGL context, R3F
+        // tree, adapter registrations — and NOTHING ever gets a handle to them:
+        // this function throws instead of returning, so no `GameSession` (and
+        // therefore no `stop()`) is ever constructed. Reclaim them here, in
+        // REVERSE mount order (the inverse of the order they were built in), then
+        // rethrow the ORIGINAL error — the mount failure is what the caller must
+        // see, never a teardown error raised while cleaning up after it.
+        for (let i = mountedEntries.length - 1; i >= 0; i--) {
+            const entry = mountedEntries[i];
+            try {
+                disposeMountedRoot(entry, container);
+            }
+            catch (disposeErr) {
+                // biome-ignore lint/suspicious/noConsole: a rollback failure must be visible; the original mount error is still what we rethrow
+                console.error(`createGameRuntime: rolling back root "${entry.id}" after a mount failure threw:`, disposeErr);
+            }
         }
-        mountedEntries.push(mountedEntry);
-        routerEntries.push(routerEntry);
+        throw err;
     }
     return { mountedEntries, routerEntries };
 }
@@ -424,6 +497,34 @@ function installSessionRenderHarness(game, location, targetOverride) {
         delete target['__vgaiRender'];
     };
 }
+/**
+ * Reclaim what `createRootsGameRuntime` built for ITSELF when the mount
+ * rejects. `mountAllRootSpecs` has already rolled back every root that DID
+ * mount, so what is left is the Game shell (holding whatever registrations
+ * those roots made into it) and the stacked surface elements of the roots that
+ * never got to mount. Neither is reachable afterwards: the mount throws instead
+ * of returning, so no `GameSession` — and therefore no `stop()` — ever exists.
+ *
+ * Never throws: the MOUNT error is what the caller must see, so a failure while
+ * cleaning up after it is reported and swallowed.
+ */
+function reclaimAfterMountFailure(game, surfaces, container) {
+    try {
+        game.dispose();
+    }
+    catch (disposeErr) {
+        // biome-ignore lint/suspicious/noConsole: a failed rollback must be visible; the original mount error is what the caller gets
+        console.error('createGameRuntime: disposing the game after a mount failure threw:', disposeErr);
+    }
+    for (const surface of surfaces) {
+        try {
+            (surface.parentNode ?? container).removeChild(surface);
+        }
+        catch {
+            /* already detached by the per-root rollback */
+        }
+    }
+}
 async function createRootsGameRuntime(config) {
     const { container, roots: specs, width, height, headless = false, seed, playtest } = config;
     if (specs.length === 0) {
@@ -514,14 +615,14 @@ async function createRootsGameRuntime(config) {
         // host's explicit `simulateSubsteps`/`renderOnce` calls — wall-clock time
         // passing while a screenshot is taken must not move the world.
         externalDrive: renderMode,
-        // WO-P13 — sim and presentation are wired to different callbacks here:
+        // Sim and presentation are wired to different callbacks here:
         // `update` runs the gameplay phases once per consumed fixed substep with
         // `preRender`/`render` withheld, and `render` runs those two once per real
         // display frame with the interpolation alpha. Both closures are invoked
         // only from the loop's own rAF arm, which `externalDrive` never arms — so
         // a capture/offline-export page (`renderMode`) reaches neither, and its
         // `simulateSubsteps` → `game.runFrame(fixedDt)` path stays frame-exact,
-        // rendering inside the substep exactly as it did before this flip.
+        // rendering inside the substep.
         update: (dt) => {
             if (started)
                 game.runFrame(dt, { skipRenderPhases: true });
@@ -537,16 +638,25 @@ async function createRootsGameRuntime(config) {
     // `createRootsGameRuntime`'s own cyclomatic complexity down (E4) — same
     // reason `mountOneThreeRoot`/`mountOnePixiRoot` are already split out
     // below.
-    const { mountedEntries, routerEntries } = await mountAllRootSpecs(mountSpecs, bottomId, {
-        game,
-        surfacesById,
-        w,
-        h,
-        dpr,
-        headless,
-        assets,
-        antialias: config.antialias,
-    });
+    let mounted;
+    try {
+        mounted = await mountAllRootSpecs(mountSpecs, bottomId, {
+            game,
+            surfacesById,
+            container,
+            w,
+            h,
+            dpr,
+            headless,
+            assets,
+            antialias: config.antialias,
+        });
+    }
+    catch (err) {
+        reclaimAfterMountFailure(game, surfacesById.values(), container);
+        throw err;
+    }
+    const { mountedEntries, routerEntries } = mounted;
     // --- Delegating input router (D5 §2a) ---
     const router = createInputRouter(container, routerEntries);
     started = true;
@@ -566,38 +676,53 @@ async function createRootsGameRuntime(config) {
         resolveStopComplete = resolve;
     });
     let stopping = false;
+    /**
+     * Reclaim EVERYTHING this session owns, and let no single failure stop that.
+     *
+     * Teardown used to be one `try` over the whole body, so a throwing
+     * `entry.mounted.dispose()` on root 1 skipped root 2's disposal, both
+     * renderers' `forceContextLoss`, `game.dispose()` and the two global
+     * retractions — while `stopComplete` still resolved and the editor still
+     * reported the instance reclaimed. Every step is now isolated: a failure is
+     * COLLECTED and reported, never allowed to abort the steps after it.
+     */
     function fullCleanup() {
         if (stopping)
             return;
         stopping = true;
+        const failures = [];
+        /** Run one teardown step; record its failure and keep going. */
+        const step = (name, run) => {
+            try {
+                run();
+            }
+            catch (error) {
+                failures.push({ step: name, error });
+            }
+        };
         try {
-            loop.stop();
-            router.dispose();
+            step('loop.stop', () => loop.stop());
+            step('router.dispose', () => router.dispose());
             for (const entry of mountedEntries) {
-                entry.mounted.dispose();
-                entry.renderer?.dispose();
-                entry.renderer?.forceContextLoss();
-                // Remove from the element's CURRENT parent, not the mount-time
-                // `container`: the editor's Game panel re-parents the live surfaces
-                // when its mount element swaps (fill <-> device preset, W2c), and
-                // `container.removeChild` would throw NotFoundError after such a move.
-                // `container` remains the fallback for hosts whose element stand-ins
-                // never wire `parentNode` (headless unit fixtures); an element already
-                // detached by such a host is a no-op via the catch.
-                try {
-                    (entry.element.parentNode ?? container).removeChild(entry.element);
-                }
-                catch {
-                    /* already detached — nothing to remove */
-                }
+                step(`root "${entry.id}"`, () => disposeMountedRoot(entry, container));
             }
-            game.dispose();
-            retractDevGlobals();
-            retractRenderHarness?.();
+            step('game.dispose', () => game.dispose());
+            step('dev globals', () => retractDevGlobals());
+            step('render harness', () => retractRenderHarness?.());
         }
         finally {
             void Promise.allSettled(mountedEntries.map((entry) => entry.mounted.disposeComplete ?? Promise.resolve())).then(() => resolveStopComplete());
         }
+        if (failures.length > 0) {
+            // LOUD, and after everything else has been reclaimed. `stop()` is called
+            // from hosts that must not be left half-torn-down by an early throw, so
+            // the report comes last — but it IS a report: a silent partial teardown
+            // is the failure this whole restructure exists to end. The editor's
+            // `exitPlayMode` catches it and prints it to the editor console.
+            throw new AggregateError(failures.map((f) => f.error), `Game session teardown failed in ${failures.length} step(s): ${failures
+                .map((f) => f.step)
+                .join(', ')}. Every other step still ran.`);
+        }
     }
     return {
         stop: fullCleanup,

package/dist/runtime/debug-registry.d.ts

@@ -1,6 +1,6 @@
 /**
  * The game-scoped debug/synthetic-player registry. ONE registry per `Game` root —
- * every world's `ctx.debug` (see `DebugCtxSurface`, `runtime/types.ts`) feeds the
+ * every world's `ctx.debug` (see {@link DebugCtxSurface} below) feeds the
  * SAME registry via {@link DebugRegistry.forRoot}, so a name a game registers is
  * visible (and name-collision-checked) across every world, not just the one that
  * registered it. `createGame` (`runtime/game.ts`) constructs the registry
@@ -10,8 +10,8 @@
  * rather than threading it through every call site.
  *
  * Provenance note: a registration's "world" is the MOUNT's adapter id (the
- * `fromSetup(id, ...)` / `SetupThreeRootConfig.id` a project already names each
- * world's entry with) rather than the `RootInstance.id` `registerThreeRoot`
+ * id a project's root adapter already carries) rather than the
+ * `RootInstance.id` `registerThreeRoot`
  * assigns — that id isn't known until AFTER `mount()` resolves (`create-
  * runtime.ts` calls `registerThreeRoot` with it only once `mount()` returns),
  * which is after every `setup()`-time registration has already run. For the
@@ -23,7 +23,76 @@ import { z } from 'zod';
 import type { DebugAdapter } from '../adapter/system-adapter';
 import type { GameLoopLiveness } from '../core/types';
 import type { Game } from './game';
-import type { DebugCommandArgs, DebugCtxSurface } from './types';
+/**
+ * The minimal structural shape `ctx.debug.attachRoom` needs from a joined
+ * Colyseus room: just enough to send the reserved `__vgai:debugCommand`
+ * message and listen for its `__vgai:debugCommandResult` reply. Structural,
+ * not a Colyseus type import — the same seam-boundary style every other
+ * `DebugCtxSurface` member uses (no wrapper around Colyseus itself, D2).
+ * `onMessage`'s return type is `unknown` because Colyseus's own return shape
+ * (void in some client versions, an unsubscribe function in others) isn't
+ * load-bearing here: the registry calls it defensively (invokes it on detach
+ * only if it's actually a function).
+ */
+export interface DebugRoomHandle {
+    send(type: string, message?: unknown): void;
+    onMessage(type: string, cb: (message: unknown) => void): unknown;
+}
+/**
+ * Infers a `registerCommand`/`registerReactCommand`/`useDebugCommand`
+ * handler's parameter tuple from its declared Zod `args` tuple (dry-run
+ * finding, ledger — "`registerCommand` fn typing forces `unknown[]` casts"):
+ * a real `z.ZodTuple` infers its element types (`z.tuple([z.number(),
+ * z.string()])` → `(n: number, s: string) => ...`), while omitting `args`
+ * (the generic's `undefined` default) resolves to the original permissive
+ * `(...args: unknown[]) => ...` shape every command had before this generic
+ * existed. That permissive fallback is deliberate, not just a placeholder —
+ * it keeps every existing no-schema registration (including ones whose
+ * handler reads positional args the runtime never validates, since
+ * `invoke()` only parses `args` against a schema when one is declared)
+ * compiling byte-for-byte unchanged.
+ */
+export type DebugCommandArgs<T extends z.ZodTuple | undefined = undefined> = T extends z.ZodTuple ? z.infer<T> : unknown[];
+/**
+ * The authoring half of the debug/synthetic-player seam — the read/actuate half is
+ * `SystemAdapters.DebugAdapter` (`adapter/system-adapter.ts`). Callable from any
+ * `init` (one file per new provider/command), or from a react world's
+ * `useDebugProvider`/`useDebugCommand`/`useDebugEmit` hooks. Every registration feeds the ONE
+ * game-scoped registry (`runtime/debug-registry.ts`) — never a per-world accumulator.
+ */
+export interface DebugCtxSurface {
+    /** Register (or replace) a named, JSON-serializable state read. Duplicate
+     *  names from the SAME world replace + warn once; the SAME name from a
+     *  DIFFERENT world throws (`DebugError` code `DEBUG_NAME_COLLISION`). */
+    registerStateProvider(name: string, fn: () => unknown, opts?: {
+        tier?: 'observable' | 'assisted';
+    }): void;
+    /** Register (or replace) an invokable command. `locus` is REQUIRED once the
+     *  project declares a Colyseus room (`DebugRegistry.setRoomDeclared`) — a
+     *  fixture must say whether it mutates authoritative (server) or predicted
+     *  (client) state.
+     *
+     *  Generic over the declared `args` Zod tuple ({@link DebugCommandArgs}) so
+     *  `fn`'s parameters INFER from it: `registerCommand('setHp', { args:
+     *  z.tuple([z.number()]) }, (hp) => ...)` types `hp` as `number` with no
+     *  cast. Leaving `args` off keeps `fn` typed `(...args: unknown[]) => ...`,
+     *  same as before this generic existed. */
+    registerCommand<T extends z.ZodTuple | undefined = undefined>(name: string, spec: {
+        description?: string;
+        args?: T;
+        locus?: 'client' | 'server';
+    }, fn: (...args: DebugCommandArgs<T>) => unknown | Promise<unknown>): void;
+    /** Push a tick-stamped event onto the debug event ring (spec §3.3) — the
+     *  engine stamps `tick`/`simT` at emission, not at read time. */
+    emit(event: string, detail?: unknown): void;
+    /**
+     * Task 2.2 — server-locus command routing (client leg). Call once your
+     * game code has joined its Colyseus room, so `locus: 'server'` commands
+     * have somewhere to send `__vgai:debugCommand`. Returns a detach function
+     * (call on room leave/dispose) — game-scoped, last-attached room wins.
+     */
+    attachRoom(room: DebugRoomHandle): () => void;
+}
 /** Engine-local error for the debug seam — mirrors the `code` + `data` shape
  *  `packages/vgai-sdk/src/errors.ts` uses (no import: the engine does not
  *  depend on `@vgai/sdk`). `code` is always machine-readable; nothing reading
@@ -37,7 +106,7 @@ export declare class DebugError extends Error {
  *  actuates through — the SAME three methods `InputManager` exposes
  *  (`setVirtualAction`/`tapVirtualAction`/`clearVirtualActions`, Task 1.4),
  *  typed narrowly here so this module never imports `InputManager` itself.
- *  Wired once by the hosting adapter (`setup-three-root-adapter.ts`, at the
+ *  Wired once by the hosting adapter (`world3d-react/r3f-root-factory.tsx`, at the
  *  same seed spot as `setInputActionsSource`) — absent until then. */
 export interface DebugVirtualInputTarget {
     setVirtualAction(action: string, value: boolean | number | {
@@ -115,7 +184,7 @@ export interface RunTicksTarget {
 }
 /** What {@link createDebugRegistry} returns — the adapter half (`DebugAdapter`,
  *  for `SystemAdapters.debug`) plus the registration/lifecycle surface the
- *  hosting adapter (`setup-three-root-adapter.ts`) and `createGame` drive. */
+ *  hosting adapter (`world3d-react/r3f-root-factory.tsx`) and `createGame` drive. */
 export interface DebugRegistry {
     /** The `SystemAdapters.debug` implementer — one shared instance, seeded
      *  onto every world's adapter bag. */
@@ -169,7 +238,7 @@ export interface DebugRegistry {
      *  `{version: 1, seed: null, fixedDt: null, ticks: []}`. `seed`/`fixedDt`
      *  are the two replay-critical metadata fields the design doc's format
      *  sketch (§2.c) calls for beside the raw per-tick deltas — the wiring
-     *  adapter (`setup-three-root-adapter.ts`) assembles them from
+     *  adapter (`world3d-react/r3f-root-factory.tsx`) assembles them from
      *  `getSeededRandom(game)?.seed`/`host.game?.loop.fixedDt` alongside
      *  `InputManager.getInputTrace()`'s own `{version, ticks}`. An `engine`
      *  (package version) stamp remains a KNOWN GAP — no build-time version
@@ -228,7 +297,7 @@ export interface DebugRegistry {
     /** D15/T-D15.3/.5 — the CURRENT shared game tick (the same counter the
      *  built-in `time` provider's `tick` field reads), for a per-world
      *  `InputManager.poll(tick)` call to key its `scheduleActionAtTick`
-     *  numbering off — see `setup-three-root-adapter.ts`'s `systems.add('input',
+     *  numbering off — see `world3d-react/r3f-root-factory.tsx`'s `systems.add('input',
      *  ...)` wiring. `0` for a bare `createDebugRegistry()` test stand-in with
      *  no real `Game`/tick counter behind it (matching `getTick`'s own
      *  constructor-supplied default in that case). */

package/dist/runtime/debug-registry.d.ts.map

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

package/dist/runtime/debug-registry.js

@@ -1,6 +1,6 @@
 /**
  * The game-scoped debug/synthetic-player registry. ONE registry per `Game` root —
- * every world's `ctx.debug` (see `DebugCtxSurface`, `runtime/types.ts`) feeds the
+ * every world's `ctx.debug` (see {@link DebugCtxSurface} below) feeds the
  * SAME registry via {@link DebugRegistry.forRoot}, so a name a game registers is
  * visible (and name-collision-checked) across every world, not just the one that
  * registered it. `createGame` (`runtime/game.ts`) constructs the registry
@@ -10,8 +10,8 @@
  * rather than threading it through every call site.
  *
  * Provenance note: a registration's "world" is the MOUNT's adapter id (the
- * `fromSetup(id, ...)` / `SetupThreeRootConfig.id` a project already names each
- * world's entry with) rather than the `RootInstance.id` `registerThreeRoot`
+ * id a project's root adapter already carries) rather than the
+ * `RootInstance.id` `registerThreeRoot`
  * assigns — that id isn't known until AFTER `mount()` resolves (`create-
  * runtime.ts` calls `registerThreeRoot` with it only once `mount()` returns),
  * which is after every `setup()`-time registration has already run. For the

package/dist/runtime/dev-build.d.ts

@@ -9,8 +9,8 @@
  *
  * Ownership, stated in one place (the build rule):
  *  - OWNER: this function. It resolves the answer; nothing else derives it.
- *  - SHARERS: the two three-root adapters (`adapter/setup-three-root-adapter.ts`
- *    and `world3d-react/r3f-adapter.tsx`), which seed live render vitals only
+ *  - SHARERS: the three-root adapter (`world3d-react/r3f-root-factory.tsx`),
+ *    which seeds live render vitals only
  *    under it, and the `static-batch` capability's mutation watch and `Frozen`
  *    warning. Any future dev-only instrument calls this too, with its own
  *    `override`.