@vgai/engine 0.5.7 → 0.5.9

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

@@ -4,8 +4,8 @@
  * 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
- * alongside the state bridge and files it in the `Game -> DebugRegistry` WeakMap
- * this module owns; later consumers (the react `useDebugProvider`/
+ * alongside the state bridge and files it in a non-enumerable game-scoped slot;
+ * later consumers (the react `useDebugProvider`/
  * `useDebugCommand` hooks, editor panels) reach it via {@link getDebugRegistry}
  * rather than threading it through every call site.
  *
@@ -20,6 +20,7 @@
  * by convention, so collision messages stay meaningful in practice.
  */
 import { z } from 'zod';
+import { createGameScopedSlot } from '../core/game-scoped-slot';
 /** 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
@@ -514,7 +515,7 @@ export function createDebugRegistry(opts) {
         },
     };
 }
-const registryByGame = new WeakMap();
+const registryByGame = createGameScopedSlot('debug-registry');
 /** Called once by `createGame`, right after both the registry and the Game
  *  shell object exist, to file the association {@link getDebugRegistry} reads. */
 export function registerDebugRegistry(game, registry) {

package/dist/runtime/dev-layers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-layers.d.ts","sourceRoot":"","sources":["../../src/runtime/dev-layers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAOxE"}
+{"version":3,"file":"dev-layers.d.ts","sourceRoot":"","sources":["../../src/runtime/dev-layers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAaxE"}

package/dist/runtime/dev-layers.js

@@ -33,6 +33,12 @@
 export function devLayersEnabled(override) {
     if (override !== undefined)
         return override;
+    // `import.meta` is cast whole, not just its `.env`: this module is reachable
+    // from programs whose tsconfig does not pull in `vite/client` (the session
+    // client's, for one, which reaches the three adapter transitively), and there
+    // `ImportMeta` has no declared `env` at all. The cast keeps the single owner
+    // of the dev answer importable from ANY program rather than forcing every
+    // downstream tsconfig to adopt Vite's ambient types.
     const env = import.meta.env;
     if (env?.DEV === true)
         return true;

package/dist/runtime/game.js

@@ -297,7 +297,7 @@ export function createGame(opts) {
     // 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.
+    // `getSimClock(host.game)` over the game-scoped slot filed below.
     //
     // The disposer is supplied HERE rather than inside the clock because
     // `core/sim-clock.ts` deliberately knows nothing about Rapier or shared
@@ -979,7 +979,7 @@ export function createGame(opts) {
             debugRegistry.strip();
         },
     };
-    // Filed AFTER the shell exists (the WeakMap keys on the Game object
+    // Filed AFTER the shell exists (the slot lives on the Game object
     // itself) so `getDebugRegistry(game)` — the react hooks' and any later
     // consumer's reach-in — works from the moment `createGame` returns.
     registerDebugRegistry(gameInternal, debugRegistry);

package/dist/runtime/gameplay-rng-trap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gameplay-rng-trap.d.ts","sourceRoot":"","sources":["../../src/runtime/gameplay-rng-trap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,MAAM,IAAI,IAAI,CAAC;IACf;;;0CAGsC;IACtC,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAG1B,GACA,eAAe,CA6CjB;AAaD,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAID;+BAC+B;AAC/B,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAEN;AAED;4CAC4C;AAC5C,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAEtF"}
+{"version":3,"file":"gameplay-rng-trap.d.ts","sourceRoot":"","sources":["../../src/runtime/gameplay-rng-trap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,MAAM,IAAI,IAAI,CAAC;IACf;;;0CAGsC;IACtC,OAAO,IAAI,IAAI,CAAC;CACjB;AAcD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAG1B,GACA,eAAe,CA6CjB;AAaD,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAID;+BAC+B;AAC/B,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAEN;AAED;4CAC4C;AAC5C,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAEtF"}

package/dist/runtime/gameplay-rng-trap.js

@@ -19,6 +19,7 @@
  * Never throws: a cosmetic third-party draw is legal, just outside the
  * contract (the design doc is explicit about this — "warn, never throw").
  */
+import { createGameScopedSlot } from '../core/game-scoped-slot';
 /** Pull a single representative "call site" line out of a captured stack —
  *  the warn-once dedupe key. `stack[0]` is the `Error:` header line,
  *  `stack[1]` is this trap's OWN wrapper frame — the caller's frame is the
@@ -82,7 +83,7 @@ export function createGameplayRngTrap(warn = (message) => {
         },
     };
 }
-const controlByOwner = new WeakMap();
+const controlByOwner = createGameScopedSlot('gameplay-rng-trap');
 /** Called once by `createGame`, alongside `registerSeededRandom`/
  *  `registerDebugRegistry`. */
 export function registerGameplayRngTrapControl(owner, control) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/engine",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Readable TypeScript game engine and universal host for Three.js, PixiJS, and React games.",
   "keywords": [
     "game-engine",

package/schemas/engine-capabilities.json

@@ -15,7 +15,7 @@
       ],
       "notes": "Grepped packages/engine/src for ccd/CCD/setCcdEnabled: zero matches. The engine constructs no rigid bodies itself — games build their own descs via ctx.RAPIER — and nothing engine-side ever enables ccd. Workaround: keep dynamic-body per-step travel small relative to the thinnest collider, or add intermediate colliders; a game may also call setCcdEnabled on its own bodies directly.",
       "evidenceHashes": {
-        "packages/engine/src/adapter/setup-three-root-adapter.ts": "fd3035e557db23e002e52707145a6e17bb3ad15767da74ec8fbafd40879d1d34"
+        "packages/engine/src/adapter/setup-three-root-adapter.ts": "b55b5aa1b032a813ddeaa1dedb6488326ed4cf3497e8cf76a07bada1e40243ea"
       }
     },
     {
@@ -67,12 +67,12 @@
       "status": "supported-with-tiers",
       "claim": "Unmodified OSS PixiJS games run via the canvas ingest seam: manifest 'iframe-reachable' + bundleUrl — in-realm capture, editor edits, overlay persistence. extraDeps must be registry-known (unknown throws); capture failure degrades loudly.",
       "evidence": [
-        "vendor/games/verify-unaltered.mjs (zero-diff vendoring gate)",
+        "vendor/games/verify-unaltered.mjs (vendored-bytes gate: zero UNRECORDED diff — byte-identical files, plus any recorded per-file patch that must reverse-apply to the pinned upstream)",
         "packages/engine/src/manifest/schema.ts"
       ],
       "notes": "Track P shipped 2026-07-03; proven: bubbo-bubbo/puzzling-potions/flappy-pixi. Tiers/limits: ARCHITECTURE-CORE.md.",
       "evidenceHashes": {
-        "vendor/games/verify-unaltered.mjs": "c41ce285aaa26a8fd0e6f5e20385b434d6fc73fc3f39ac1a61204d7141166201",
+        "vendor/games/verify-unaltered.mjs": "df875b09d698b3cfc03443ff3dba4929f5f08ea8913009d4fae253d478282312",
         "packages/engine/src/manifest/schema.ts": "63d3f6fdbe3e9323ecbd4910c540d8a77e57d95e9044016424b46ca15a5c0bea"
       }
     },
@@ -82,12 +82,12 @@
       "status": "supported-with-caveats",
       "claim": "Unmodified native-React DOM games run via the manifest `ingest-react` identity: vendored byte-for-byte (vendor/games/, zero-diff CI), mounted through the react world stack under the host React 19 (deduped). Embed-only in v1 — hosted, sized, disposed; NO authoring (the editor never writes JSX back into an unmodified game, D-N4).",
       "evidence": [
-        "vendor/games/verify-unaltered.mjs (zero-diff vendoring gate)",
+        "vendor/games/verify-unaltered.mjs (vendored-bytes gate: zero UNRECORDED diff — byte-identical files, plus any recorded per-file patch that must reverse-apply to the pinned upstream)",
         "packages/editor/src/adapter-resolver.ts"
       ],
       "notes": "Scope is native-DOM React ONLY (D-N1): R3F/@pixi/react games are canvas games and ride the three.js/pixi seams instead. Generality limit: ONE proven game (react-rpg — menu-to-dungeon e2e under React 19; both game-2 candidates rejected on evidence, R-N7). Game deps must be host-installed root deps (D-N6). Open R-N6: vendored react games' raw window listeners bypass the play-mode input gate.",
       "evidenceHashes": {
-        "vendor/games/verify-unaltered.mjs": "c41ce285aaa26a8fd0e6f5e20385b434d6fc73fc3f39ac1a61204d7141166201",
+        "vendor/games/verify-unaltered.mjs": "df875b09d698b3cfc03443ff3dba4929f5f08ea8913009d4fae253d478282312",
         "packages/editor/src/adapter-resolver.ts": "ce88071c9a4061df0a3b7edef24031bf81704ae2c3ede62ed6bf43d4f34ac556"
       }
     },

package/src/adapter/ingest/contract-debug-adapter.ts

@@ -0,0 +1,110 @@
+/**
+ * Projects a game's DECLARED system surface (`window.vgaiGame.systems`, see
+ * `game-contract.ts`) onto the host's existing {@link DebugAdapter} — the one
+ * seam `game.commands()` / `game.state()` / `game.providers()` already read
+ * through for first-party content (`command-listener.ts`'s
+ * `dispatchBridgeMethod` → `getActiveSystems().debug`).
+ *
+ * Why a projection rather than a second door: an agent driving an ingested
+ * game must not have to learn a parallel vocabulary. A first-party game
+ * registers verbs with `ctx.debug.registerCommand`; an ingested game declares
+ * them in its entry shim. Both arrive at the SAME `DebugAdapter`, so every
+ * consumer downstream — the CLI's `vgai eval`, `@vgai/e2e`'s `GameClient`, the
+ * editor's Debug Console and State Watch panels — works unchanged and unaware
+ * of the provenance.
+ *
+ * What this deliberately does NOT do:
+ * - **Validate arguments.** The first-party path validates against a declared
+ *   Zod tuple; a shim beside a foreign game is plain JS and has none. A verb
+ *   validates itself and throws its own error, which surfaces wrapped as
+ *   `DEBUG_COMMAND_FAILED` — the host never invents a schema to check against.
+ * - **Fabricate an event ring.** There is no tick loop behind an ingested
+ *   game's declarations, so `events()` is empty. That is accurate (nothing was
+ *   emitted), not a stub standing in for a missing feature.
+ */
+
+import { DebugError } from '../../runtime/debug-registry';
+import type { DebugAdapter, DebugCommandInfo, TickStampedEvent } from '../system-adapter';
+import type { VgaiGameSystems } from './game-contract';
+
+/**
+ * Build a {@link DebugAdapter} over a declared system surface, or `null` when
+ * the game declared no verbs and no state. `null` is the honest floor: the
+ * bridge then reports `DEBUG_ADAPTER_UNAVAILABLE` exactly as it did before,
+ * rather than serving an empty adapter that reads as "this game has no state"
+ * when the truth is "this game declared nothing".
+ */
+export function createContractDebugAdapter(
+  systems: VgaiGameSystems | undefined | null,
+): DebugAdapter | null {
+  const commandList = systems?.commands ?? [];
+  const providerList = systems?.state ?? [];
+  if (commandList.length === 0 && providerList.length === 0) return null;
+
+  // Snapshot into name-keyed maps once. A later duplicate shadows an earlier
+  // one and the listing de-duplicates with it, so `commands()` can never
+  // advertise a name `invoke()` would resolve differently.
+  const byCommand = new Map(commandList.map((c) => [c.name, c]));
+  const byProvider = new Map(providerList.map((p) => [p.name, p]));
+
+  return {
+    providers: () =>
+      [...byProvider.values()].map((p) => ({ name: p.name, tier: p.tier ?? 'observable' })),
+
+    state: (name: string): unknown => {
+      const provider = byProvider.get(name);
+      if (!provider) {
+        throw new DebugError(
+          'STATE_PROVIDER_NOT_FOUND',
+          `No state provider named "${name}" is declared by this game.`,
+          { registered: [...byProvider.keys()] },
+        );
+      }
+      return provider.read();
+    },
+
+    stateAll: (): Record<string, unknown> => {
+      const out: Record<string, unknown> = {};
+      for (const [name, provider] of byProvider) {
+        // One throwing provider must not cost the caller every other reading —
+        // the same per-key isolation the first-party registry gives.
+        try {
+          out[name] = provider.read();
+        } catch (err) {
+          out[name] = { __error: String(err) };
+        }
+      }
+      return out;
+    },
+
+    commands: (): DebugCommandInfo[] =>
+      [...byCommand.values()].map((c) => ({
+        name: c.name,
+        description: c.description,
+        argsJsonSchema: c.argsJsonSchema,
+        // An ingested game runs entirely in the browser realm the host mounted
+        // it in; there is no server leg for its verbs to route to.
+        locus: 'client' as const,
+      })),
+
+    invoke: async (name: string, args: unknown[]): Promise<unknown> => {
+      const command = byCommand.get(name);
+      if (!command) {
+        throw new DebugError(
+          'DEBUG_COMMAND_NOT_REGISTERED',
+          `No command named "${name}" is declared by this game.`,
+          { registered: [...byCommand.keys()] },
+        );
+      }
+      try {
+        return await command.run(...args);
+      } catch (err) {
+        throw new DebugError('DEBUG_COMMAND_FAILED', `Command "${name}" threw: ${String(err)}`, {
+          name,
+        });
+      }
+    },
+
+    events: (): TickStampedEvent[] => [],
+  };
+}

package/src/adapter/ingest/game-contract.ts

@@ -15,7 +15,7 @@
  * endpoint by endpoint: capture infers what it can (the scene), the game
  * declares what inference can't reach (its DOM root, its session lifecycle).
  *
- * Origin (root), F17+F21 (lifecycle).
+ * Origin (root), F17+F21 (lifecycle), WO-SYS1 (systems).
  */
 
 /**
@@ -34,6 +34,62 @@ export interface VgaiGameLifecycle {
   resume?(): void;
 }
 
+/**
+ * One invokable verb the game exposes. Deliberately the SAME listing shape a
+ * first-party game gets from `ctx.debug.registerCommand`
+ * (`DebugCommandInfo`/`DebugAdapter.invoke` in `adapter/system-adapter.ts`) —
+ * an ingested game's verbs must enumerate through `game.commands()` and run
+ * through `game.command(...)` with no second vocabulary for agents to learn.
+ *
+ * `run` receives the positional argument list exactly as invoked. There is no
+ * host-side validation: the contract is plain JS declared beside a foreign
+ * game, so it cannot carry a Zod tuple the way `registerCommand` does.
+ * `argsJsonSchema` is therefore DOCUMENTATION for listing surfaces, not a
+ * gate — a verb validates its own arguments and throws its own errors.
+ */
+export interface VgaiGameCommand {
+  name: string;
+  description?: string;
+  /** JSON-Schema projection of the argument list, when the game declares one. */
+  argsJsonSchema?: unknown;
+  run(...args: unknown[]): unknown | Promise<unknown>;
+}
+
+/**
+ * One named, JSON-serializable state read — the `ctx.debug.registerStateProvider`
+ * shape. `tier` carries the same meaning as the first-party one: `observable`
+ * is a value the game already computes, `assisted` is one the shim derives.
+ */
+export interface VgaiGameStateProvider {
+  name: string;
+  tier?: 'observable' | 'assisted';
+  read(): unknown;
+}
+
+/**
+ * The game's SYSTEM surface: what its content actually IS, as opposed to how
+ * it renders. An ingested game's content is not always its scene graph — in a
+ * system-driven game the authorable content lives in the game's own model and
+ * is reached through the game's own verbs, which `root`/`lifecycle` could not
+ * express.
+ *
+ * Both members are read by exactly one consumer,
+ * `adapter/ingest/contract-debug-adapter.ts`, which projects them onto the
+ * host's ordinary `DebugAdapter` (`adapter/system-adapter.ts`) — so
+ * `game.commands()`/`game.state()` reach an ingested game through the same
+ * bridge first-party content uses, with no second vocabulary for agents to
+ * learn. That is deliberate scope: this
+ * interface describes what a foreign game's entry shim may declare, so every
+ * member here is a promise the host must already keep. A member nothing reads
+ * would be a shim author implementing a hook that is never called.
+ */
+export interface VgaiGameSystems {
+  /** Verbs, enumerated by `game.commands()` and run by `game.command(...)`. */
+  commands?: VgaiGameCommand[];
+  /** State reads, enumerated by `game.providers()` and read by `game.state(...)`. */
+  state?: VgaiGameStateProvider[];
+}
+
 export interface VgaiGameContract {
   /** Bump only on breaking shape changes; additive endpoints keep version 1. */
   contractVersion: 1;
@@ -45,6 +101,12 @@ export interface VgaiGameContract {
    */
   root?: HTMLElement;
   lifecycle?: VgaiGameLifecycle;
+  /**
+   * The game's own systems. Absent means "this game declared no system
+   * surface" — every dependent editor surface then shows a named absence, not
+   * an empty pretend-palette.
+   */
+  systems?: VgaiGameSystems;
 }
 
 /**

package/src/adapter/setup-three-root-adapter.ts

@@ -33,12 +33,14 @@ import {
 import { createSimClock, getSimClock, type SimClockInternal } from '../core/sim-clock';
 import { createSystemRunner } from '../core/system-runner';
 import { createDebugDraw } from '../dev/debug-draw';
+import { type RenderVitalsRegistration, registerRenderVitals } from '../dev/register-render-vitals';
 import {
   createRenderDebugAdapter,
   frameCaptureContextFor,
   type RenderDebugWiring,
 } from '../dev/render-debug-adapter';
 import { collectRenderMemory } from '../dev/render-memory';
+import { RENDER_SUBMIT_PHASE } from '../dev/render-vitals';
 import { createWebGLFrameCapture } from '../dev/webgl-frame-capture';
 import { createWebGLGpuTimer } from '../dev/webgl-gpu-timer';
 import { createSceneIndex } from '../ecs/scene-index';
@@ -61,6 +63,7 @@ import {
   type DebugRegistry,
   getDebugRegistry,
 } from '../runtime/debug-registry';
+import { devLayersEnabled } from '../runtime/dev-layers';
 import { disposeDebrisSubtree, type RootFrameHooks } from '../runtime/game';
 import type { EditorPreview, GameCleanup, GameContext, GameSetupFn } from '../runtime/types';
 import { type AudioContext as GameAudio, setupAudio } from '../setup/setup-audio';
@@ -237,6 +240,10 @@ export class SetupThreeRootAdapter implements RootAdapter {
       : null;
     const viewportShading = new ViewportShadingRenderer();
     let viewportShadingMode: ViewportShadingMode = 'solid';
+    /** Top-level `renderer.render()` calls the last presentation cost — written
+     *  by the render system, read by `postFrame`. See both for why the count is
+     *  latched rather than differenced at report time. */
+    let lastPresentationPasses = 0;
 
     // --- System runner (engine-level systems) ---
     const systems = createSystemRunner(host.game?.profiler.systemObserver, 'three');
@@ -296,7 +303,8 @@ export class SetupThreeRootAdapter implements RootAdapter {
       systems.add(
         'render',
         (dt) => {
-          if (host.game?.profiler.enabled) gpuTimer?.begin();
+          const profiler = host.game?.profiler;
+          if (profiler?.enabled) gpuTimer?.begin();
           if (sparkRenderer) scene.add(sparkRenderer);
           // W4b: arm-gated frame capture wraps the real draw calls. beginPass
           // is a no-op unless a captureFrame() armed it; afterRender delivers
@@ -304,6 +312,21 @@ export class SetupThreeRootAdapter implements RootAdapter {
           // patched context — in the SAME finally as gpuTimer.end(). Spark is
           // added before this so its draws fall inside the captured frame.
           renderDebugWiring?.beforeRender();
+          // Issue #1504: CPU render submission, bracketed as its OWN profiler
+          // phase nested inside the frame's enclosing `render` phase. This is
+          // the frame's only isolated measurement of "how long did it take to
+          // hand the draws to the driver" — the `render` phase around it also
+          // contains physics-debug redraw and every other world's render work,
+          // and a system span would key the reading to this adapter's system
+          // NAME. The profiler's phase clock is a stack precisely so this
+          // bracket cannot truncate its parent (`dev/performance-profiler.ts`).
+          // It is also what makes a frame a PRESENTATION as far as the vitals
+          // fold is concerned: no draw, no bracket, no display frame.
+          profiler?.beginPhase();
+          // `info.render.frame` counts top-level renderer.render() calls and
+          // survives `info.reset()`, so its delta across the draw is how many
+          // passes the composer chain (plus shadows) actually cost.
+          const passesBefore = renderer.info.render.frame;
           try {
             viewportShading.render(
               scene,
@@ -315,6 +338,8 @@ export class SetupThreeRootAdapter implements RootAdapter {
               (mesh) => camera.layers.test(mesh.layers),
             );
           } finally {
+            profiler?.endPhase(RENDER_SUBMIT_PHASE);
+            lastPresentationPasses = renderer.info.render.frame - passesBefore;
             renderDebugWiring?.afterRender();
             sparkRenderer?.removeFromParent();
             gpuTimer?.end();
@@ -336,13 +361,25 @@ export class SetupThreeRootAdapter implements RootAdapter {
 
     const postFrame = () => {
       if (ownsInput) input.endFrame();
-      if (host.game?.profiler.enabled) {
+      // `renderer.info` is checked, not assumed: a headless/stub renderer
+      // supplies only what the runtime needs to mount, and a mount with no
+      // counters must report NOTHING rather than throw once per frame. This
+      // used to be unreachable because only the editor ever enabled the
+      // profiler; the engine enables it itself under the dev gate now (see the
+      // render-vitals seed below), so the assumption has to be paid for.
+      if (host.game?.profiler.enabled && renderer.info) {
         host.game.profiler.reportRender({
           gpuMs: gpuTimer?.poll() ?? null,
           drawCalls: renderer.info.render.calls,
           triangles: renderer.info.render.triangles,
           geometries: renderer.info.memory.geometries,
           textures: renderer.info.memory.textures,
+          // The LAST presentation's pass count, not a delta taken here: under
+          // the display-rate loop this hook runs once per fixed SUBSTEP, so a
+          // delta measured at this point would read as 0 on every substep that
+          // did not draw. Same one-frame-warm semantics as the renderer.info
+          // counters beside it.
+          renderPasses: lastPresentationPasses,
         });
       }
     };
@@ -538,6 +575,48 @@ export class SetupThreeRootAdapter implements RootAdapter {
       (host.game ? getSeededRandom(host.game) : null) ??
       createSeededRandom(DEFAULT_SEEDED_RANDOM_SEED);
 
+    // --- Live render vitals (issue #1504) -------------------------------------
+    // Engine-owned and first-party, seeded HERE like `renderDebug` above: a
+    // running game must be able to explain its own frame cost through the debug
+    // registry, with no capability to install and nothing for a game to write.
+    //
+    // THE GATE, in one place. Three conditions, and the reason for each:
+    //  1. `devLayersEnabled()` — the ONE owner of "is this a dev/editor
+    //     context" (`runtime/dev-layers.ts`). A ship build registers nothing,
+    //     subscribes to nothing, and never enables the profiler.
+    //  2. a `Game` shell exists — the readings are folded out of that game's
+    //     profiler frames, and a bare mount has no profiler to fold.
+    //  3. not headless — a headless mount registers no render system at all,
+    //     so it never brackets a submission and never presents a frame. Its
+    //     vitals could only ever read empty, and registering a door that is
+    //     structurally incapable of answering is worse than not having one.
+    //
+    // The enabled-gating question, resolved: the profiler is AUTO-ENABLED here
+    // rather than given a second, cheaper always-on counter tier. A counter
+    // tier would be a parallel measurement path — exactly the side ledger this
+    // work exists to avoid — and the profiler already has the one property
+    // that made the choice: `enabled` is a plain flag whose cost is per-frame
+    // bookkeeping the editor ALREADY pays (it sets `profiler.enabled = true`
+    // on play, `CenterDocuments.tsx`), so under the dev gate this is not a new
+    // cost, it is the same cost arriving a little earlier. Nothing here ever
+    // turns it OFF: the profiler's other owners (the Performance panel,
+    // `render-control.ts`'s perfSample) save and restore the prior state, so a
+    // dev session that enabled it at mount keeps it enabled.
+    let renderVitals: RenderVitalsRegistration | null = null;
+    const seedRenderVitals = (): void => {
+      if (!host.game || headless || !devLayersEnabled()) return;
+      renderVitals?.dispose();
+      host.game.profiler.enabled = true;
+      renderVitals = registerRenderVitals({
+        registry: debugRegistry,
+        worldId: this.id,
+        profiler: host.game.profiler,
+        scene,
+        renderer,
+      });
+    };
+    seedRenderVitals();
+
     // Snapshot of the engine-owned adapter kinds, taken right after seeding
     // and before any setup() has had a chance to run. `hotReload`/`disposeGame`
     // use this to strip every GAME-registered kind (including an override of a
@@ -740,6 +819,13 @@ export class SetupThreeRootAdapter implements RootAdapter {
       safeStep('debugRegistry.strip', () =>
         host.game ? debugRegistry.strip(this.id) : debugRegistry.strip(),
       );
+      // The strip above removes the vitals REGISTRATIONS (their provenance is
+      // this world). This ends the fold's profiler subscription — the one
+      // resource `registerRenderVitals` allocates that a strip cannot reach.
+      safeStep('renderVitals.dispose', () => {
+        renderVitals?.dispose();
+        renderVitals = null;
+      });
 
       // Release analyser taps BEFORE the audio teardown below. A consumer
       // (the editor's meter poll) should dispose its own handle, but Stop must
@@ -855,6 +941,12 @@ export class SetupThreeRootAdapter implements RootAdapter {
       // every react-door registration (whose `useEffect` cleanup never
       // re-fires to restore them after someone else's strip).
       safeStep('debugRegistry.strip', () => debugRegistry.strip(this.id));
+      // The strip above takes the ENGINE's own vitals registrations with it
+      // (they carry this world's provenance, which is what makes the game's
+      // own re-seed silent). Re-seed them before the incoming setup runs, so a
+      // warm restart does not silently cost a game its render vitals — and so
+      // the fold starts clean rather than carrying the outgoing game's frames.
+      safeStep('renderVitals re-seed', seedRenderVitals);
 
       currentCleanup = await newSetup(ctx, newEditorPreview);
     };

package/src/core/game-scoped-slot.ts

@@ -0,0 +1,28 @@
+/**
+ * A non-enumerable slot carried by the game object itself.
+ *
+ * Packaged editor play can legitimately involve two copies of `@vgai/engine`:
+ * the editor bundle creates the Game, while the project's Vite graph creates
+ * its root adapter. Module-local WeakMaps cannot cross that boundary. A
+ * registry-backed symbol can, while keeping the internal value off the public
+ * string-keyed Game surface.
+ */
+export function createGameScopedSlot<T>(name: string): {
+  set(owner: object, value: T): void;
+  get(owner: object): T | null;
+} {
+  const key = Symbol.for(`@vgai/engine/game-scoped/${name}`);
+
+  return {
+    set(owner, value) {
+      Object.defineProperty(owner, key, {
+        configurable: true,
+        enumerable: false,
+        value,
+      });
+    },
+    get(owner) {
+      return (owner as { [key: symbol]: T | undefined })[key] ?? null;
+    },
+  };
+}

package/src/core/seeded-random.ts

@@ -27,6 +27,7 @@
  */
 
 import { createMulberry32 } from '../runtime/render-seed';
+import { createGameScopedSlot } from './game-scoped-slot';
 
 /** The name `ctx.random()` (called with no `.stream(...)`) draws from. */
 export const GAMEPLAY_STREAM = 'gameplay';
@@ -135,7 +136,7 @@ export function createSeededRandom(initialSeed: number): SeededRandom {
 
 // ---------------------------------------------------------------------------
 // Game-scoped registry — mirrors `runtime/debug-registry.ts`'s
-// `registerDebugRegistry`/`getDebugRegistry` WeakMap pattern exactly, but
+// `registerDebugRegistry`/`getDebugRegistry` game-slot pattern exactly, but
 // keyed on a bare `object` (not `Game`) so this module never needs to import
 // `runtime/game.ts` even as a type — `core/` stays independent of `runtime/`
 // except for the one explicit, documented `render-seed.ts` reuse above.
@@ -144,7 +145,7 @@ export function createSeededRandom(initialSeed: number): SeededRandom {
 // `registerDebugRegistry(gameInternal, debugRegistry)`.
 // ---------------------------------------------------------------------------
 
-const registryByOwner = new WeakMap<object, SeededRandom>();
+const registryByOwner = createGameScopedSlot<SeededRandom>('seeded-random');
 
 /** Called once by `createGame`, right after both the seeded-random surface
  *  and the Game shell object exist — mirrors `registerDebugRegistry`. */

package/src/core/sim-clock.ts

@@ -114,6 +114,7 @@
  */
 
 import type * as THREE from 'three';
+import { createGameScopedSlot } from './game-scoped-slot';
 
 /** Cancel handle returned by {@link SimClock.after}/{@link SimClock.disposeAfter}. */
 export interface SimTimerHandle {
@@ -362,12 +363,12 @@ export function createSimClock(options: SimClockOptions): SimClockInternal {
 
 // ---------------------------------------------------------------------------
 // Game-scoped registry — mirrors `core/seeded-random.ts`'s
-// `registerSeededRandom`/`getSeededRandom` WeakMap pattern exactly, keyed on a
+// `registerSeededRandom`/`getSeededRandom` slot pattern exactly, keyed on a
 // bare `object` (not `Game`) so `core/` never imports `runtime/`. `createGame`
 // is the one real registrant, passing the `GameInternal` shell as the key.
 // ---------------------------------------------------------------------------
 
-const clockByOwner = new WeakMap<object, SimClockInternal>();
+const clockByOwner = createGameScopedSlot<SimClockInternal>('sim-clock');
 
 /** Called once by `createGame`, right after the clock and the Game shell exist. */
 export function registerSimClock(owner: object, clock: SimClockInternal): void {