@vgai/engine 0.5.15 → 0.5.16

package/dist/adapter/ingest/observation-debug-adapter.js

@@ -0,0 +1,131 @@
+/**
+ * Projects an ADAPTER's declared observation slots
+ * (`AdapterDefinition.observation`, `adapter/adapter-module.ts`) onto the host's
+ * existing {@link DebugAdapter} — the one seam `game.providers()` /
+ * `game.state()` / `game.commands()` already read through
+ * (`command-listener.ts`'s `dispatchBridgeMethod` → `getActiveSystems().debug`).
+ *
+ * This is the SIBLING of `contract-debug-adapter.ts` and deliberately the same
+ * shape: a projection rather than a second door. The two differ only in WHO
+ * declared the surface — the game itself, on `window.vgaiGame.systems`, or the
+ * game's adapter module beside it — and a consumer downstream must not be able
+ * to tell them apart. `merge-debug-adapters.ts` is what folds both onto the one
+ * slot.
+ *
+ * ## What `game` is
+ *
+ * The host's to hand over, and for an INGEST mount it is the REALM the game's
+ * own modules ran in. That is not a convenience: an ingest mount runs the game
+ * in the editor's own realm (`game-contract.ts`'s `readGameContract` says so —
+ * "the realm every ingest mount runs the game's modules in, where the game and
+ * the host share one global"), a vendored bundle's adapter is HOST-realm by the
+ * placement rule, and the only handles such a game publishes are the ones on
+ * that realm — its runtime's own public registry, or a host-build seam beside
+ * it. Handing the realm is therefore handing the game everything it actually
+ * exposes; handing anything narrower would make the adapter reach for `window`
+ * itself, which is the same read with the provenance hidden.
+ *
+ * ## The two-state rule, kept
+ *
+ * Declaring a slot and answering it are separate facts. A declaration with NO
+ * `answer` is still listed and refuses BY NAME when read — never omitted,
+ * because omitting it would report "the game has no such state" when the truth
+ * is "the table declared it and nothing binds it yet". Same for a throwing
+ * `answer`: it propagates (exactly as a first-party provider's does), and only
+ * `stateAll()` isolates it per key.
+ *
+ * ## What this deliberately does NOT do
+ *
+ * - **Validate arguments.** A declared command's `answer` receives the invoked
+ *   argument list after the game handle; there is no Zod tuple beside a foreign
+ *   game, so a verb validates itself and throws its own error, surfaced wrapped
+ *   as `DEBUG_COMMAND_FAILED`. Identical to the contract projection's stance.
+ * - **Fabricate an event ring.** Nothing emits behind a declaration, so
+ *   `events()` is empty — accurate, not a stub.
+ */
+import { DebugError } from '../../runtime/debug-registry';
+/**
+ * An adapter-declared read is DERIVED by the host-side table from the game's own
+ * handles — which is precisely what `assisted` means in the tier vocabulary
+ * (`game-contract.ts`: "`observable` is a value the game already computes,
+ * `assisted` is one the shim derives"). Reporting `observable` would claim the
+ * game itself publishes the value.
+ */
+const DECLARED_TIER = 'assisted';
+function unanswered(id, kind) {
+    return new DebugError('OBSERVATION_UNANSWERED', `Observation "${id}" (${kind}) is declared by this game's adapter with no \`answer\` — ` +
+        'the slot exists and nothing binds it yet, which is not the same as the game having none.', { id, kind });
+}
+/**
+ * Build a {@link DebugAdapter} over an adapter's observation declarations, or
+ * `null` when it declares none. `null` is the honest floor — the same one
+ * `createContractDebugAdapter` returns — so a game that declared nothing keeps
+ * reporting `DEBUG_ADAPTER_UNAVAILABLE` rather than serving an empty adapter
+ * that reads as "this game has no state".
+ */
+export function createObservationDebugAdapter(declarations, game) {
+    const all = declarations ?? [];
+    if (all.length === 0)
+        return null;
+    // Snapshot into id-keyed maps once, exactly as the contract projection does:
+    // a later duplicate shadows an earlier one and the listing de-duplicates with
+    // it, so a listed id can never resolve differently than it reads.
+    const byProvider = new Map(all.filter((d) => d.kind === 'state').map((d) => [d.id, d]));
+    const byCommand = new Map(all.filter((d) => d.kind === 'command').map((d) => [d.id, d]));
+    return {
+        providers: () => [...byProvider.keys()].map((name) => ({ name, tier: DECLARED_TIER })),
+        state: (name) => {
+            const declaration = byProvider.get(name);
+            if (!declaration) {
+                throw new DebugError('STATE_PROVIDER_NOT_FOUND', `No state provider named "${name}" is declared by this game's adapter.`, { registered: [...byProvider.keys()] });
+            }
+            if (!declaration.answer)
+                throw unanswered(name, 'state');
+            return declaration.answer(game);
+        },
+        stateAll: () => {
+            const out = {};
+            for (const [name, declaration] of byProvider) {
+                // One throwing declaration must not cost the caller every other
+                // reading — the same per-key isolation the first-party registry gives.
+                try {
+                    out[name] = declaration.answer
+                        ? declaration.answer(game)
+                        : (() => {
+                            throw unanswered(name, 'state');
+                        })();
+                }
+                catch (err) {
+                    out[name] = { __error: String(err) };
+                }
+            }
+            return out;
+        },
+        commands: () => [...byCommand.keys()].map((name) => ({
+            name,
+            // 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: byCommand.get(name)?.locus ?? 'client',
+        })),
+        invoke: async (name, args) => {
+            const declaration = byCommand.get(name);
+            if (!declaration) {
+                throw new DebugError('DEBUG_COMMAND_NOT_REGISTERED', `No command named "${name}" is declared by this game's adapter.`, { registered: [...byCommand.keys()] });
+            }
+            if (!declaration.answer)
+                throw unanswered(name, 'command');
+            try {
+                // The game handle first, then the invoked argument list — a declared
+                // verb is a function OF the mounted game, which is the whole reason
+                // `answer` takes one.
+                return await declaration.answer(game, ...args);
+            }
+            catch (err) {
+                throw new DebugError('DEBUG_COMMAND_FAILED', `Command "${name}" threw: ${String(err)}`, {
+                    name,
+                });
+            }
+        },
+        events: () => [],
+    };
+}

package/dist/adapter/ingest/scene-capture.d.ts

@@ -1,11 +1,11 @@
 /**
  * Scene capture — the core primitive of unmodified-game ingestion.
  *
- * An external three.js game owns its own `WebGLRenderer`, `Scene`, camera, and
- * render loop. To let the editor inspect/edit that live scene WITHOUT touching
- * the game's code, we need a handle to the game's `Scene`+camera the moment it
- * first renders. The robust way to obtain it is an **accessor trap** on
- * `WebGLRenderer.prototype.render`:
+ * An external three.js game owns its own renderer, `Scene`, camera, and render
+ * loop. To let the editor inspect/edit that live scene WITHOUT touching the
+ * game's code, we need a handle to the game's `Scene`+camera the moment it
+ * first renders. For WebGL, the robust way to obtain it is an **accessor trap**
+ * on `WebGLRenderer.prototype.render`:
  *
  *   - `WebGLRenderer` assigns `this.render` as an OWN instance property inside
  *     its constructor (not on the prototype), and `THREE.WebGLRenderer` is a
@@ -20,12 +20,16 @@
  * (`docs/ingest-study-spike/vgai-ingest-adapter.js`), proven against an
  * unmodified `three.js/examples/games_fps` game.
  *
- * CRITICAL: the trap must be installed on the SAME `three` module instance the
- * game uses. In a bundler/dev-server that dedupes `three` (one `node_modules/
- * three`), an external ESM game's `import 'three'` resolves to that one instance,
- * so passing the host's `THREE` here traps the game's renderer too. A game that
- * bundles its own copy of `three` cannot be captured this way (the module-identity
- * gatekeeper).
+ * DOM-backed addon renderers use ordinary prototype methods instead. The host
+ * supplies those exact shared classes through `additionalRendererCtors`, and
+ * the same observer captures their `(scene, camera)` pair without inventing a
+ * second world model. CSS3DRenderer is the first implementer.
+ *
+ * CRITICAL: every trap must be installed on the SAME `three` module/addon
+ * instance the game uses. In a bundler/dev-server that dedupes `three` (one
+ * `node_modules/three`), an external ESM game's imports resolve to those shared
+ * classes. A game that bundles its own copy cannot be captured this way (the
+ * module-identity gatekeeper).
  *
  * Wave 17 adds an OPTIONAL, ADDITIVE composer capture: a game rendering through
  * its own three.js addon `EffectComposer`
@@ -50,14 +54,35 @@
  */
 import type * as THREE from 'three';
 import { type VisibilityClock, type VisibleCaptureWindow } from './visible-capture-window';
+/** The renderer operations the ingest host may lawfully use after capture.
+ * WebGLRenderer supplies every member; DOM-backed Three addon renderers such as
+ * CSS3DRenderer deliberately omit the WebGL-only lifecycle operations. */
+export interface CapturedThreeRenderer {
+    readonly domElement: HTMLElement;
+    readonly info?: THREE.WebGLInfo | undefined;
+    render(scene: THREE.Scene, camera: THREE.Camera): unknown;
+    setSize(width: number, height: number, updateStyle?: boolean): void;
+    setAnimationLoop?(callback: ((time: number) => void) | null): void;
+    dispose?(): void;
+    getPixelRatio?(): number;
+    getContext?(): unknown;
+    getRenderTarget?(): unknown;
+}
 /** A live runtime captured from an external game on its first rendered frame. */
 export interface CapturedRuntime {
     scene: THREE.Scene;
     camera: THREE.Camera;
-    renderer: THREE.WebGLRenderer;
+    renderer: CapturedThreeRenderer;
 }
 /** Options for {@link installSceneCapture}. */
 export interface SceneCaptureOptions {
+    /**
+     * Additional shared Three addon renderer classes whose prototype `render`
+     * method carries the same `(scene, camera)` pair as WebGLRenderer. CSS3DRenderer
+     * is the first implementer. The caller must pass the exact class its game
+     * imports; a bundled private copy remains deliberately uncapturable.
+     */
+    additionalRendererCtors?: readonly unknown[];
     /**
      * True when `renderer` is one the HOST constructed for its own drawing.
      *
@@ -206,7 +231,7 @@ export interface SceneCaptureHandle {
     getDrawCount(): number;
     /** The game's last (non-null) `setAnimationLoop` callback for a renderer, so the
      *  host can pause (set null) and resume (re-set it) the game's own loop. */
-    getAnimationLoop(renderer: THREE.WebGLRenderer): ((time: number) => void) | null;
+    getAnimationLoop(renderer: CapturedThreeRenderer): ((time: number) => void) | null;
     /**
      * Wave 17 (D-C3): resize every captured `EffectComposer` that renders
      * through the captured renderer to `w`×`h`, matching its pixel ratio to

package/dist/adapter/ingest/scene-capture.d.ts.map

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

package/dist/adapter/ingest/scene-capture.js

@@ -1,11 +1,11 @@
 /**
  * Scene capture — the core primitive of unmodified-game ingestion.
  *
- * An external three.js game owns its own `WebGLRenderer`, `Scene`, camera, and
- * render loop. To let the editor inspect/edit that live scene WITHOUT touching
- * the game's code, we need a handle to the game's `Scene`+camera the moment it
- * first renders. The robust way to obtain it is an **accessor trap** on
- * `WebGLRenderer.prototype.render`:
+ * An external three.js game owns its own renderer, `Scene`, camera, and render
+ * loop. To let the editor inspect/edit that live scene WITHOUT touching the
+ * game's code, we need a handle to the game's `Scene`+camera the moment it
+ * first renders. For WebGL, the robust way to obtain it is an **accessor trap**
+ * on `WebGLRenderer.prototype.render`:
  *
  *   - `WebGLRenderer` assigns `this.render` as an OWN instance property inside
  *     its constructor (not on the prototype), and `THREE.WebGLRenderer` is a
@@ -20,12 +20,16 @@
  * (`docs/ingest-study-spike/vgai-ingest-adapter.js`), proven against an
  * unmodified `three.js/examples/games_fps` game.
  *
- * CRITICAL: the trap must be installed on the SAME `three` module instance the
- * game uses. In a bundler/dev-server that dedupes `three` (one `node_modules/
- * three`), an external ESM game's `import 'three'` resolves to that one instance,
- * so passing the host's `THREE` here traps the game's renderer too. A game that
- * bundles its own copy of `three` cannot be captured this way (the module-identity
- * gatekeeper).
+ * DOM-backed addon renderers use ordinary prototype methods instead. The host
+ * supplies those exact shared classes through `additionalRendererCtors`, and
+ * the same observer captures their `(scene, camera)` pair without inventing a
+ * second world model. CSS3DRenderer is the first implementer.
+ *
+ * CRITICAL: every trap must be installed on the SAME `three` module/addon
+ * instance the game uses. In a bundler/dev-server that dedupes `three` (one
+ * `node_modules/three`), an external ESM game's imports resolve to those shared
+ * classes. A game that bundles its own copy cannot be captured this way (the
+ * module-identity gatekeeper).
  *
  * Wave 17 adds an OPTIONAL, ADDITIVE composer capture: a game rendering through
  * its own three.js addon `EffectComposer`
@@ -48,7 +52,7 @@
  * against the `bloom-composer` fixture
  * (`docs/f13-bloom-composer-proof/record-fixed.mjs`).
  */
-import { startVisibleCaptureWindow, } from './visible-capture-window';
+import { documentVisibilityClock, startVisibleCaptureWindow, } from './visible-capture-window';
 /**
  * How many distinct alternates are recorded before the trap stops looking.
  *
@@ -112,7 +116,27 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
     // the GETTER returns a wrapper that records each non-null callback before forwarding.
     const REAL_SAL = Symbol('vgai.realSetAnimationLoop');
     const loopCallbacks = new WeakMap();
+    const loopedRenderers = new Set();
+    /** Visibility clock of the in-flight `waitForCapture`, if any. */
+    let waitingVisibility = null;
     const priorSAL = Object.getOwnPropertyDescriptor(proto, 'setAnimationLoop');
+    function pumpHiddenLoops() {
+        if (captured ||
+            !waitingVisibility ||
+            !(waitingVisibility.suspended?.() ?? waitingVisibility.hidden())) {
+            return;
+        }
+        for (const renderer of loopedRenderers) {
+            try {
+                loopCallbacks.get(renderer)?.(0);
+            }
+            catch {
+                /* a throwing game frame must not kill the waiter */
+            }
+            if (captured)
+                return;
+        }
+    }
     Object.defineProperty(proto, 'setAnimationLoop', {
         configurable: true,
         set(fn) {
@@ -121,8 +145,14 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
         get() {
             const self = this;
             return function setAnimationLoop(cb) {
-                if (cb)
+                if (cb) {
                     loopCallbacks.set(self, cb);
+                    loopedRenderers.add(self);
+                    // Hidden tabs park rAF. Play/eval still need a first frame, so when
+                    // a waiter is parked we drive the game's own loop once — the same
+                    // class of tick `waitSimTime` already uses for a hidden document.
+                    queueMicrotask(pumpHiddenLoops);
+                }
                 const real = self[REAL_SAL];
                 return typeof real === 'function'
                     ? real.call(self, cb)
@@ -203,6 +233,21 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
             drawCount,
         });
     }
+    /** Observe the common `(scene, camera)` render contract once, regardless of
+     * whether it came from WebGLRenderer's constructor-assigned method or an
+     * addon's ordinary prototype method. */
+    function observeRendererRender(self, scene, camera) {
+        if (!captured || self === captured.renderer)
+            drawCount++;
+        if (opts?.isHostRenderer?.(self) === true)
+            return;
+        if (!scene?.isScene)
+            return;
+        if (captured)
+            recordAlternateWorld(self, scene, camera);
+        else
+            adoptWorld(self, scene, camera);
+    }
     Object.defineProperty(proto, 'render', {
         configurable: true,
         set(fn) {
@@ -221,8 +266,6 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
                 // `setAnimationLoop`, so they ARE gateable) and the instrument was
                 // reporting someone else's frames. Before capture every render still
                 // counts: that is how the first game frame is detected at all.
-                if (!captured || self === captured.renderer)
-                    drawCount++;
                 // Never capture a scene the HOST owns. The trap sits on the shared
                 // `WebGLRenderer.prototype`, so the editor's own viewport renders
                 // arrive here too — and when a game bundles its own MISMATCHED three,
@@ -233,16 +276,39 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
                 // Whether that happened at all came down to whether the editor
                 // rendered a frame inside the game's capture window, so the same
                 // session could pass or fail on timing alone.
-                if (opts?.isHostRenderer?.(self) !== true && scene?.isScene) {
-                    if (captured)
-                        recordAlternateWorld(self, scene, camera);
-                    else
-                        adoptWorld(self, scene, camera);
-                }
+                observeRendererRender(self, scene, camera);
                 return forwardRender(self, args);
             };
         },
     });
+    // DOM-backed Three renderers (CSS3DRenderer is the first) use a normal
+    // prototype method rather than WebGLRenderer's constructor assignment. Trap
+    // only classes explicitly supplied by the host, and restore each byte-for-byte.
+    const additionalRendererRestores = [];
+    for (const candidate of opts?.additionalRendererCtors ?? []) {
+        const ctor = candidate;
+        const rendererProto = ctor?.prototype;
+        const priorRender = rendererProto?.render;
+        if (!rendererProto || typeof priorRender !== 'function' || rendererProto === proto)
+            continue;
+        rendererProto.render = function (...args) {
+            observeRendererRender(this, args[0], args[1]);
+            const hooks = renderPassHooks;
+            if (hooks === null || !captured || this !== captured.renderer) {
+                return priorRender.apply(this, args);
+            }
+            hooks.before();
+            try {
+                return priorRender.apply(this, args);
+            }
+            finally {
+                hooks.after();
+            }
+        };
+        additionalRendererRestores.push(() => {
+            rendererProto.render = priorRender;
+        });
+    }
     // ---- Wave 17 (D-C2): additive composer capture, only when a composer ctor
     // was passed. `EffectComposer` methods (including `render`) live on the
     // PROTOTYPE (a plain ES class — the constructor never does `this.render =
@@ -296,7 +362,9 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
             // renderer need not even expose that method for this to stay a no-op.
             if (!captured || composers.size === 0)
                 return;
-            const pixelRatio = captured.renderer.getPixelRatio();
+            const pixelRatio = captured.renderer.getPixelRatio?.();
+            if (pixelRatio === undefined)
+                return;
             for (const composer of composers) {
                 composer.setSize(w, h);
                 composer.setPixelRatio(pixelRatio);
@@ -320,20 +388,27 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
                         const i = waiters.indexOf(wrapped);
                         if (i >= 0)
                             waiters.splice(i, 1);
+                        waitingVisibility = null;
                         opts.onWait?.(null);
                         reject(new Error(`Scene capture timed out after ${timeoutMs}ms of VISIBLE time ` +
-                            `(${Math.round(captureWindow.elapsedHiddenMs())}ms hidden, which is not counted — ` +
-                            'a hidden tab cannot render) — the game never rendered, ' +
+                            `(${Math.round(captureWindow.elapsedHiddenMs())}ms browser-suspended, which is ` +
+                            'not counted because no frame can be presented) — the game never rendered, ' +
                             'or it bundles its own (un-shared) copy of three.'));
                     },
                 });
                 const wrapped = (rt) => {
                     captureWindow.cancel();
+                    waitingVisibility = null;
                     opts.onWait?.(null);
                     resolve(rt);
                 };
                 waiters.push(wrapped);
+                waitingVisibility = opts.visibility ?? documentVisibilityClock();
                 opts.onWait?.(captureWindow);
+                // A waiter that starts already-hidden (the normal `vgai play` path
+                // against a backgrounded tab) must not wait for a human to foreground
+                // it. Pump any loop the game has already registered.
+                queueMicrotask(pumpHiddenLoops);
             });
         },
         uninstall() {
@@ -379,6 +454,8 @@ export function installSceneCapture(threeNamespace, effectComposerCtor, opts) {
             // prototype method — no per-instance own-property to restore, unlike
             // the renderer/loop traps above).
             restoreComposerTrap();
+            for (const restore of additionalRendererRestores)
+                restore();
         },
     };
 }

package/dist/adapter/ingest/visible-capture-window.d.ts

@@ -45,6 +45,16 @@ export interface VisibilityClock {
     now(): number;
     /** True while the document is hidden (no rAF, so no frame can be captured). */
     hidden(): boolean;
+    /**
+     * True while the browser is not presenting frames. This is wider than
+     * `hidden()`: WebKit also stops rAF for an unfocused window (and can suspend
+     * the page entirely) while `document.hidden` still reads false.
+     *
+     * Optional for compatibility with injected clocks; absent means `hidden()`.
+     */
+    suspended?(): boolean;
+    /** Why {@link suspended} is true, when the clock can say. */
+    suspensionReason?(): 'hidden' | 'unfocused' | 'page-suspended' | null;
     /** Subscribe to visibility transitions; returns the unsubscribe. */
     subscribe(onChange: () => void): () => void;
 }
@@ -91,18 +101,25 @@ export interface VisibleCaptureWindow {
     readonly budgetMs: number;
     /** Visible milliseconds spent so far. */
     elapsedVisibleMs(): number;
-    /** Milliseconds this window has spent parked while hidden (not counted). */
+    /** Milliseconds this window has spent browser-suspended (not counted). */
     elapsedHiddenMs(): number;
-    /** Whether the wait is parked right now because the document is hidden. */
+    /**
+     * Whether the document itself is hidden. Kept distinct from browser
+     * suspension so status never calls an unfocused, still-visible window hidden.
+     */
     isHidden(): boolean;
+    /** Whether the expiry budget is parked because the browser is not presenting frames. */
+    isSuspended(): boolean;
+    /** The browser condition parking the budget, when observable. */
+    suspensionReason(): 'hidden' | 'unfocused' | 'page-suspended' | null;
     /** Stop the timer and drop the visibility listener. Idempotent. */
     cancel(): void;
 }
 /**
  * Start a window that calls `onExpire` after `budgetMs` of VISIBLE time.
- * While the document is hidden the timer is disarmed entirely (so a throttled
- * background timer cannot fire it late either) and re-armed with the remaining
- * budget when the document comes back.
+ * While browser frame presentation is suspended the timer is disarmed entirely
+ * (so a throttled background timer cannot fire it late either) and re-armed
+ * with the remaining budget when frame presentation resumes.
  */
 export declare function startVisibleCaptureWindow(opts: {
     budgetMs: number;

package/dist/adapter/ingest/visible-capture-window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visible-capture-window.d.ts","sourceRoot":"","sources":["../../../src/adapter/ingest/visible-capture-window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,GAAG,IAAI,MAAM,CAAC;IACd,+EAA+E;IAC/E,MAAM,IAAI,OAAO,CAAC;IAClB,oEAAoE;IACpE,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;yEAEyE;AACzE,wBAAgB,uBAAuB,IAAI,eAAe,CAWzD;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,GACd,kBAAkB,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,GACd,kBAAkB,CAUpB;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED;2EAC2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED,sFAAsF;AACtF,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yCAAyC;IACzC,gBAAgB,IAAI,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,eAAe,IAAI,MAAM,CAAC;IAC1B,2EAA2E;IAC3E,QAAQ,IAAI,OAAO,CAAC;IACpB,mEAAmE;IACnE,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,iDAAiD;IACjD,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC,GAAG,oBAAoB,CAmDvB"}
+{"version":3,"file":"visible-capture-window.d.ts","sourceRoot":"","sources":["../../../src/adapter/ingest/visible-capture-window.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,GAAG,IAAI,MAAM,CAAC;IACd,+EAA+E;IAC/E,MAAM,IAAI,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,OAAO,CAAC;IACtB,6DAA6D;IAC7D,gBAAgB,CAAC,IAAI,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAAC;IACtE,oEAAoE;IACpE,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C;AAED;;yEAEyE;AACzE,wBAAgB,uBAAuB,IAAI,eAAe,CA4CzD;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,GACd,kBAAkB,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,GACd,kBAAkB,CAUpB;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED;2EAC2E;AAC3E,wBAAgB,eAAe,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED,sFAAsF;AACtF,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yCAAyC;IACzC,gBAAgB,IAAI,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,eAAe,IAAI,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,IAAI,OAAO,CAAC;IACpB,wFAAwF;IACxF,WAAW,IAAI,OAAO,CAAC;IACvB,iEAAiE;IACjE,gBAAgB,IAAI,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAAC;IACrE,mEAAmE;IACnE,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,iDAAiD;IACjD,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IACnD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC,GAAG,oBAAoB,CAuDvB"}

package/dist/adapter/ingest/visible-capture-window.js

@@ -39,14 +39,50 @@
  *  honest answer for a headless caller — it has no tab to background. */
 export function documentVisibilityClock() {
     const doc = typeof document === 'undefined' ? null : document;
+    const win = doc?.defaultView ?? null;
+    let pageSuspended = false;
+    const reason = () => {
+        if (pageSuspended)
+            return 'page-suspended';
+        if (doc?.hidden === true)
+            return 'hidden';
+        // WebKit stops rAF when the browser window becomes inactive, including
+        // when another app is in front. Page Visibility can still say `visible`
+        // in that state. Focus is a platform fact, not a Safari/UA sniff, and in
+        // browsers that keep rendering while unfocused this merely parks the
+        // expiry clock until either a frame arrives or focus returns.
+        if (doc && typeof doc.hasFocus === 'function' && !doc.hasFocus())
+            return 'unfocused';
+        return null;
+    };
     return {
         now: () => (typeof performance === 'undefined' ? Date.now() : performance.now()),
         hidden: () => doc?.hidden === true,
+        suspended: () => reason() !== null,
+        suspensionReason: reason,
         subscribe(onChange) {
             if (!doc)
                 return () => { };
+            const onPageHide = () => {
+                pageSuspended = true;
+                onChange();
+            };
+            const onPageShow = () => {
+                pageSuspended = false;
+                onChange();
+            };
             doc.addEventListener('visibilitychange', onChange);
-            return () => doc.removeEventListener('visibilitychange', onChange);
+            win?.addEventListener('blur', onChange);
+            win?.addEventListener('focus', onChange);
+            win?.addEventListener('pagehide', onPageHide);
+            win?.addEventListener('pageshow', onPageShow);
+            return () => {
+                doc.removeEventListener('visibilitychange', onChange);
+                win?.removeEventListener('blur', onChange);
+                win?.removeEventListener('focus', onChange);
+                win?.removeEventListener('pagehide', onPageHide);
+                win?.removeEventListener('pageshow', onPageShow);
+            };
         },
     };
 }
@@ -88,15 +124,16 @@ export function visibleRemainingMs(state, now) {
 }
 /**
  * Start a window that calls `onExpire` after `budgetMs` of VISIBLE time.
- * While the document is hidden the timer is disarmed entirely (so a throttled
- * background timer cannot fire it late either) and re-armed with the remaining
- * budget when the document comes back.
+ * While browser frame presentation is suspended the timer is disarmed entirely
+ * (so a throttled background timer cannot fire it late either) and re-armed
+ * with the remaining budget when frame presentation resumes.
  */
 export function startVisibleCaptureWindow(opts) {
     const clock = opts.clock ?? documentVisibilityClock();
     const setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
     const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
-    let state = beginVisibleBudget(opts.budgetMs, clock.now(), clock.hidden());
+    const suspended = () => clock.suspended?.() ?? clock.hidden();
+    let state = beginVisibleBudget(opts.budgetMs, clock.now(), suspended());
     let timer = null;
     let done = false;
     function disarm() {
@@ -121,7 +158,7 @@ export function startVisibleCaptureWindow(opts) {
     const unsubscribe = clock.subscribe(() => {
         if (done)
             return;
-        state = applyVisibility(state, clock.now(), clock.hidden());
+        state = applyVisibility(state, clock.now(), suspended());
         arm();
     });
     arm();
@@ -129,7 +166,9 @@ export function startVisibleCaptureWindow(opts) {
         budgetMs: opts.budgetMs,
         elapsedVisibleMs: () => visibleElapsedMs(state, clock.now()),
         elapsedHiddenMs: () => hiddenElapsedMs(state, clock.now()),
-        isHidden: () => state.hidden,
+        isHidden: () => clock.hidden(),
+        isSuspended: () => state.hidden,
+        suspensionReason: () => state.hidden ? (clock.suspensionReason?.() ?? (clock.hidden() ? 'hidden' : null)) : null,
         cancel() {
             if (done)
                 return;

package/dist/adapter/native-debug-module.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The ordinary module surface a native game may expose to its own debugger.
+ *
+ * A root entry re-exports one `debug` object from the project's command module:
+ *
+ *   export { debug } from './commands';
+ *
+ * The command module imports no vgai API. Its functions are the application's
+ * own functions over its own stores; the native adapter merely projects that
+ * existing registry onto the session debug/input doors after the root mounts.
+ * Loading through the root entry is load-bearing: the functions close over the
+ * exact module graph the mounted application uses, never a separately evaluated
+ * copy of its stores.
+ */
+import type { Game } from '../runtime/game';
+export declare const NATIVE_INPUT_VALUE_TYPES: readonly ["digital", "scalar", "vector2", "pointerDelta", "pointerPosition"];
+export type NativeInputValueType = (typeof NATIVE_INPUT_VALUE_TYPES)[number];
+export type NativeInputValue = boolean | number | {
+    readonly x: number;
+    readonly y: number;
+};
+export interface NativeDebugModule {
+    readonly commands?: Readonly<Record<string, (...args: unknown[]) => unknown>>;
+    readonly state?: Readonly<Record<string, () => unknown>>;
+    readonly input?: {
+        readonly actions: Readonly<Record<string, NativeInputValueType>>;
+        readonly set: (action: string, value: NativeInputValue) => void;
+        readonly clear: () => void;
+        /** Optional native-scheduler operation. The adapter never synthesizes one. */
+        readonly tap?: (action: string) => void;
+        /** Optional native-scheduler operation. The adapter never adds a host phase. */
+        readonly scheduleAtTick?: (tick: number, action: string, value: NativeInputValue) => void;
+    };
+}
+export interface NativeDebugBinding {
+    readonly rootId: string;
+    readonly debug: NativeDebugModule;
+}
+/** Read the single native `debug` export from an already-loaded root module. */
+export declare function nativeDebugBindingFromEntryModule(rootId: string, entryModule: unknown): NativeDebugBinding | null;
+/** Project native registries onto the existing session debugger after mount. */
+export declare function installNativeDebugBindings(game: Game, bindings: readonly NativeDebugBinding[]): void;
+//# sourceMappingURL=native-debug-module.d.ts.map

package/dist/adapter/native-debug-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-debug-module.d.ts","sourceRoot":"","sources":["../../src/adapter/native-debug-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,eAAO,MAAM,wBAAwB,8EAM3B,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,CAAC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE;QACf,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;QACjE,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;QAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;QAC3B,8EAA8E;QAC9E,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;QACxC,gFAAgF;QAChF,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;KAC3F,CAAC;CACH;AAID,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AA0ED,gFAAgF;AAChF,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,OAAO,GACnB,kBAAkB,GAAG,IAAI,CAwB3B;AAkID,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,SAAS,kBAAkB,EAAE,GACtC,IAAI,CAkBN"}