@vgai/engine 0.5.2 → 0.5.3

package/src/runtime/game.ts

@@ -1,40 +1,35 @@
 /**
  * Game root — T7.1 slice 1 ("introduce Game internally") + slice 2 ("world
  * registry + ordered frame algorithm"), extended in T7.3 slice 1 with real
- * `'pixijs'`-kind `WorldInstance` support (`stage`/`physics2d`/`collisions2d`,
- * a real `pixiRoot()`) so `world2d/pixi-game-adapter.ts` can register its
- * world onto a real `Game` instead of driving its own loop, and in T7.3
- * slice 2 with a construction-time stage check (symmetric with the
- * threejs/scene check) and the two-world (threejs + pixijs) proof
- * (`test/game-three-plus-pixi.test.ts`). T6.2 slice 1 adds real `'react'`-kind
- * `WorldInstance` support (`container`, a real `reactRoot()`) — the DOM-root
- * world surface `runtime/create-runtime.ts`'s roots path now mounts (see
- * `docs/REACT-WORLD-DESIGN.md` §1.B); react roots host no `ComponentManager`
- * (D8 — components attaching to a react-kind manager already throw,
- * `ecs/component-manager.ts`), so `physics`/`collisions`/`camera`/`frame`
- * stay `undefined` for them exactly like an opaque/foreign mount.
+ * `'canvas'`-kind `RootInstance` support (`stage`/`physics2d`, a real
+ * `pixiStage()`) so a canvas adapter can register its world onto a real `Game`
+ * instead of driving its own loop, and in T7.3 slice 2 with a
+ * construction-time stage check (symmetric with the three/scene check).
+ * T6.2 slice 1 adds real `'react'`-kind
+ * `RootInstance` support (`container`, a real `reactRoot()`) — the DOM-root
+ * world surface `runtime/create-runtime.ts`'s roots path now mounts, with
+ * `physics`/`collisions`/`camera`/`frame` `undefined` for them exactly
+ * like an opaque/foreign mount.
  *
- * See `docs/GAME-ROOT-DESIGN.md` (D6), particularly §4 (the frame algorithm)
- * and §8 stage 2, for the full target shape. This file holds the Game/
- * WorldInstance shell, the NEW game-scoped `SystemRunner`, and the
- * host-facing `runFrame` frame executor. The public surface is NOT frozen
- * yet — do not add these exports to a barrel/index; only the in-scope
- * runtime/adapter files import this module directly. The `gpu` per-world
- * cache is the one remaining slice-1 omission.
+ * (D6), particularly §4 (the frame algorithm) and §8 stage 2, for the full
+ * target shape. This file holds the Game/ RootInstance shell, the NEW
+ * game-scoped `SystemRunner`, and the host-facing `runFrame` frame executor.
+ * The public surface is NOT frozen yet — do not add these exports to a
+ * barrel/index; only the in-scope runtime/adapter files import this module
+ * directly. The `gpu` per-world cache is the one remaining slice-1 omission.
  */
 
 // TYPE-ONLY pixi import (T7.3 slice 1): `game.ts` must never value-import
 // `pixi.js` — a value import would pull the Pixi runtime into 3D-only
-// bundles that never touch world2d. Every pixi-typed field below is erased
+// bundles that never touch a canvas root. Every pixi-typed field below is erased
 // at compile time; nothing here constructs or calls into Pixi.
 import type * as PIXI from 'pixi.js';
 import type * as THREE from 'three';
 import type { AdapterSurface as AdapterSurfaceLeaf } from '../adapter/adapter-surface';
-import { createInputManagerAdapter } from '../adapter/first-party-systems';
-import type { MountedWorld } from '../adapter/game-adapter';
 import { formatAudioGateMessage, formatLoopGateMessage } from '../adapter/loop-gate-report';
+import type { MountedRoot } from '../adapter/root-adapter';
+import type { MountedSetupThreeRoot } from '../adapter/setup-three-root-adapter';
 import type { SystemAdapters } from '../adapter/system-adapter';
-import type { VgaiMountedGame } from '../adapter/vgai-scene-game-adapter';
 import type { AssetCache } from '../assets';
 import type { createGameLoop } from '../core/game-loop';
 import {
@@ -42,19 +37,18 @@ import {
   DEFAULT_SEEDED_RANDOM_SEED,
   registerSeededRandom,
 } from '../core/seeded-random';
+import { createSimClock, registerSimClock, type SimClockInternal } from '../core/sim-clock';
 import { createSystemRunner, type SystemRunner } from '../core/system-runner';
 import { PHASE_ORDER, SystemPhase, type SystemPhaseName } from '../core/types';
 import { createPerformanceProfiler, type PerformanceProfiler } from '../dev/performance-profiler';
-import type { ComponentManager } from '../ecs/component-manager';
-import type { GameComponent } from '../ecs/game-component';
+import { hasUserData } from '../ecs/user-data';
 import { InputManager } from '../input/input-manager';
 import type { CollisionSystem } from '../physics/collision-system';
 import type { PhysicsRegistry } from '../physics/physics-registry';
+// TYPE-ONLY (same rule as the pixi import above): this lives under `pixi/`,
+// but `game.ts` only ever names its TYPE.
+import type { Physics2DRegistry } from '../pixi/physics-registry';
 import type { AudioContext as GameAudio } from '../setup/setup-audio';
-// TYPE-ONLY (same rule as the pixi import above): these live under
-// `world2d/`, but `game.ts` only ever names their TYPES.
-import type { Collision2DSystem } from '../world2d/collision-2d';
-import type { Physics2DRegistry } from '../world2d/physics2d-registry';
 import {
   createDebugRegistry,
   DebugError,
@@ -63,27 +57,42 @@ import {
 } from './debug-registry';
 import { createGameplayRngTrap, registerGameplayRngTrapControl } from './gameplay-rng-trap';
 import { createStateBridge, type GameStateBridge } from './state-bridge';
+import type { GameContext, PlaytestContext } from './types';
 
-/** The one loop type — `createGameLoop`'s return shape (D1, fixed-step). */
+/** The one loop type — `createGameLoop`'s return shape (fixed-step sim,
+ *  display-rate presentation since WO-P13). */
 export type GameLoop = ReturnType<typeof createGameLoop>;
 
 /**
- * Game-level play-state control surface (D10, T7.6 — `docs/DECISIONS-PENDING.md`
- * §D10): pause/resume/step as ONE control surface on the running game, with
- * PER-WORLD `pausable` semantics (`WorldInstance.pausable`) — a menu/HUD world
- * declaring `pausable: false` keeps ticking (input, components, physics) while
- * every `pausable: true` world freezes. Interacts with D1 (deliberate
- * fixed-rate rendering): a paused-and-pausable world's `render` phase still
- * runs every substep (with `dt` forced to `0`, so time-based render effects —
- * e.g. a post-processing pass with its own internal clock — don't silently
- * keep animating under a "frozen" scene) — simulation freezes, the screen does
- * not go black. `GameLoop.timeScale` (unaffected by this) remains the
- * orthogonal "speed up/slow down" axis — pausing never touches it, so the
- * host's accumulator/rAF loop keeps ticking at its normal cadence and keeps
- * calling `runFrame`, which is what makes "paused still renders" possible
- * (the previous `GameSession.pause()` implementation set `loop.timeScale = 0`,
- * which — per D1 — starves the accumulator and stops rendering too; that was
- * the bug this control surface replaces, not a compatible behavior to keep).
+ * WO-P13 — 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
+ * definition of "the render phases" across all three, kept in `PHASE_ORDER`'s
+ * own order.
+ */
+const DISPLAY_RATE_PHASES: readonly SystemPhaseName[] = PHASE_ORDER.filter(
+  (phase) => phase === SystemPhase.PRE_RENDER || phase === SystemPhase.RENDER,
+);
+
+/**
+ * Game-level play-state control surface (D10, T7.6): pause/resume/step as ONE
+ * control surface on the running game, with PER-WORLD `pausable` semantics
+ * (`RootInstance.pausable`) — a menu/HUD world declaring `pausable: false` keeps
+ * ticking (input, physics) while every `pausable: true` world
+ * freezes. A paused-and-pausable world's `render` phase still runs (with `dt`
+ * forced to `0`, so time-based render effects — e.g. a post-processing pass with
+ * its own internal clock — don't silently keep animating under a "frozen" scene)
+ * — simulation freezes, the screen does not go black. WO-P13 changed only the
+ * CADENCE of that: once per display frame under a host that drives
+ * `runRenderFrame`, once per substep under one that still renders inside
+ * `runFrame`. `GameLoop.timeScale` (unaffected by this) remains the orthogonal
+ * "speed up/slow down" axis — pausing never touches it, so the host's
+ * accumulator/rAF loop keeps ticking at its normal cadence, which is what makes
+ * "paused still renders" possible (the previous `GameSession.pause()`
+ * implementation set `loop.timeScale = 0`, which starves the accumulator — and,
+ * before WO-P13, stopped rendering with it; that was the bug this control
+ * surface replaces, not a compatible behavior to keep).
  */
 export interface PlayState {
   /** Whether the game is currently paused (game-level — see the per-world
@@ -94,10 +103,9 @@ export interface PlayState {
    * while already paused is a no-op) and, for every `pausable`, self-driven
    * (`drivesOwnLoop`) world, invoke its loop-gate capability
    * (`mounted.setPaused(true)`) — reporting loudly, once per world, when that
-   * capability is absent (an honest "cannot gate" instead of a silent no-op,
-   * `docs/CAPABILITY-TIERS.md` §d). Also silences every `pausable` world's
-   * audio via its `SystemAdapters.audio` (absent ⇒ the same loud, once-only
-   * report).
+   * capability is absent (an honest "cannot gate" instead of a silent no-op).
+   * Also silences every `pausable` world's audio via its
+   * `SystemAdapters.audio` (absent ⇒ the same loud, once-only report).
    */
   pause(): void;
   /** Resume every `pausable` world — the inverse of `pause()`, same
@@ -122,28 +130,27 @@ export interface PlayState {
 }
 
 /**
- * The kinds of render surface a world can be. `'threejs'` and `'pixijs'`
- * roots are real as of T7.3 slice 1 (`create-runtime.ts`'s default threejs
- * world; `world2d/pixi-game-adapter.ts`'s pixi world); `'react'` is named
+ * The kinds of render surface a world can be. `'three'` and `'canvas'`
+ * roots are both real; `'react'` is named
  * here so the type is already shaped for T7.4 and no caller has to widen a
  * union later.
  *
  * Re-exported from `adapter/adapter-surface.ts` (T7.5) — moved there so
- * `adapter/game-adapter.ts`'s kind-tagged `MountedWorld` types can name it
+ * `adapter/root-adapter.ts`'s kind-tagged `MountedRoot` types can name it
  * without an import cycle back to this file. This re-export keeps every
  * existing `import type { AdapterSurface } from '../runtime/game'` call site
- * (`ecs/game-component.ts`, `ecs/component-manager.ts`) compiling unchanged.
+ * (`ecs/behavior.ts`, `ecs/component-manager.ts`) compiling unchanged.
  */
 export type AdapterSurface = AdapterSurfaceLeaf;
 
 /**
- * A world's per-phase frame hooks (GAME-ROOT-DESIGN §4, T7.1 slice 2).
- * Populated on a `WorldInstance` only for first-party mounts — an opaque/
+ * A world's per-phase frame hooks (T7.1 slice 2).
+ * Populated on a `RootInstance` only for first-party mounts — an opaque/
  * foreign mount has no phase-partitioned entry point, so it stays
  * `undefined` and the Game's frame executor (`GameInternal.runFrame`) falls
  * back to calling its single `mounted.update(dt)` once per substep instead.
  */
-export interface WorldFrameHooks {
+export interface RootFrameHooks {
   /** Run this world's engine systems + component ticks + world-bound game
    *  systems for one phase. For a first-party world this delegates to the
    *  SAME `SystemRunner.runPhase` its (legacy) `mounted.update` uses. */
@@ -156,58 +163,55 @@ export interface WorldFrameHooks {
 }
 
 /**
- * A single world instance: the unit of adaptation (GAME-ROOT-DESIGN §3).
+ * A single world instance: the unit of adaptation.
  * Slice-1 subset — `gpu` (per-world GPU resource cache, §6.2) is omitted
  * until the slice that builds it.
  */
-export interface WorldInstance {
+export interface RootInstance {
   /** Manifest id (T3.1). Slice 1 always registers exactly one: `'main'`. */
   readonly id: string;
   readonly kind: AdapterSurface;
   /** Per-world play/pause semantics (D10, T7.6). Slice 1 always `true`. */
   readonly pausable: boolean;
-  /** The GameAdapter that produced `mounted` — first-party or external.
-   *  Deliberately narrower than `GameAdapter<K>` (T7.5): this field is only
-   *  ever read for `.id` (`Game.registerWorld`'s diagnostic message below) —
-   *  never re-invoked — and `GameAdapter<K>`'s `mount` signature legitimately
-   *  differs per kind's host type (a pixijs adapter's `World2DHost`, a react
-   *  adapter's `ReactWorldHost`, vs a threejs adapter's `HostContext`), so
-   *  requiring the FULL interface here would force a cast at every non-
-   *  threejs registration site for no behavioral gain — see `AdapterHandle`
-   *  below. */
+  /** The RootAdapter that produced `mounted` — first-party or external.
+   *  Deliberately narrower than `RootAdapter<K>` (T7.5): this field is only
+   *  ever read for `.id` (`Game.registerRoot`'s diagnostic message below) —
+   *  never re-invoked — and `RootAdapter<K>`'s `mount` signature legitimately
+   *  differs per kind's host CONTEXT (`HostContextFor<K>`, P-8: a canvas
+   *  adapter's `CanvasHostContext`, a react adapter's `DomHostContext`, vs a
+   *  three adapter's `ThreeHostContext`), so requiring the FULL interface here
+   *  would force each registration site to name its own `K` for no behavioral
+   *  gain — see `AdapterHandle` below. */
   readonly adapter: AdapterHandle;
-  /** The live mounted surface — one of `MountedWorld`'s kind-tagged shapes
-   *  (T7.5; `MountedThreeWorld` for a threejs world, `MountedPixiWorld` for
-   *  pixijs, `MountedReactWorld` for react). */
-  readonly mounted: MountedWorld;
+  /** The live mounted surface — one of `MountedRoot`'s kind-tagged shapes
+   *  (T7.5; `MountedThreeRoot` for a three world, `MountedPixiRoot` for
+   *  canvas, `MountedReactRoot` for react). */
+  readonly mounted: MountedRoot;
   /** Kind-narrowed accessor: throws a descriptive error when this world is
-   *  not a threejs world. */
-  threeRoot(): THREE.Scene;
-  /** Kind-narrowed accessor for pixijs roots (T7.3): returns the stage
-   *  passed to `createWorldInstance` for a `'pixijs'`-kind world. Throws
-   *  descriptively for a non-pixijs world, or a pixijs world built without
-   *  a `stage` (see `WorldInstanceInit.stage`). */
-  pixiRoot(): PIXI.Container;
-  /** Kind-narrowed accessor for react roots (T6.2 slice 1,
-   *  `docs/REACT-WORLD-DESIGN.md` §1.B): returns the DOM-root layer
-   *  `<div>` the host mounted this world's react tree into (the SAME
-   *  element passed as `container` to `createWorldInstance` — identity
-   *  matters, mirroring `threeRoot()`/`pixiRoot()`'s "same instance the
-   *  adapter mounted" contract). Throws descriptively for a non-react
-   *  world, or a react world built without a `container` (see
-   *  `WorldInstanceInit.container`). */
+   *  not a three world. */
+  threeScene(): THREE.Scene;
+  /** Kind-narrowed accessor for canvas roots (T7.3): returns the stage
+   *  passed to `createRootInstance` for a `'canvas'`-kind world. Throws
+   *  descriptively for a non-pixijs world, or a canvas world built without
+   *  a `stage` (see `RootInstanceInit.stage`). */
+  pixiStage(): PIXI.Container;
+  /** Kind-narrowed accessor for react roots (T6.2 slice 1): returns the
+   *  DOM-root layer `<div>` the host mounted this world's react tree into
+   *  (the SAME element passed as `container` to `createRootInstance` —
+   *  identity matters, mirroring `threeScene()`/`pixiStage()`'s "same
+   *  instance the adapter mounted" contract). Throws descriptively for a
+   *  non-react world, or a react world built without a `container` (see
+   *  `RootInstanceInit.container`). */
   reactRoot(): HTMLElement;
   /** Present only when the world's mount is first-party (Rapier3D for
-   *  threejs roots). */
+   *  three roots). */
   readonly physics?: PhysicsRegistry | undefined;
   readonly collisions?: CollisionSystem | undefined;
-  /** Present only when the world's mount is a first-party pixijs world
-   *  (Rapier2D, T7.3) — the 2D analog of `physics`/`collisions` above. Kept
-   *  as separate fields (not folded into `physics`/`collisions` as a union)
-   *  so 3D call sites keep their non-union `PhysicsRegistry`/`CollisionSystem`
-   *  typing unchanged. */
+  /** Present only when the world's mount owns a Rapier-2D world — the 2D
+   *  analog of `physics` above. Kept as a separate field (not folded into
+   *  `physics` as a union) so 3D call sites keep their non-union
+   *  `PhysicsRegistry` typing unchanged. */
   readonly physics2d?: Physics2DRegistry | undefined;
-  readonly collisions2d?: Collision2DSystem | undefined;
   /** Kind-typed via `mounted` in T7.5; `unknown` here deliberately. */
   readonly camera?: unknown;
   /** Phase-partitioned frame entry point (T7.1 slice 2) — present only for
@@ -215,55 +219,54 @@ export interface WorldInstance {
    *  `GameInternal.runFrame` drives via its single `mounted.update` call
    *  instead (unless it `drivesOwnLoop`, in which case it isn't ticked at
    *  all — see `runFrame`). */
-  readonly frame?: WorldFrameHooks | undefined;
+  readonly frame?: RootFrameHooks | undefined;
 }
 
 /**
- * Minimal identity surface `WorldInstance.adapter` needs (T7.5) — see that
- * field's doc comment for why it's narrower than `GameAdapter<K>`. Any real
- * adapter object (a NAMED type, not a fresh object literal) — `GameAdapter<K>`,
- * `Pixi2DGameAdapter`, `ReactRootAdapter`, or a project's own custom adapter —
+ * Minimal identity surface `RootInstance.adapter` needs (T7.5) — see that
+ * field's doc comment for why it's narrower than `RootAdapter<K>`. Any real
+ * adapter object (a NAMED type, not a fresh object literal) — `RootAdapter<K>`,
+ * `Pixi2DRootAdapter`, `ReactRootAdapter`, or a project's own custom adapter —
  * satisfies this trivially (extra members beyond `id` are always fine for a
  * non-literal source); a bare `{ id, mount }` object literal built INLINE at
- * a `createWorldInstance`/`registerXWorld` call site needs an intermediate
+ * a `createRootInstance`/`registerXRoot` call site needs an intermediate
  * `const` (excess-property checking only special-cases fresh literals).
  */
 export interface AdapterHandle {
   readonly id: string;
 }
 
-/** Inputs to {@link createWorldInstance}. */
-export interface WorldInstanceInit {
+/** Inputs to {@link createRootInstance}. */
+export interface RootInstanceInit {
   readonly id: string;
   readonly kind: AdapterSurface;
   /** Defaults to `true` (D10's per-world default). */
   readonly pausable?: boolean;
   readonly adapter: AdapterHandle;
-  readonly mounted: MountedWorld;
-  /** Required when `kind === 'threejs'` — backs `threeRoot()`. */
+  readonly mounted: MountedRoot;
+  /** Required when `kind === 'three'` — backs `threeScene()`. */
   readonly scene?: THREE.Scene | undefined;
-  /** Required when `kind === 'pixijs'` — backs `pixiRoot()` (T7.3 slice 2,
-   *  symmetric with `scene` for threejs above). */
+  /** Required when `kind === 'canvas'` — backs `pixiStage()` (T7.3 slice 2,
+   *  symmetric with `scene` for three above). */
   readonly stage?: PIXI.Container | undefined;
-  /** Required when `kind === 'react'` — backs `reactRoot()` (T6.2 slice 1,
+  /** Required when `kind === 'dom'` — backs `reactRoot()` (T6.2 slice 1,
    *  symmetric with `scene`/`stage` above): the DOM-root layer `<div>` this
    *  world's react tree is mounted into. */
   readonly container?: HTMLElement | undefined;
   readonly physics?: PhysicsRegistry | undefined;
   readonly collisions?: CollisionSystem | undefined;
   readonly physics2d?: Physics2DRegistry | undefined;
-  readonly collisions2d?: Collision2DSystem | undefined;
   readonly camera?: unknown;
-  readonly frame?: WorldFrameHooks | undefined;
+  readonly frame?: RootFrameHooks | undefined;
 }
 
 /**
- * Build a `WorldInstance` whose kind-narrowed accessors throw descriptively
- * on kind mismatch (GAME-ROOT-DESIGN §3). This is the one place that builds
- * `threeRoot`/`pixiRoot`, so every world (however it's constructed, in this
+ * Build a `RootInstance` whose kind-narrowed accessors throw descriptively
+ * on kind mismatch. This is the one place that builds
+ * `threeScene`/`pixiStage`, so every world (however it's constructed, in this
  * slice or later ones) gets identical throw behavior.
  */
-export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
+export function createRootInstance(init: RootInstanceInit): RootInstance {
   const {
     id,
     kind,
@@ -276,50 +279,48 @@ export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
     physics,
     collisions,
     physics2d,
-    collisions2d,
     camera,
     frame,
   } = init;
 
-  // A threejs world with no scene has nothing for `threeRoot()` to return —
-  // fail loudly HERE, at construction, rather than letting `threeRoot()`
-  // throw its generic "not a threejs world" message later for a world whose
-  // kind IS threejs (checklist item 5; a misleading error for this case).
-  if (kind === 'threejs' && !scene) {
+  // 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
+  // kind IS three (checklist item 5; a misleading error for this case).
+  if (kind === 'three' && !scene) {
     throw new Error(
-      `WorldInstance "${id}" (kind: threejs): a threejs world requires a scene — ` +
-        'pass `scene` in WorldInstanceInit.',
+      `RootInstance "${id}" (kind: three): a three world requires a scene — ` +
+        'pass `scene` in RootInstanceInit.',
     );
   }
 
-  // Symmetric check for pixijs (T7.3 slice 2) — a pixijs world with no stage
-  // has nothing for `pixiRoot()` to return; fail loudly here, at
-  // construction, same as the threejs/scene check above.
-  if (kind === 'pixijs' && !stage) {
+  // Symmetric check for canvas (T7.3 slice 2) — a canvas world with no stage
+  // has nothing for `pixiStage()` to return; fail loudly here, at
+  // construction, same as the three/scene check above.
+  if (kind === 'canvas' && !stage) {
     throw new Error(
-      `WorldInstance "${id}" (kind: pixijs): a pixijs world requires a stage — ` +
-        'pass `stage` in WorldInstanceInit.',
+      `RootInstance "${id}" (kind: canvas): a canvas world requires a stage — ` +
+        'pass `stage` in RootInstanceInit.',
     );
   }
 
-  // Symmetric check for react (T6.2 slice 1, docs/REACT-WORLD-DESIGN.md
-  // §1.B) — a react world with no container has nothing for `reactRoot()`
-  // to return; fail loudly here, at construction, same as the two checks
-  // above.
-  if (kind === 'react' && !container) {
+  // Symmetric check for react (T6.2 slice 1) — a react world with no
+  // container has nothing for `reactRoot()` to return; fail loudly here,
+  // at construction, same as the two checks above.
+  if (kind === 'dom' && !container) {
     throw new Error(
-      `WorldInstance "${id}" (kind: react): a react world requires a container — ` +
-        'pass `container` in WorldInstanceInit.',
+      `RootInstance "${id}" (kind: react): a react world requires a container — ` +
+        'pass `container` in RootInstanceInit.',
     );
   }
 
-  // Disposed-world guard (GAME-ROOT-DESIGN §8 stage 3 / T7.1 slice 3). There
-  // is no `unregisterWorld` (decision 4 — roots are manifest-declared; a
+  // Disposed-world guard (T7.1 slice 3). There
+  // is no `unregisterRoot` (decision 4 — roots are manifest-declared; a
   // whole Game is disposed, not one world out of its registry), so a caller
   // that disposes ONE world's `mounted` directly (e.g. ending a sub-session)
-  // leaves that `WorldInstance` sitting in `Game.roots` — and `runFrame`
+  // leaves that `RootInstance` sitting in `Game.roots` — and `runFrame`
   // would otherwise keep invoking its (now-torn-down) frame hooks every
-  // subsequent frame. `MountedGame` has no public "am I disposed" flag to
+  // subsequent frame. `MountedThreeRoot` has no public "am I disposed" flag to
   // 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)
@@ -334,7 +335,7 @@ export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
     disposed = true;
     originalDispose();
   };
-  const guardedFrame: WorldFrameHooks | undefined = frame
+  const guardedFrame: RootFrameHooks | undefined = frame
     ? {
         runPhase(phase, dt) {
           if (disposed) return;
@@ -356,26 +357,25 @@ export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
     physics,
     collisions,
     physics2d,
-    collisions2d,
     camera,
     frame: guardedFrame,
-    threeRoot(): THREE.Scene {
-      if (kind !== 'threejs' || !scene) {
+    threeScene(): THREE.Scene {
+      if (kind !== 'three' || !scene) {
         throw new Error(
-          `WorldInstance "${id}" (kind: ${kind}): threeRoot() requested but this world is not ` +
-            'a threejs world',
+          `RootInstance "${id}" (kind: ${kind}): threeScene() requested but this world is not ` +
+            'a three world',
         );
       }
       return scene;
     },
-    pixiRoot(): PIXI.Container {
-      // The `!stage` branch a pixijs world could hit here is now unreachable
-      // (T7.3 slice 2): construction above throws for `kind === 'pixijs'`
-      // with no `stage`, symmetric with `threeRoot()`'s `scene` guard.
-      if (kind !== 'pixijs' || !stage) {
+    pixiStage(): PIXI.Container {
+      // The `!stage` branch a canvas world could hit here is now unreachable
+      // (T7.3 slice 2): construction above throws for `kind === 'canvas'`
+      // with no `stage`, symmetric with `threeScene()`'s `scene` guard.
+      if (kind !== 'canvas' || !stage) {
         throw new Error(
-          `WorldInstance "${id}" (kind: ${kind}): pixiRoot() requested but this world is not ` +
-            'a pixijs world',
+          `RootInstance "${id}" (kind: ${kind}): pixiStage() requested but this world is not ` +
+            'a canvas world',
         );
       }
       return stage;
@@ -383,11 +383,11 @@ export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
     reactRoot(): HTMLElement {
       // The `!container` branch a react world could hit here is now
       // unreachable (T6.2 slice 1): construction above throws for
-      // `kind === 'react'` with no `container`, symmetric with
-      // `threeRoot()`/`pixiRoot()`'s guards.
-      if (kind !== 'react' || !container) {
+      // `kind === 'dom'` with no `container`, symmetric with
+      // `threeScene()`/`pixiStage()`'s guards.
+      if (kind !== 'dom' || !container) {
         throw new Error(
-          `WorldInstance "${id}" (kind: ${kind}): reactRoot() requested but this world is not ` +
+          `RootInstance "${id}" (kind: ${kind}): reactRoot() requested but this world is not ` +
             'a react world',
         );
       }
@@ -397,40 +397,131 @@ export function createWorldInstance(init: WorldInstanceInit): WorldInstance {
 }
 
 /**
- * Type guard for whether a `MountedGame` is a first-party
- * `VgaiSceneGameAdapter` mount (has a live `GameContext` at `.ctx`). Used to
+ * 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` (and, on `Game`,
- * `components`/`input`/`audio`) can be populated from it — an external
+ * `input`/`audio`) 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` — world2d's `MountedGame2D` (`world2d/pixi-game-adapter.ts`) also
- * has a `ctx` key (a `World2DContext`, unrelated to `GameContext`), so a
- * structural `'ctx' in mounted` check would misfire once T7.3 registers 2D
- * roots onto the same `Game`. The probe is a plain property read, not an
- * `instanceof`/value import of `vgai-scene-game-adapter.ts` — the
- * `VgaiMountedGame` import above stays type-only.
+ * 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: MountedWorld): mounted is VgaiMountedGame {
+export function isFirstPartyMounted(mounted: MountedRoot): mounted is MountedSetupThreeRoot {
   return (mounted as { firstParty?: unknown }).firstParty === true;
 }
 
 /**
- * The Game root (GAME-ROOT-DESIGN §3). Owns the one loop, the raw-asset
+ * One world's half of a debris disposal, as {@link disposeDebrisSubtree} needs
+ * it. A first-party `GameContext` satisfies this structurally.
+ *
+ * `physics`/`rapierWorld` are OPTIONAL: an owner that builds no first-party
+ * Rapier runtime (an R3F world) carries neither, and {@link
+ * disposeDebrisSubtree} reads them behind `readRapierHandles` rather than
+ * unconditionally.
+ */
+export interface DebrisOwner {
+  readonly physics?: GameContext['physics'];
+  readonly rapierWorld?: GameContext['rapierWorld'];
+}
+
+/**
+ * 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
+ * `ComponentManager`-only owner) that builds no first-party physics runtime.
+ */
+function readRapierHandles(owner: DebrisOwner): {
+  physics: NonNullable<DebrisOwner['physics']>;
+  rapierWorld: GameContext['rapierWorld'];
+} | null {
+  const { physics, rapierWorld } = owner;
+  if (!physics || !rapierWorld) return null;
+  return { physics, rapierWorld };
+}
+
+/**
+ * P3 — what `SimClock.disposeAfter` actually does. `core/sim-clock.ts` knows
+ * 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
+ * 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
+ * owner does not own, so offering the subtree to each is safe.
+ *
+ * Safe on an object already removed or already disposed: `removeFromParent` on
+ * a parentless `Object3D` is a no-op and three's `dispose()` calls are
+ * idempotent.
+ */
+export function disposeDebrisSubtree(
+  obj: THREE.Object3D,
+  owners: ReadonlyArray<DebrisOwner>,
+): void {
+  const nodes: THREE.Object3D[] = [];
+  obj.traverse((node) => nodes.push(node));
+  for (const owner of owners) {
+    const rapier = readRapierHandles(owner);
+    if (!rapier) continue;
+    for (const node of nodes) {
+      const refs = rapier.physics.get(node);
+      if (!refs) continue;
+      rapier.rapierWorld.removeRigidBody(refs.body);
+      rapier.physics.remove(node);
+    }
+  }
+  obj.removeFromParent();
+  for (const node of nodes) {
+    // Duck-typed rather than `instanceof THREE.Mesh` so this module keeps its
+    // TYPE-ONLY three import (it is surface-neutral — it also hosts pixi
+    // roots). Covers Points/Line/Sprite debris too, which a Mesh check would
+    // silently leak.
+    const drawable = node as Partial<THREE.Mesh>;
+    if (!hasUserData(node, '__sharedGeometry')) drawable.geometry?.dispose();
+    const material = drawable.material;
+    if (Array.isArray(material)) {
+      for (const m of material) m.dispose();
+    } else {
+      material?.dispose();
+    }
+  }
+}
+
+/**
+ * The {@link DebrisOwner}s one registered world contributes: its `GameContext`
+ * when the mount is first-party, else nothing. 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: RootInstance): DebrisOwner[] {
+  return isFirstPartyMounted(world.mounted) ? [world.mounted.ctx] : [];
+}
+
+/**
+ * The Game root. Owns the one loop, the raw-asset
  * cache, the world registry, and (T7.1 slice 2) the game-scoped
- * `SystemRunner`. `components`/`input`/`audio` remain slice-1 late
+ * `SystemRunner`. `input`/`audio` remain slice-1 late
  * additions: they delegate to the default world's first-party mount so
  * existing single-world call sites keep working; hoisting them to true
- * Game ownership (GAME-ROOT-DESIGN §3's target shape) is a later slice's
+ * Game ownership (the target shape) is a later slice's
  * work, not this one's.
  */
 export interface Game {
   readonly loop: GameLoop;
   readonly assets: AssetCache;
+  /** Host identity for this private play run or coordinated Team Test. */
+  readonly playtest?: PlaytestContext | null;
   /** Per-game diagnostic store. Disabled by default; the editor enables it on demand. */
   readonly profiler: PerformanceProfiler;
   /**
-   * The game-scoped `SystemRunner` (GAME-ROOT-DESIGN §4, T7.1 slice 2) — a
+   * The game-scoped `SystemRunner` (T7.1 slice 2) — a
    * NEW bucket, separate from any world's own runner. Within each phase,
    * `GameInternal.runFrame` runs THIS runner's `runPhase` first, before any
    * world's engine systems/component ticks/world-bound game systems (e.g.
@@ -441,111 +532,114 @@ export interface Game {
    */
   readonly systems: SystemRunner;
   /** Declaration-ordered. Slice 1 registers exactly one (the default
-   *  threejs world) — this is the SAME array reference `registerWorld`
+   *  three world) — this is the SAME array reference `registerRoot`
    *  mutates, not a snapshot, so holders (e.g. `GameContext.roots`) observe
    *  later registrations. */
-  readonly roots: ReadonlyArray<WorldInstance>;
-  world(id: string): WorldInstance | null;
-  /** First threejs world, else first world. Throws descriptively when no
+  readonly roots: ReadonlyArray<RootInstance>;
+  world(id: string): RootInstance | null;
+  /** First three world, else first world. Throws descriptively when no
    *  world has been registered yet. */
-  readonly defaultWorld: WorldInstance;
+  readonly defaultRoot: RootInstance;
   /**
-   * Game-scoped aggregation of every world's `SystemAdapters` (§7.1-3,
-   * `docs/GAME-ROOT-DESIGN.md` §3: "`registerSystemAdapter` is game-scoped" —
-   * the recorded decision this getter finally implements; probe1). Each
-   * mounted world builds its OWN `mounted.systems` object (a game registers
-   * capabilities like `networking` from ITS OWN `setup()`, via
-   * `ctx.registerSystemAdapter`, per-world) — this merges every world's
-   * `mounted.systems` into ONE `SystemAdapters`, in `roots` REGISTRATION
-   * order, first registration wins per key. A later world registering the
-   * SAME kind (e.g. two roots both exposing `networking`) does not
-   * override the first — instead this warns ONCE per (game instance, key)
-   * naming both world ids, matching this file's `[game] world "<id>" …`
-   * console idiom (see `registerWorld` below). NOT to be confused with
-   * `Game.systems` (the game-scoped `SystemRunner` bucket, an entirely
-   * different concept — see that field's doc comment) — this name was
-   * deliberately chosen not to collide with it.
+   * Game-scoped aggregation of every world's `SystemAdapters` (§7.1-3:
+   * "`registerSystemAdapter` is game-scoped" — the recorded decision this
+   * getter finally implements; probe1). Each mounted world builds its OWN
+   * `mounted.systems` object (a game registers capabilities like `networking`
+   * from ITS OWN `setup()`, via `ctx.registerSystemAdapter`, per-world) —
+   * this merges every world's `mounted.systems` into ONE `SystemAdapters`, in
+   * `roots` REGISTRATION order, first registration wins per key. A later
+   * world registering the SAME kind (e.g. two roots both exposing
+   * `networking`) does not override the first — instead this warns ONCE per
+   * (game instance, key) naming both world ids, matching this file's `[game]
+   * world "<id>" …` console idiom (see `registerRoot` below). NOT to be
+   * confused with `Game.systems` (the game-scoped `SystemRunner` bucket, an
+   * entirely different concept — see that field's doc comment) — this name
+   * was deliberately chosen not to collide with it.
    *
    * A plain getter (recomputed on every read, not cached) so a LATER
-   * `registerWorld` call (or a world's setup registering a NEW adapter kind
+   * `registerRoot` call (or a world's setup registering a NEW adapter kind
    * after this was first read) is always reflected — only the COLLISION
    * warning is deduped (once per key, for the lifetime of this `Game`).
    * Includes every world regardless of first-party-ness — `mounted.systems`
    * is a capability any adapter (first-party or foreign) may expose.
    */
   readonly systemAdapters: SystemAdapters;
-  /** Delegates to the default world's first-party `ComponentManager`.
-   *  Throws when the default world is not a first-party mount. */
-  readonly components: ComponentManager;
+  /** Subscribe when a mounted root registers or replaces a system adapter. */
+  subscribeSystemAdapters?(listener: () => void): () => void;
   /** The one game-owned `InputManager`, shared by every first-party root. */
   readonly input: InputManager;
   /** Delegates to the default world's first-party audio context. Throws
    *  when the default world is not a first-party mount. */
   readonly audio: GameAudio;
   /**
-   * Frame-versioned state bridge (T7.4 slice 1 — `docs/REACT-STATE-BRIDGE.md`
-   * §2). Bumped once per completed `runFrame`, after all phases of all
-   * roots and all `endFrame` hooks (see `runFrame`'s tail below). This is
-   * the ONE subscription surface `useGameState`
-   * (`@vgai/engine/react/game-state`) — or any
-   * other frame-versioned consumer — subscribes to; `state-bridge.ts` itself
-   * has no react import, matching the rest of `runtime/`.
+   * Frame-versioned state bridge (T7.4 slice 1). Bumped once per completed
+   * `runFrame`, after all phases of all roots and all `endFrame` hooks (see
+   * `runFrame`'s tail below). This is the ONE subscription surface
+   * `useWorldState` (`@vgai/engine/react/world-state`) — or any other
+   * frame-versioned consumer — subscribes to; `state-bridge.ts` itself has no
+   * react import, matching the rest of `runtime/`.
    */
   readonly state: GameStateBridge;
   /** Game-level play-state control surface (D10, T7.6) — see {@link PlayState}. */
   readonly play: PlayState;
   /**
-   * Cross-world component query (GAME-ROOT-DESIGN §5, T7.1 slice 3) — the
-   * game-level half; `ComponentManager.queryByComponent` (`ecs/
-   * component-manager.ts`) is the per-world half this aggregates.
+   * WO-P13 — the interpolation alpha the most recent display frame presented
+   * at: `accumulator / fixedDt`, in `[0, 1]`. `0` means "exactly on the last
+   * completed fixed state", `0.5` means "halfway to the next one".
    *
-   * Iterates `roots` in declaration order, querying each world's
-   * `ComponentManager` — the first-party mount's `ctx.components`, or the
-   * optional `MountedWorldBase.components` capability for a non-first-party
-   * adapter that runs a real manager (e.g. `@engine/world3d-react`'s R3F
-   * mount — its `<Behavior>` components are aggregated here exactly like
-   * scene-authored ones). A mount with neither is skipped (an opaque/foreign
-   * world hosts no `GameComponent`s). `opts.worldId`/`opts.kind` apply as
-   * world-level filters; the per-world results are concatenated. No filter (`opts` omitted) spans **every** world — that is the
-   * whole point of this API existing (D7's "cross-world flow is ordinary
-   * component access", e.g. a pixi minimap component querying the 3D
-   * world's tank components).
+   * Read it to interpolate your own transforms between the last two fixed
+   * states; it is the same number `onRenderStep` hands its callbacks, exposed
+   * here for code that renders from somewhere other than a callback. Stays
+   * `0` for a Game whose host never wired a display-rate render pass (see
+   * {@link onRenderStep}).
+   */
+  readonly renderAlpha: number;
+  /**
+   * WO-P13 — the `RenderStepped`-shaped host: register a callback that runs
+   * ONCE PER DISPLAY FRAME, before that frame's `preRender`/`render` phases,
+   * with `(alpha, displayDt)`.
+   *
+   * This is the seam for presentation-only work whose natural rate is the
+   * monitor's, not the simulation's — camera polish/smoothing, procedural
+   * sway, a cosmetic bob. It is NOT a gameplay hook: it can fire twice
+   * between two fixed substeps (120 Hz display, 60 Hz sim) and zero times
+   * across a `runTicks` fast-forward, so anything that must be deterministic
+   * belongs in a fixed phase (`ctx.systems.add`, a `useFrame` hook, a
+   * `useFrame`) instead.
    *
-   * Returns component **instances**, not nodes — `inst.world`/typed node
-   * accessors (`inst.object3D`, the generic `inst.node`) are T7.2's; this
-   * API's contract freezes HERE. The physical ONE-`ComponentManager`
-   * unification (partitioning one manager by (phase, world) instead of one
-   * manager per world) lands with T7.2/T7.3 — this per-world-aggregation
-   * implementation is the compatible interim: callers written against this
-   * signature keep working unchanged once the manager is unified
-   * underneath.
+   * Reached from game code as `ctx.game?.onRenderStep(...)`. Returns an
+   * unsubscribe function; pass `opts.signal` to unsubscribe with the same
+   * `AbortSignal` a `setup()` already uses for its listeners and sim timers
+   * (`core/sim-clock.ts`'s ownership section — cancelling what you registered
+   * is the game's job, and a stale render-step closure is the same hazard
+   * class as a stale event listener).
    *
-   * `T extends GameComponent<AdapterSurface>` (not the bare default-`'threejs'`
-   * `GameComponent`, T7.3 slice 2) — the whole point of a CROSS-WORLD query
-   * is spanning every kind in one call (the T7.3 AC,
-   * `test/game-three-plus-pixi.test.ts`), so a `GameComponent<'pixijs'>`
-   * subclass must type-check here exactly like a default-kind one does.
+   * Silent-no-op honesty: a callback registered on a Game whose host wired no
+   * display-rate render pass (a bare test harness, a `drivesOwnLoop`-only
+   * mount, an `externalDrive` capture page) never fires, because nothing
+   * drives it. That is the same shape as `ctx.clock` on a Game-less mount.
    */
-  queryByComponent<T extends GameComponent<AdapterSurface>>(
-    cls: new () => T,
-    opts?: { worldId?: string; kind?: AdapterSurface },
-  ): T[];
+  onRenderStep(
+    fn: (alpha: number, displayDt: number) => void,
+    opts?: { signal?: AbortSignal | undefined },
+  ): () => void;
 }
 
 /**
- * Host-internal extension of {@link Game}: adds `registerWorld` (the host's
+ * Host-internal extension of {@link Game}: adds `registerRoot` (the host's
  * wiring surface for populating the world registry) and `runFrame` (the
  * frame executor). NEITHER is part of the game-facing `Game` surface —
- * games/components never call either directly; the host loop
+ * games never call either directly; the host loop
  * (`createGameRuntime`) and `GameSession.step()` are the only callers of
  * `runFrame`.
  */
 export interface GameInternal extends Game {
+  /** Host-side signal used by root contexts after `registerSystemAdapter`. */
+  notifySystemAdaptersChanged(): void;
   /** Append a world in declaration order. Throws on a duplicate id. */
-  registerWorld(world: WorldInstance): void;
+  registerRoot(world: RootInstance): void;
   /**
-   * Run ONE fixed substep across every phase and every world
-   * (GAME-ROOT-DESIGN §4):
+   * Run ONE fixed substep across every phase and every world:
    *
    * ```
    * for phase in PHASE_ORDER:
@@ -585,19 +679,55 @@ export interface GameInternal extends Game {
    * `endFrame` with the real `dt` (not the render-phase's forced `0`), and
    * touches no other world at all — a natural no-op while not paused, since
    * the frozen set is then empty.
+   *
+   * WO-P13 addendum: `opts.skipRenderPhases` omits `preRender`+`render` from
+   * the pass — every other phase, and `endFrame`, run exactly as always. A
+   * host that drives presentation at DISPLAY rate sets it on every substep
+   * and calls {@link runRenderFrame} once per real frame instead
+   * (`create-runtime.ts`). A host that does
+   * not set it keeps the pre-WO-P13 shape verbatim — which is why
+   * `externalDrive` capture (`render-control.ts`'s `simulateSubsteps`, which
+   * calls `runFrame(fixedDt)` with no opts) is frame-exact and unchanged.
+   * `runTicks` sets it per tick for its `render: 'none' | 'last'` modes.
+   */
+  runFrame(dt: number, opts?: { ignorePause?: boolean; skipRenderPhases?: boolean }): void;
+  /**
+   * WO-P13 — run ONE display frame's presentation pass: the registered
+   * `onRenderStep` callbacks, then the `preRender` and `render` phases across
+   * game-scoped systems and every host-driven world, in the same
+   * game-systems-then-worlds order {@link runFrame} uses.
+   *
+   * ```
+   * for cb in onRenderStep callbacks: cb(alpha, displayDt)
+   * for phase in [preRender, render]:
+   *   game.systems.runPhase(phase, displayDt)
+   *   for world in roots (declaration order):
+   *     if world.mounted.drivesOwnLoop: continue
+   *     world.frame?.runPhase(phase, frozen ? 0 : displayDt)
+   * ```
+   *
+   * Advances NOTHING: no `tick`, no `simT`, no sim-clock flush, no state-bridge
+   * bump, no `endFrame`. It is presentation only, which is what makes calling
+   * it at a rate the simulation does not share safe in the first place.
+   *
+   * D10's pause rule carries over unchanged in substance: a frozen world
+   * (paused + `pausable`) still RENDERS — that is what keeps a paused editor
+   * viewport painted — but with `dt` forced to `0`, so no time-based render
+   * effect animates a frozen scene. What changes is only the cadence: once per
+   * display frame instead of once per fixed substep.
    */
-  runFrame(dt: number, opts?: { ignorePause?: boolean }): void;
+  runRenderFrame(alpha: number, displayDt: number): void;
   /**
-   * D15/T-D15.3-.4 (`docs/D15-DETERMINISM-DESIGN.md` §2.b) — a deterministic
-   * fast-forward primitive: synchronously call the SAME per-tick pipeline
-   * `runFrame` uses, `n` times in a tight loop, with `dt` fixed to the host
-   * loop's own fixed timestep (`this.loop.fixedDt` — `core/game-loop.ts`).
-   * This generalizes `render-control.ts`'s proven `VgaiRenderHarness.
-   * simulateSubsteps` from the capture-only door (`?vgai-render=1`) to a
-   * Game-level primitive every door can reach (the bridge's
-   * `window.__vgai.runTicks`, the editor relay's `run-ticks` case →
-   * `play.runTicks`) — `simulateSubsteps` itself is UNTOUCHED by this
-   * addition (it may later delegate to this method; not this unit's job).
+   * D15/T-D15.3-.4 — a deterministic fast-forward primitive: synchronously
+   * call the SAME per-tick pipeline `runFrame` uses, `n` times in a tight
+   * loop, with `dt` fixed to the host loop's own fixed timestep
+   * (`this.loop.fixedDt` — `core/game-loop.ts`). This generalizes
+   * `render-control.ts`'s proven `VgaiRenderHarness. simulateSubsteps` from
+   * the capture-only door (`?vgai-render=1`) to a Game-level primitive every
+   * door can reach (the bridge's `window.__vgai.runTicks`, the editor relay's
+   * `run-ticks` case → `play.runTicks`) — `simulateSubsteps` itself is
+   * UNTOUCHED by this addition (it may later delegate to this method; not
+   * this unit's job).
    *
    * Semantics:
    * - **Decoupled from wall clock and the accumulator.** `runTicks` drives
@@ -620,7 +750,7 @@ export interface GameInternal extends Game {
    *   never renders, not even the last tick. `tick`/`simT`/
    *   `stateBridge.bump()`/the debug event ring advance identically on
    *   EVERY tick regardless of `render` — only the paint-affecting phases
-   *   are skipped, so state watchers (`useGameState`, debug state providers)
+   *   are skipped, so state watchers (`useWorldState`, debug state providers)
    *   stay correct even when fast-forwarding with no visible output.
    * - **Refuses while paused.** Throws a structured `DebugError`
    *   (`code: 'RUN_TICKS_PAUSED'`) if `Game.play.paused` is true —
@@ -637,8 +767,8 @@ export interface GameInternal extends Game {
   runTicks(n: number, opts?: RunTicksOptions): void;
   /**
    * ADAPTER-MOUNT surface, not game-facing: an adapter's `mount()` calls
-   * this (via `host.game` — the classic `VgaiSceneGameAdapter` and the R3F
-   * `createR3FWorldContext` both do) to load the game-owned input map ONCE,
+   * this (via `host.game` — the classic `SetupThreeRootAdapter` and the R3F
+   * `createR3FRootContext` both do) to load the game-owned input map ONCE,
    * even when several roots ask for the same path; competing paths throw
    * (input is game-owned, so roots cannot load competing maps). GAME code
    * never calls this — a project's map loads automatically at mount from
@@ -651,7 +781,7 @@ export interface GameInternal extends Game {
   dispose(): void;
 }
 
-function describeMismatch(handle: 'components' | 'input' | 'audio', world: WorldInstance): string {
+function describeMismatch(handle: 'input' | 'audio', world: RootInstance): string {
   return (
     `Game.${handle}: default world "${world.id}" (kind: ${world.kind}) is not a first-party ` +
     "mount — hoisting these to true Game ownership is a later slice's work; available only " +
@@ -662,31 +792,32 @@ function describeMismatch(handle: 'components' | 'input' | 'audio', world: World
 /**
  * Construct the (host-internal) Game shell. Callers: `createGameRuntime`
  * builds this BEFORE mounting its one adapter, then registers the default
- * threejs world once mount resolves (see `registerThreeWorld` in
+ * three world once mount resolves (see `registerThreeRoot` in
  * `create-runtime.ts`).
  */
 export function createGame(opts: {
   loop: GameLoop;
   assets: AssetCache;
+  playtest?: PlaytestContext | null | undefined;
   /** D15 (T-D15.1) — the root seed `ctx.random` boots from, on every world
    *  mounted onto this Game. Defaults to `DEFAULT_SEEDED_RANDOM_SEED` (a
    *  fixed, non-wall-clock constant — `ctx.random` is always reproducible
    *  on its own terms, whether or not the project's manifest DECLARES that
    *  reproducibility as a contract). The manifest-aware boot path
-   *  (`mount-manifest.ts`'s `mountManifestWorlds`) is what actually resolves
+   *  (`mount-manifest.ts`'s `mountManifestRoots`) is what actually resolves
    *  `manifest.determinism.defaultSeed`/`?vgai-seed=`/explicit config and
    *  passes the result here, BEFORE any world's `mount()`/`setup()` runs —
    *  `createGameRuntime` always constructs the Game (this call) first (see
    *  this function's own doc comment below). */
   seed?: number | undefined;
 }): GameInternal {
-  const roots: WorldInstance[] = [];
+  const roots: RootInstance[] = [];
   const profiler = createPerformanceProfiler();
   const systems = createSystemRunner(profiler.systemObserver, 'game');
   const input = new InputManager();
   const stateBridge = createStateBridge();
   // D15 (T-D15.1) — the game-scoped seeded-random surface every world's
-  // `ctx.random` aliases (see `vgai-scene-game-adapter.ts`'s `ctx.random =
+  // `ctx.random` aliases (see `setup-three-root-adapter.ts`'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
@@ -711,14 +842,39 @@ export function createGame(opts: {
       return rngTrapEnabled;
     },
   };
-  // T1.2 (docs/SYNTHETIC-PLAYER-SPEC.md §3.1/§3.3): `tick` counts completed
-  // fixed substeps, `simT` accumulates their `dt` — both game-scoped, bumped
-  // ONLY where `stateBridge.bump()` is (guarded by `advanced`, `runFrame`'s
-  // tail below), so a paused/frozen frame never advances either. The debug
-  // registry reads them via suppliers (not by capturing the numbers now)
-  // so its built-in `time` provider always sees the CURRENT values.
+  // `tick` counts completed fixed substeps, `simT` accumulates their `dt` —
+  // both game-scoped, bumped ONLY where `stateBridge.bump()` is (guarded by
+  // `advanced`, `runFrame`'s tail below), so a paused/frozen frame never
+  // advances either. The debug registry reads them via suppliers (not by
+  // capturing the numbers now) so its built-in `time` provider always sees
+  // the CURRENT values.
   let tick = 0;
   let simT = 0;
+  // WO-P13 — 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
+  // state, which is exactly what makes running them at the monitor's rate safe.
+  let renderAlpha = 0;
+  const renderStepCallbacks = new Set<(alpha: number, displayDt: number) => void>();
+  // P3 — the ONE sim clock this Game owns, declared beside the accumulator it
+  // is bound to (`flush(simT)` runs at the tail of `runFrameImpl`, inside the
+  // same `advanced` guard as the two bumps above, so a paused/frozen frame
+  // fires no timers). Every world's `ctx.clock` is THIS instance, reached the
+  // same way `ctx.random`/`ctx.debug` reach their game-scoped singletons —
+  // `getSimClock(host.game)` over the WeakMap filed below.
+  //
+  // 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
+  // ordering for ONE subtree.
+  const simClock: SimClockInternal = createSimClock({
+    // Every mount that could own part of the subtree is offered it:
+    // `physics.get` is a no-op for a node the mount does not own, so this is
+    // correct with several three roots on one Game and needs no ownership
+    // bookkeeping.
+    dispose: (obj) => disposeDebrisSubtree(obj, roots.flatMap(debrisOwnersOf)),
+  });
   const debugRegistry = createDebugRegistry({
     getTick: () => tick,
     getSimT: () => simT,
@@ -726,11 +882,11 @@ export function createGame(opts: {
     // registry's world-addressed input-target compatibility surface. Every
     // first-party root now registers the SAME game-owned InputManager, but the
     // stable default id still keeps explicit/implicit debug routing coherent.
-    // Use the SAME "first threejs world, else first world" rule
-    // `requireDefaultWorld` (declared just below — safe: this closure is
+    // Use the SAME "first three world, else first world" rule
+    // `requireDefaultRoot` (declared just below — safe: this closure is
     // only ever CALLED later, once at least one world has mounted) already
-    // defines for `Game.defaultWorld`.
-    getDefaultWorldId: () => (roots.length > 0 ? requireDefaultWorld().id : null),
+    // defines for `Game.defaultRoot`.
+    getDefaultRootId: () => (roots.length > 0 ? requireDefaultRoot().id : null),
     // Issue #175 — the built-in `time` provider's `loopLiveness` field reads
     // the REAL loop, not any UI-level play-state store: `opts.loop` is the
     // SAME `GameLoop` this `Game`'s own `.loop` field exposes, so this
@@ -738,7 +894,6 @@ export function createGame(opts: {
     // the loop is actually ticking.
     getLoopLiveness: () => opts.loop.liveness,
   });
-  const inputAdapter = createInputManagerAdapter(input);
   let inputFrameActive = false;
   systems.add(
     'input',
@@ -747,19 +902,19 @@ export function createGame(opts: {
     },
     { name: 'input.poll' },
   );
-  input.setDebugEmit((event, detail) => debugRegistry.forWorld('(game)').emit(event, detail));
+  input.setDebugEmit((event, detail) => debugRegistry.forRoot('(game)').emit(event, detail));
   let inputMapPath: string | null = null;
   let inputMapLoad: Promise<void> | null = null;
 
-  function requireDefaultWorld(): WorldInstance {
+  function requireDefaultRoot(): RootInstance {
     if (roots.length === 0) {
-      throw new Error('Game.defaultWorld: no roots registered yet');
+      throw new Error('Game.defaultRoot: no roots registered yet');
     }
-    return roots.find((w) => w.kind === 'threejs') ?? roots[0]!;
+    return roots.find((w) => w.kind === 'three') ?? roots[0]!;
   }
 
-  function requireFirstPartyCtx(handle: 'components' | 'input' | 'audio') {
-    const world = requireDefaultWorld();
+  function requireFirstPartyCtx(handle: 'input' | 'audio') {
+    const world = requireDefaultRoot();
     if (!isFirstPartyMounted(world.mounted)) {
       throw new Error(describeMismatch(handle, world));
     }
@@ -772,6 +927,7 @@ export function createGame(opts: {
   // short of a new `createGame` call, matching `reportedGateShortfalls`
   // above's "once per game instance" idiom.
   const warnedSystemAdapterKeys = new Set<string>();
+  const systemAdapterListeners = new Set<() => void>();
   // 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
   function computeSystemAdapters(): SystemAdapters {
     // Debug is game-scoped: React hooks, probes, and the built-in time
@@ -780,17 +936,14 @@ export function createGame(opts: {
     // root may still publish this SAME adapter (the first-party Three/Pixi
     // mounts do); the reference-equality branch below treats that as the
     // intentional shared registration it is.
-    const result: SystemAdapters = { debug: debugRegistry.adapter, input: inputAdapter };
-    const ownerWorldId = new Map<string, string>([
-      ['debug', '(game)'],
-      ['input', '(game)'],
-    ]);
+    const result: SystemAdapters = { debug: debugRegistry.adapter };
+    const ownerRootId = new Map<string, string>([['debug', '(game)']]);
     for (const world of roots) {
       const adapters = world.mounted.systems;
       if (!adapters) continue;
       for (const key of Object.keys(adapters) as (keyof SystemAdapters)[]) {
         if (adapters[key] === undefined) continue;
-        const existingOwner = ownerWorldId.get(key);
+        const existingOwner = ownerRootId.get(key);
         if (existingOwner !== undefined) {
           // Reference-equality short-circuit: two roots sharing the ONE
           // game-scoped debug registry's adapter (T1.1) both expose the SAME
@@ -803,14 +956,14 @@ export function createGame(opts: {
             console.warn(
               `[game] systemAdapters: "${key}" is registered by both world "${existingOwner}" and ` +
                 `world "${world.id}" — the FIRST registration ("${existingOwner}") wins; the later ` +
-                'one is shadowed (docs/GAME-ROOT-DESIGN.md §3: game-scoped system adapters).',
+                '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 as any)[key] = adapters[key];
-        ownerWorldId.set(key, world.id);
+        ownerRootId.set(key, world.id);
       }
     }
     return result;
@@ -834,7 +987,7 @@ export function createGame(opts: {
     // Other native `console.warn`/`console.error` call sites in this file are
     // unsuppressed and already counted in the lint baseline (see `runFrame`'s
     // impl below); this one is a NEW site, so it's suppressed to keep this
-    // task's diff at zero NEW warnings (same reasoning as `overlay-report.ts`'s
+    // task's diff at zero NEW warnings (same reasoning as `achieved-tier.ts`'s
     // identical suppression).
     // biome-ignore lint/suspicious/noConsole: see comment above
     console.warn(message);
@@ -845,7 +998,7 @@ export function createGame(opts: {
    *  absent — shared by `pause()`/`resume()` below (same fan-out, opposite
    *  boolean). */
   // 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 setWorldGates(next: boolean): void {
+  function setRootGates(next: boolean): void {
     for (const world of roots) {
       if (!world.pausable) continue; // pausable:false roots are untouched by design
       if (world.mounted.drivesOwnLoop) {
@@ -868,7 +1021,7 @@ export function createGame(opts: {
     }
   }
 
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the frame algorithm (GAME-ROOT-DESIGN §4, now with D10's per-world pause gate + the onlyFrozen step()-only mode) is one cohesive nested loop over phases/roots — splitting it would obscure the ordering contract documented on GameInternal.runFrame
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the frame algorithm (now with D10's per-world pause gate + the onlyFrozen step()-only mode) is one cohesive nested loop over phases/roots — splitting it would obscure the ordering contract documented on GameInternal.runFrame
   function runFrameImpl(
     dt: number,
     frameOpts?: { ignorePause?: boolean; onlyFrozen?: boolean; skipRenderPhases?: boolean },
@@ -882,11 +1035,14 @@ export function createGame(opts: {
     if (rngTrapEnabled) rngTrap.enable();
     profiler.beginFrame();
     const ignorePause = frameOpts?.ignorePause ?? false;
-    // D15/T-D15.4: internal-only render-phase skip (not part of the public
-    // `GameInternal.runFrame` signature — no external caller sets it, mirroring
-    // `onlyFrozen` below) — `runTicks`'s `render: 'none'|'last'` fast-forward
-    // mode sets this on every tick it doesn't want to paint. See `runTicks`'s
-    // doc comment on `GameInternal` for the full contract.
+    // D15/T-D15.4 + WO-P13: 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.
     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
@@ -1069,7 +1225,7 @@ export function createGame(opts: {
       }
     }
 
-    // T7.4 slice 1 (REACT-STATE-BRIDGE.md §2): bump + notify LAST, after
+    // T7.4 slice 1: bump + notify LAST, after
     // every phase of every world and every world's endFrame/update above —
     // subscribers must only ever observe post-frame state. Bumped at most
     // once per completed `runFrame`/`step()` call, never per phase/world —
@@ -1080,30 +1236,115 @@ export function createGame(opts: {
       stateBridge.bump();
       tick++;
       simT += dt;
+      // P3 — sim timers fire IMMEDIATELY after the bump, inside this same
+      // `advanced` guard: a paused/frozen world advances no sim time, so it
+      // must fire no timers either, and `Game.play.step()` (which reaches this
+      // block with `advanced` set by the frozen-set loop above) fires exactly
+      // the timers that ONE substep makes due. One flush === one completed
+      // substep, which is what lets `SimClock.tickNow()` simply count flushes
+      // and always agree with `tick`.
+      simClock.flush(simT);
     }
     profiler.endFrame();
     if (rngTrapEnabled) rngTrap.disable();
   }
 
+  /**
+   * WO-P13 — 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
+   * loop.
+   *
+   * Three deliberate parallels with `runFrameImpl`, so the two passes cannot
+   * drift into different rules for the same situation:
+   *  - game-scoped systems run before per-world hooks, per phase;
+   *  - one world's throw is logged and isolated, never allowed to starve a
+   *    sibling still due this phase;
+   *  - the RNG trap brackets the whole pass, so `Math.random` called from a
+   *    render-phase system is still caught by D15's dev-mode trap — it was,
+   *    back when this pass lived inside `runFrame`, and moving code must not
+   *    quietly move it out from under a guard.
+   *
+   * Profiler note (a real, accepted consequence): the profiler's "frame" has
+   * always meant "one `runFrame` call", so a display frame now produces the
+   * substep records it always did PLUS one record for this pass, carrying the
+   * `preRender`/`render` spans and the renderer counters. Re-modelling the
+   * profiler's frame boundary around the display frame is a separate change to
+   * a debugging surface, not part of flipping the loop.
+   */
+  function runRenderFrameImpl(alpha: number, displayDt: number): void {
+    renderAlpha = alpha;
+    if (rngTrapEnabled) rngTrap.enable();
+    profiler.beginFrame();
+
+    // `RenderStepped` first: a camera adjusted here is drawn by THIS frame's
+    // render phase, not next frame's. Iterated over a snapshot so a callback
+    // that unsubscribes itself (or registers another) cannot mutate the set
+    // mid-iteration.
+    if (renderStepCallbacks.size > 0) {
+      for (const fn of [...renderStepCallbacks]) {
+        try {
+          fn(alpha, displayDt);
+        } catch (err) {
+          console.error('[game] an onRenderStep callback threw:', err);
+        }
+      }
+    }
+
+    const n = roots.length;
+    for (const phase of DISPLAY_RATE_PHASES) {
+      profiler.beginPhase();
+      systems.runPhase(phase, displayDt);
+      for (let i = 0; i < n; i++) {
+        const world = roots[i]!;
+        if (world.mounted.drivesOwnLoop) continue;
+        // D10/T7.6, carried over verbatim in substance: a frozen world still
+        // renders (a paused viewport stays painted) but with `dt` forced to
+        // `0`, and skips every other phase.
+        const frozen = paused && world.pausable;
+        if (frozen && phase !== SystemPhase.RENDER) continue;
+        try {
+          world.frame?.runPhase(phase, frozen ? 0 : displayDt);
+        } catch (err) {
+          console.error(
+            `[game] world "${world.id}" (kind: ${world.kind}) runPhase("${phase}") threw ` +
+              '(display frame):',
+            err,
+          );
+        }
+      }
+      profiler.endPhase(phase);
+    }
+
+    profiler.endFrame();
+    if (rngTrapEnabled) rngTrap.disable();
+  }
+
   const gameInternal: GameInternal = {
     loop: opts.loop,
     assets: opts.assets,
+    playtest: opts.playtest ?? null,
     profiler,
     systems,
     get roots() {
       return roots;
     },
-    world(id: string): WorldInstance | null {
+    world(id: string): RootInstance | null {
       return roots.find((w) => w.id === id) ?? null;
     },
-    get defaultWorld() {
-      return requireDefaultWorld();
+    get defaultRoot() {
+      return requireDefaultRoot();
     },
     get systemAdapters() {
       return computeSystemAdapters();
     },
-    get components() {
-      return requireFirstPartyCtx('components').components;
+    subscribeSystemAdapters(listener: () => void) {
+      systemAdapterListeners.add(listener);
+      return () => systemAdapterListeners.delete(listener);
+    },
+    notifySystemAdaptersChanged() {
+      for (const listener of systemAdapterListeners) listener();
     },
     input,
     get audio() {
@@ -1117,12 +1358,12 @@ export function createGame(opts: {
       pause() {
         if (paused) return;
         paused = true;
-        setWorldGates(true);
+        setRootGates(true);
       },
       resume() {
         if (!paused) return;
         paused = false;
-        setWorldGates(false);
+        setRootGates(false);
       },
       step(dt = 1 / 60) {
         // Self-driven pausable roots advance via their adapter's `step()`
@@ -1155,72 +1396,37 @@ export function createGame(opts: {
         runFrameImpl(dt, { onlyFrozen: true });
       },
     },
-    queryByComponent<T extends GameComponent<AdapterSurface>>(
-      cls: new () => T,
-      opts?: { worldId?: string; kind?: AdapterSurface },
-    ): T[] {
-      // Checklist item 8a: a `worldId` naming a world that doesn't exist is a
-      // caller error (typo'd id, wrong manifest) — degrade loudly, matching
-      // repo habit, rather than silently returning `[]`. A worldId that DOES
-      // exist but isn't first-party legitimately answers "no components"
-      // below (the loop's `!isFirstPartyMounted` `continue`), which stays
-      // silent — that's a real, not a mistaken, empty result.
-      if (opts?.worldId !== undefined && !roots.some((w) => w.id === opts.worldId)) {
-        throw new Error(`Game.queryByComponent: unknown worldId "${opts.worldId}"`);
-      }
-      const result: T[] = [];
-      for (const world of roots) {
-        // A world's manager comes from its first-party ctx OR from the
-        // optional `MountedWorldBase.components` capability (a non-first-
-        // party adapter running the engine's REAL ComponentManager — e.g.
-        // `@engine/world3d-react`'s R3F mount, whose `<Behavior>` components
-        // used to be invisible here: the query compiled, ran, and returned
-        // `[]` forever). A mount with NEITHER hosts no GameComponents, so
-        // its silent empty contribution is a real, not a mistaken, result.
-        const manager = isFirstPartyMounted(world.mounted)
-          ? world.mounted.ctx.components
-          : world.mounted.components;
-        if (!manager) continue;
-        if (opts?.worldId !== undefined && world.id !== opts.worldId) continue;
-        if (opts?.kind !== undefined && world.kind !== opts.kind) continue;
-        // Checklist item 8b: a plain for-loop push instead of
-        // `result.push(...arr)` — spread-as-arguments can hit engine/runtime
-        // argument-count limits once a world's instance count gets large.
-        const instances = manager.queryByComponent(cls);
-        for (const inst of instances) result.push(inst);
-      }
-      return result;
-    },
-    registerWorld(world: WorldInstance): void {
+    registerRoot(world: RootInstance): void {
       if (roots.some((w) => w.id === world.id)) {
-        throw new Error(`Game.registerWorld: duplicate world id "${world.id}"`);
+        throw new Error(`Game.registerRoot: duplicate world id "${world.id}"`);
       }
       // Checklist item 6: the SAME `mounted` object registered under two
       // world ids would be double-ticked by `runFrame` (its `frame.runPhase`/
       // `endFrame` called once per registration) and double-dispose-wrapped
-      // (`createWorldInstance` wraps `mounted.dispose` in place — a second
+      // (`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
-      // `VgaiSceneGameAdapter.dispose` being idempotent; a foreign adapter
+      // `SetupThreeRootAdapter.dispose` being idempotent; a foreign adapter
       // has no such guarantee). Reject it outright instead.
       if (roots.some((w) => w.mounted === world.mounted)) {
         throw new Error(
-          `Game.registerWorld: world "${world.id}" shares its \`mounted\` object with an ` +
+          `Game.registerRoot: world "${world.id}" shares its \`mounted\` object with an ` +
             `already-registered world ("${roots.find((w) => w.mounted === world.mounted)!.id}") — ` +
             'the same mount cannot be registered twice.',
         );
       }
       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
-      // (docs/R3F-FIRST-PARTY-DESIGN.md W3, gate 4): `mountAllWorldSpecs`
-      // (`create-runtime.ts`) mounts roots SEQUENTIALLY, and a react world's
-      // `adapter.mount()` (`resolveDefaultReactAdapter`/`mountOneReactWorld`)
-      // 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
-      // caller calls `registerWorld` for that very world. A `useGameState`
+      // "roots: " (empty) hang in `36-r3f-first-party.spec.ts` on CI (gate
+      // 4): `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
+      // 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.
       // Previously the ONLY way such a subscriber ever saw the corrected
@@ -1232,57 +1438,85 @@ export function createGame(opts: {
       // that first tick can be delayed well past a test's assertion window,
       // or — if the tab is ever backgrounded — not fire at all for a long
       // stretch; the subscriber's cached snapshot then sits on its stale
-      // (possibly fully empty) first render for that whole time, matching
-      // the observed CI symptom exactly ("the HUD element IS mounted; the
-      // roots list is EMPTY"). Proven red-then-green by
-      // `packages/engine/test/state-bridge.test.ts`'s "registerWorld notifies
+      // (possibly fully empty) first render for that whole time, matching the
+      // observed CI symptom exactly ("the HUD element IS mounted; the roots
+      // list is EMPTY"). Proven red-then-green by
+      // `packages/engine/test/state-bridge.test.ts`'s "registerRoot notifies
       // subscribers immediately" case: a subscriber registered before a
       // world, with `runFrame` NEVER called, only saw the update after this
-      // fix. `bump()` also advances `frameVersion` (the only invalidation
-      // key `createFrameSelectorCache`/`useGameState` understand — see
+      // fix. `bump()` also advances `frameVersion` (the only invalidation key
+      // `createFrameSelectorCache`/`useWorldState` understand — see
       // `frame-selector-cache.ts`), so this doubles as "frameVersion is
       // bumped once per completed runFrame OR once per world registered",
       // documented on `GameStateBridge.frameVersion` below.
       stateBridge.bump();
-      // T7.4 slice 2 (REACT-STATE-BRIDGE.md §4): a NON-first-party mount
+      // T7.4 slice 2: a NON-first-party mount
       // (an ingested/foreign world — first-party mounts are exempt, they're
-      // observed via `Game.state`/`useGameState` instead) with no `observe`
+      // observed via `Game.state`/`useWorldState` instead) with no `observe`
       // has no state bridge at all — react HUDs cannot subscribe to it, and
       // silently returning `undefined` forever would hide that. Report ONCE
       // per mount, at registration time, matching this file's existing
       // `[game] world "<id>" (kind: <kind>) ...` console idiom (see
       // `runFrame` below).
       //
-      // §7.1-15: a `kind: 'react'` world is ALSO exempt — it has no `observe`
-      // BY DESIGN (D8/REACT-WORLD-DESIGN.md: a react world's own mounted tree
-      // reads state via `Game.state`/`useGameState`, the SAME first-party
-      // bridge a threejs/pixijs world's HUD uses, never `WorldStateObserver`
+      // §7.1-15: a `kind: 'dom'` world is ALSO exempt — it has no `observe`
+      // BY DESIGN (D8: a react world's own mounted tree
+      // reads state via `Game.state`/`useWorldState`, the SAME first-party
+      // bridge a three/canvas world's HUD uses, never `RootStateObserver`
       // — that hook is scoped to the ingested/foreign-world case). Without
       // this exemption every production react world logged a false-positive
       // "no state bridge" warning at registration (probe: every real react
       // world mount), eroding the signal for a genuinely un-observable
       // ingested world.
-      // A mount exposing the engine's real ComponentManager (notably the R3F
-      // first-party adapter) is observable through Game.queryByComponent +
-      // Game.state even though it does not carry the classic scene adapter's
-      // `firstParty` brand. Requiring a foreign-world `observe` bridge there
-      // produces a false warning while the canonical bridge is already live.
+      // 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
+      // foreign-world `observe` bridge there produces a false warning while
+      // the canonical bridge is already live.
       if (
         !isFirstPartyMounted(world.mounted) &&
-        !world.mounted.components &&
-        world.kind !== 'react' &&
+        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` (WorldStateObserver); ' +
-            'react HUDs/useWorldObservation cannot subscribe to its state (docs/REACT-STATE-BRIDGE.md §4).',
+            'no state bridge — this mounted game has no `observe` (RootStateObserver); ' +
+            'react HUDs/useRootObservation cannot subscribe to its state.',
         );
       }
     },
-    runFrame(dt: number, frameOpts?: { ignorePause?: boolean }): void {
+    runFrame(dt: number, frameOpts?: { ignorePause?: boolean; skipRenderPhases?: boolean }): void {
       runFrameImpl(dt, frameOpts);
     },
+    runRenderFrame(alpha: number, displayDt: number): void {
+      runRenderFrameImpl(alpha, displayDt);
+    },
+    get renderAlpha() {
+      return renderAlpha;
+    },
+    onRenderStep(
+      fn: (alpha: number, displayDt: number) => void,
+      stepOpts?: { signal?: AbortSignal | undefined },
+    ): () => void {
+      const signal = stepOpts?.signal;
+      // Already-aborted is a no-op registration, never a throw — the same
+      // `AbortSignal` contract `SimClock.after` honors.
+      if (signal?.aborted) return () => {};
+      renderStepCallbacks.add(fn);
+      let detachAbort: (() => void) | null = null;
+      const unsubscribe = (): void => {
+        renderStepCallbacks.delete(fn);
+        detachAbort?.();
+        detachAbort = null;
+      };
+      if (signal) {
+        signal.addEventListener('abort', unsubscribe, { once: true });
+        detachAbort = (): void => signal.removeEventListener('abort', unsubscribe);
+      }
+      return unsubscribe;
+    },
     runTicks(n: number, ticksOpts?: RunTicksOptions): void {
       if (!Number.isInteger(n) || n < 0) {
         throw new RangeError(`Game.runTicks: n must be a non-negative integer, got ${n}`);
@@ -1294,7 +1528,7 @@ export function createGame(opts: {
         throw new DebugError(
           'RUN_TICKS_PAUSED',
           'Game.runTicks: refused — Game.play.paused is true; stepping the frozen set is ' +
-            "Game.play.step()'s contract, not runTicks' (docs/D15-DETERMINISM-DESIGN.md §2.b)",
+            "Game.play.step()'s contract, not runTicks'",
         );
       }
       const render = ticksOpts?.render ?? 'last';
@@ -1317,6 +1551,18 @@ export function createGame(opts: {
       return inputMapLoad;
     },
     dispose(): void {
+      // P3 — the sim clock is GAME-scoped, so this is the only correct place to
+      // dispose it: `create-runtime.ts`'s `fullCleanup` calls us after EVERY
+      // 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
+      // 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
+      // `debugRegistry` are game-scoped too, and per-root teardown has never
+      // destroyed either — only ever `strip(this.id)`, its own slice.
+      simClock.dispose();
       input.dispose();
       debugRegistry.strip();
     },
@@ -1339,6 +1585,9 @@ export function createGame(opts: {
   // `createGame` returns.
   registerSeededRandom(gameInternal, seededRandom);
   registerGameplayRngTrapControl(gameInternal, rngTrapControl);
+  // P3 — same "file after the shell exists" ordering: `getSimClock(game)` is
+  // how every world's mount resolves `ctx.clock` to THIS game's one clock.
+  registerSimClock(gameInternal, simClock);
 
   return gameInternal;
 }