@vgai/engine 0.5.5 → 0.5.6

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

@@ -0,0 +1,287 @@
+/**
+ * The game-scoped debug/synthetic-player registry. ONE registry per `Game` root —
+ * every world's `ctx.debug` (see `DebugCtxSurface`, `runtime/types.ts`) feeds the
+ * SAME registry via {@link DebugRegistry.forRoot}, so a name a game registers is
+ * visible (and name-collision-checked) across every world, not just the one that
+ * registered it. `createGame` (`runtime/game.ts`) constructs the registry
+ * alongside the state bridge and files it in the `Game -> DebugRegistry` WeakMap
+ * this module owns; later consumers (the react `useDebugProvider`/
+ * `useDebugCommand` hooks, editor panels) reach it via {@link getDebugRegistry}
+ * rather than threading it through every call site.
+ *
+ * Provenance note: a registration's "world" is the MOUNT's adapter id (the
+ * `fromSetup(id, ...)` / `SetupThreeRootConfig.id` a project already names each
+ * world's entry with) rather than the `RootInstance.id` `registerThreeRoot`
+ * assigns — that id isn't known until AFTER `mount()` resolves (`create-
+ * runtime.ts` calls `registerThreeRoot` with it only once `mount()` returns),
+ * which is after every `setup()`-time registration has already run. For the
+ * single-world case (nearly every project today) this is simply `'setup-three'`;
+ * a multi-world manifest names each world's adapter to match its declared id
+ * by convention, so collision messages stay meaningful in practice.
+ */
+import { z } from 'zod';
+import type { DebugAdapter } from '../adapter/system-adapter';
+import type { GameLoopLiveness } from '../core/types';
+import type { Game } from './game';
+import type { DebugCommandArgs, DebugCtxSurface } from './types';
+/** 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
+ *  this error may key off `message` prose. */
+export declare class DebugError extends Error {
+    readonly code: string;
+    readonly data?: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, data?: Record<string, unknown>);
+}
+/** The virtual-input surface the debug bridge (`runtime/debug-bridge.ts`)
+ *  actuates through — the SAME three methods `InputManager` exposes
+ *  (`setVirtualAction`/`tapVirtualAction`/`clearVirtualActions`, Task 1.4),
+ *  typed narrowly here so this module never imports `InputManager` itself.
+ *  Wired once by the hosting adapter (`setup-three-root-adapter.ts`, at the
+ *  same seed spot as `setInputActionsSource`) — absent until then. */
+export interface DebugVirtualInputTarget {
+    setVirtualAction(action: string, value: boolean | number | {
+        x: number;
+        y: number;
+    }): {
+        delivered: boolean;
+        reason?: string;
+    };
+    tapVirtualAction(action: string): {
+        delivered: boolean;
+        reason?: string;
+    };
+    clearVirtualActions(): void;
+    /** D15/T-D15.5 — schedule a virtual actuation for a specific future (or
+     *  current) tick, applied at the start of that tick's input phase (composes
+     *  with `runTicks`). */
+    scheduleActionAtTick(tick: number, action: string, value: boolean | number | {
+        x: number;
+        y: number;
+    }): void;
+    startInputRecording(): void;
+    stopInputRecording(): void;
+    isInputRecording(): boolean;
+    /** The four legacy named-test-source injectors (`InputManager`'s own),
+     *  included here so `inject-input`'s non-`action` kinds route through the
+     *  SAME per-world resolution as everything else on this interface (D15
+     *  review objection: routing must never depend on registration order). */
+    injectAxis(sourceId: string, value: number): void;
+    injectVector2(sourceId: string, value: {
+        x: number;
+        y: number;
+    }): void;
+    injectPointerDelta(sourceId: string, delta: {
+        x: number;
+        y: number;
+    }): void;
+    injectPointerPosition(sourceId: string, value: {
+        x: number;
+        y: number;
+    }): void;
+}
+/**
+ * D15/T-D15.5 — the `input.trace` builtin provider's shape.
+ * `seed`/`fixedDt` are
+ * replay-critical metadata a future SP5 consumer needs BESIDE the raw
+ * per-tick action deltas (`ticks`, straight off `InputManager.getInputTrace()`)
+ * to know what to replay the trace AGAINST — recording deltas alone is not
+ * enough to reproduce a run. Both are `null` only when no wiring/no
+ * `ctx.random`/no `Game` exists behind this world (never a fabricated 0).
+ */
+export interface InputTraceSnapshot {
+    version: 1;
+    seed: number | null;
+    fixedDt: number | null;
+    ticks: unknown[];
+}
+/** `Game.runTicks`'s options — see `GameInternal.runTicks`'s doc comment
+ *  (`runtime/game.ts`, D15/T-D15.3-.4) for full semantics. Named here (not
+ *  re-declared per-caller) so the bridge (`runtime/debug-bridge.ts`), the
+ *  editor relay (`command-listener.ts`'s `run-ticks` case), and
+ *  `play.runTicks` (`@vgai/sdk`) all reference the SAME type. */
+export interface RunTicksOptions {
+    /** `'last'` (default) — skip `preRender`/`render` for every tick except
+     *  the final one. `'all'` — render every tick. `'none'` — never render,
+     *  not even the last tick. */
+    render?: 'last' | 'all' | 'none';
+}
+/** The run-ticks actuation surface a live `Game` wires in (see
+ *  {@link DebugRegistry.setRunTicksTarget}) — just `GameInternal.runTicks`'s
+ *  signature, typed narrowly here so this module never imports `./game`
+ *  as a value (only `Game` as a type, already the case above). */
+export interface RunTicksTarget {
+    runTicks(n: number, opts?: RunTicksOptions): void;
+}
+/** What {@link createDebugRegistry} returns — the adapter half (`DebugAdapter`,
+ *  for `SystemAdapters.debug`) plus the registration/lifecycle surface the
+ *  hosting adapter (`setup-three-root-adapter.ts`) and `createGame` drive. */
+export interface DebugRegistry {
+    /** The `SystemAdapters.debug` implementer — one shared instance, seeded
+     *  onto every world's adapter bag. */
+    readonly adapter: DebugAdapter;
+    /** Build the `ctx.debug` surface for one world/mount — registrations made
+     *  through it carry `worldId` as their provenance for collision messages. */
+    forRoot(worldId: string): DebugCtxSurface;
+    /** Emit from a React root through the same tick-stamped event ring as
+     *  `ctx.debug.emit`. React roots have no setup context, so
+     *  `useDebugEmit()` calls this dedicated door instead of reaching through
+     *  the registry's internal synthetic world id. */
+    emitReact(event: string, detail?: unknown): void;
+    /**
+     * Remove non-built-in registrations (Defect 2 fix — this used to be
+     * unconditionally global, which made a per-mount call like `hotReload`'s
+     * silently wipe every OTHER live world's registrations and every react-door
+     * registration, whose `useEffect` cleanup never re-fires to restore them).
+     *
+     * - `strip(worldId)` — scoped: removes only providers/commands whose
+     *   provenance is exactly `worldId` (and clears their warn-once state), so
+     *   a hot-reloading world re-seeds itself without disturbing anyone else.
+     *   React-door registrations (provenance `'__react__'`) are never touched
+     *   by a world-scoped strip.
+     * - `strip()` (no id) — the original global behavior: every non-built-in
+     *   registration is removed, including react-door ones. Intended for "the
+     *   whole game is going away" (`disposeGame`) or test teardown, not a
+     *   single mount's warm restart.
+     *
+     * Either way, the very next registration of a name just removed is silent —
+     * there is nothing left to collide with or warn about.
+     */
+    strip(worldId?: string): void;
+    /** Manifest wiring lands in a later wave; until then, call this directly
+     *  (default `false`) to exercise the locus-required throw. */
+    setRoomDeclared(declared: boolean): void;
+    /** Wire the built-in `input.actions` provider to a live `InputManager`
+     *  (T1.2), scoped to `worldId` — lazy, since a world's InputManager doesn't
+     *  exist yet when the registry is constructed (`createGame`, before any
+     *  world mounts). Before ANY source is set, `input.actions` reads `[]`;
+     *  once one or more roots have registered, the built-in `input.actions`
+     *  provider reads the DEFAULT world's (see {@link resolveInputRootId}) —
+     *  same resolution every other per-world seam on this interface uses. */
+    setInputActionsSource(worldId: string, fn: () => {
+        name: string;
+        valueType: string;
+    }[]): void;
+    /** D15/T-D15.5 — wire the built-in `input.trace` provider to a live
+     *  `InputManager.getInputTrace`, scoped to `worldId` — same lazy-supplier
+     *  shape/seed spot as {@link setInputActionsSource}, same default-world
+     *  resolution for the read. Before a source is set, `input.trace` reads
+     *  `{version: 1, seed: null, fixedDt: null, ticks: []}`. `seed`/`fixedDt`
+     *  are the two replay-critical metadata fields the design doc's format
+     *  sketch (§2.c) calls for beside the raw per-tick deltas — the wiring
+     *  adapter (`setup-three-root-adapter.ts`) assembles them from
+     *  `getSeededRandom(game)?.seed`/`host.game?.loop.fixedDt` alongside
+     *  `InputManager.getInputTrace()`'s own `{version, ticks}`. An `engine`
+     *  (package version) stamp remains a KNOWN GAP — no build-time version
+     *  constant is threaded into the runtime bundle today; a future track
+     *  adding one should extend this shape, not invent a second trace format. */
+    setInputTraceSource(worldId: string, fn: () => InputTraceSnapshot): void;
+    /**
+     * Wire the debug bridge's actuation methods (`runtime/debug-bridge.ts`) to
+     * a live `InputManager` (Task 2.1), scoped to `worldId` — same lazy-
+     * supplier shape as {@link setInputActionsSource}, wired at the same seed
+     * spot (once per world mount, not once per Game).
+     *
+     * Fix for a closed-PR review objection: this used to be a SINGLE slot
+     * (last-writer-wins across every world that mounted), which could route
+     * the debug bridge (`window.__vgai.input.*`, which read this directly) and
+     * the editor relay (which reached the default world's `InputManager`
+     * through a DIFFERENT accessor, `Game.input`) to two DIFFERENT roots in a
+     * multi-world project — the bridge always got whichever world mounted
+     * LAST, the relay always got the FIRST/default world. Now every world's
+     * target is kept, keyed by `worldId`, and {@link getVirtualInputTarget}
+     * resolves ONE of them via {@link resolveInputRootId} — the SAME
+     * resolution the bridge and the relay both call through, so they can never
+     * disagree again. An explicit `worldId` reaches that world specifically. */
+    setVirtualInputTarget(worldId: string, target: DebugVirtualInputTarget): void;
+    /**
+     * Resolve and return a virtual-input target: `worldId` given and
+     * registered → that world's; omitted → the DEFAULT world's (per
+     * {@link resolveInputRootId} — the manifest's first/default world when a
+     * `Game` is behind this registry, else the single registered world, else
+     * whichever registered first), consistently, for every caller (the debug
+     * bridge and the editor relay both call this — see this interface's own
+     * doc comment above). `null` when nothing is registered for the resolved
+     * id at all (callers throw a structured `DEBUG_INPUT_UNAVAILABLE` in that
+     * case rather than silently no-op-ing). Throws `DebugError`
+     * (`DEBUG_INPUT_WORLD_NOT_FOUND`) for an EXPLICIT `worldId` that was never
+     * registered — a caller mistake, distinct from "nothing mounted yet".
+     */
+    getVirtualInputTarget(worldId?: string): DebugVirtualInputTarget | null;
+    /**
+     * D15/T-D15.4: wire `Game.runTicks` (`runtime/game.ts`) as the run-ticks
+     * actuation target — called ONCE by `createGame`, immediately (unlike
+     * {@link setVirtualInputTarget}, which waits for a per-world mount, a
+     * `Game`'s own `runTicks` exists the instant the Game shell does). The
+     * SAME target backs `runtime/debug-bridge.ts`'s `window.__vgai.runTicks`
+     * (door a) and the editor relay's `run-ticks` case → `play.runTicks`
+     * (door b) — one implementation, byte-identical semantics across doors
+     * (D17).
+     */
+    setRunTicksTarget(target: RunTicksTarget): void;
+    /** The target {@link setRunTicksTarget} last set, or `null` before any
+     *  `Game` has wired one (a bare `createDebugRegistry()` test stand-in with
+     *  no `createGame` behind it). Consumers throw a structured "unavailable"
+     *  error in that case rather than silently no-op-ing — see
+     *  `debug-bridge.ts`'s `runTicks` method. */
+    getRunTicksTarget(): RunTicksTarget | null;
+    /** D15/T-D15.3/.5 — the CURRENT shared game tick (the same counter the
+     *  built-in `time` provider's `tick` field reads), for a per-world
+     *  `InputManager.poll(tick)` call to key its `scheduleActionAtTick`
+     *  numbering off — see `setup-three-root-adapter.ts`'s `systems.add('input',
+     *  ...)` wiring. `0` for a bare `createDebugRegistry()` test stand-in with
+     *  no real `Game`/tick counter behind it (matching `getTick`'s own
+     *  constructor-supplied default in that case). */
+    getGameTick(): number;
+    /** React-door registration (Task 1.5, spec §3.1's "react-world
+     *  registration door") — same accumulator as `forRoot(...)
+     *  .registerStateProvider`, provenance `'__react__'` (see {@link REACT_WORLD_ID}),
+     *  but returns a disposer instead of requiring a separate unregister call.
+     *  Calling the disposer removes the registration ONLY if it is still the
+     *  live entry under `name` — unmount never clobbers a DIFFERENT mount's
+     *  later registration of the same name, and (matching `strip()`) removal
+     *  is silent: the very next registration of that name has nothing to warn
+     *  about. */
+    registerReactProvider(name: string, fn: () => unknown, opts?: {
+        tier?: 'observable' | 'assisted' | undefined;
+    }): () => void;
+    /** See {@link registerReactProvider} — the command-side counterpart. Same
+     *  args-tuple-infers-`fn`-params generic as `DebugCtxSurface.registerCommand`
+     *  ({@link DebugCommandArgs}). */
+    registerReactCommand<T extends z.ZodTuple | undefined = undefined>(name: string, spec: {
+        description?: string;
+        args?: T;
+        locus?: 'client' | 'server';
+    }, fn: (...args: DebugCommandArgs<T>) => unknown | Promise<unknown>): () => void;
+}
+/**
+ * Construct a fresh game-scoped debug registry. `getTick`/`getSimT` are
+ * suppliers (not values) so the built-in `time` provider always reads the
+ * CURRENT counters — `createGame` passes closures over its own mutable
+ * `tick`/`simT`, incremented in `runFrame`'s tail (T1.2). `getDefaultRootId`
+ * (D15/T-D15.5, optional) resolves the manifest's first/default world id —
+ * `createGame` passes `() => (roots.length ? requireDefaultRoot().id :
+ * null)`; a bare `createDebugRegistry()` test stand-in with no `Game` behind
+ * it omits it (per-world resolution then falls back to "the single
+ * registered world" or "whichever registered first" — see
+ * `resolveInputRootId`). `getLoopLiveness` (issue #175, optional) supplies
+ * the REAL `GameLoop.liveness` — `createGame` passes `() => opts.loop.
+ * liveness`; a bare `createDebugRegistry()` test stand-in with no loop
+ * behind it omits it, and the built-in `time` provider reports `null`
+ * rather than fabricating `'running'` (this module must never claim health
+ * it cannot observe, same rule the loop's own liveness getter documents).
+ */
+export declare function createDebugRegistry(opts: {
+    getTick(): number;
+    getSimT(): number;
+    getDefaultRootId?(): string | null;
+    getLoopLiveness?(): GameLoopLiveness;
+}): DebugRegistry;
+/** Called once by `createGame`, right after both the registry and the Game
+ *  shell object exist, to file the association {@link getDebugRegistry} reads. */
+export declare function registerDebugRegistry(game: Game, registry: DebugRegistry): void;
+/** The game-scoped registry backing `game.systemAdapters.debug`, or `null` for
+ *  a `Game` built without one (there is always one for every `createGame`
+ *  call — `null` only for a `Game`-shaped stand-in a test builds by hand). */
+export declare function getDebugRegistry(game: Game): DebugRegistry | null;
+//# sourceMappingURL=debug-registry.d.ts.map

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

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