@volter/editor-game 0.5.68 → 0.5.70

package/src/runtime/debug-registry.ts

@@ -31,8 +31,8 @@ import type { Game } from './game';
 
 /**
  * The minimal structural shape `ctx.debug.attachRoom` needs from a joined
- * Colyseus room: just enough to send the reserved `__vgai:debugCommand`
- * message and listen for its `__vgai:debugCommandResult` reply. Structural,
+ * Colyseus room: just enough to send the reserved `__volter:debugCommand`
+ * message and listen for its `__volter:debugCommandResult` reply. Structural,
  * not a Colyseus type import — the same seam-boundary style every other
  * `DebugCtxSurface` member uses (no wrapper around Colyseus itself, D2).
  * `onMessage`'s return type is `unknown` because Colyseus's own return shape
@@ -99,15 +99,15 @@ export interface DebugCtxSurface {
   /**
    * Task 2.2 — server-locus command routing (client leg). Call once your
    * game code has joined its Colyseus room, so `locus: 'server'` commands
-   * have somewhere to send `__vgai:debugCommand`. Returns a detach function
+   * have somewhere to send `__volter:debugCommand`. Returns a detach function
    * (call on room leave/dispose) — game-scoped, last-attached room wins.
    */
   attachRoom(room: DebugRoomHandle): () => void;
 }
 
 /** Engine-local error for the debug seam — mirrors the `code` + `data` shape
- *  `packages/vgai-sdk/src/errors.ts` uses (no import: the engine does not
- *  depend on `@vgai/sdk`). `code` is always machine-readable; nothing reading
+ *  `packages/volter-sdk/src/errors.ts` uses (no import: the engine does not
+ *  depend on the SDK). `code` is always machine-readable; nothing reading
  *  this error may key off `message` prose. */
 export class DebugError extends Error {
   readonly code: string;
@@ -129,7 +129,7 @@ const REGISTRATION_HINT =
  *  (`POST /__editor/command`) and `page.evaluate` both serialize the error's
  *  `data` bag — and an `Error` stringifies to `{}` there, so a command's own
  *  refusal text ("no such waypoint") vanished and the developer at
- *  `vgai eval` saw only `debug: command "x" threw`. The text has to travel as
+ *  `volter-game-editor eval` saw only `debug: command "x" threw`. The text has to travel as
  *  plain strings, and in the `message` above all: that is the one field every
  *  client (`SessionError`, the CLI's own error print) actually surfaces. */
 function describeCause(cause: unknown): {
@@ -145,12 +145,12 @@ function describeCause(cause: unknown): {
 }
 
 /** Task 2.2 — how long `invoke()` waits for a `locus: 'server'` command's
- *  `__vgai:debugCommandResult` reply before failing loudly. */
+ *  `__volter:debugCommandResult` reply before failing loudly. */
 const SERVER_COMMAND_TIMEOUT_MS = 10_000;
 
 /** The virtual-input surface the debug bridge (`runtime/debug-bridge.ts`)
  *  actuates through: a root's input door — its entry's `debug.input`
- *  (`adapter/native-debug-module.ts`) or a `vgai.adapter.ts` input binding
+ *  (`adapter/native-debug-module.ts`) or a `volter.adapter.ts` input binding
  *  (`host/adapter-runtime-bindings.ts`), wired once per root when its bindings
  *  install, at the same spot as `setInputActionsSource` — absent until then. */
 export interface DebugVirtualInputTarget {
@@ -200,7 +200,7 @@ export interface InputTraceSnapshot {
  *  (`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. */
+ *  `play.runTicks` (the 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,
@@ -295,7 +295,7 @@ export interface DebugRegistry {
    * Every world's target is kept, keyed by `worldId`, and
    * {@link getVirtualInputTarget} resolves ONE of them via
    * {@link resolveInputRootId} — the SAME resolution the debug bridge
-   * (`window.__vgai.input.*`) and the editor relay both call through, so they
+   * (`window.__volter.input.*`) and the editor relay both call through, so they
    * can never disagree about which root an unaddressed actuation reaches. An
    * explicit `worldId` reaches that world specifically. */
   setVirtualInputTarget(worldId: string, target: DebugVirtualInputTarget): void;
@@ -318,7 +318,7 @@ export interface DebugRegistry {
    * 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`
+   * SAME target backs `runtime/debug-bridge.ts`'s `window.__volter.runTicks`
    * (door a) and the editor relay's `run-ticks` case → `play.runTicks`
    * (door b) — one implementation, byte-identical semantics across doors
    * (D17).
@@ -605,8 +605,8 @@ export function createDebugRegistry(opts: {
   /**
    * Task 2.2 — server-locus command routing (client leg). A `locus: 'server'`
    * command never calls its own registered `fn` locally: `invoke()` instead
-   * sends the reserved room message `__vgai:debugCommand` and resolves on the
-   * matching `__vgai:debugCommandResult` reply, so a fixture mutates the
+   * sends the reserved room message `__volter:debugCommand` and resolves on the
+   * matching `__volter:debugCommandResult` reply, so a fixture mutates the
    * AUTHORITATIVE (server) copy of state, not client prediction. Request ids
    * are a monotonic per-registry counter (`dbg-<n>`), not `Math.random`/
    * `Date.now`, so two in-flight commands never collide and correlation is
@@ -635,14 +635,14 @@ export function createDebugRegistry(opts: {
         );
       }, SERVER_COMMAND_TIMEOUT_MS);
       pendingServerCommands.set(requestId, { resolve, reject, timer });
-      room.send('__vgai:debugCommand', { name, args, requestId });
+      room.send('__volter:debugCommand', { name, args, requestId });
     });
   }
 
   // Defect 8 fix — the live detach() for whatever room is CURRENTLY attached
   // (or null if none). `attachRoom` calls this itself before attaching a new
   // room: without it, a second `attachRoom` call (no explicit `detach()` in
-  // between) left the first room's `__vgai:debugCommandResult` subscription
+  // between) left the first room's `__volter:debugCommandResult` subscription
   // live forever (a leak — the old room keeps getting messages dispatched to
   // a handler nothing reads anymore) and stranded any of ITS in-flight
   // commands riding the full 10s timeout with no way to ever be answered.
@@ -652,7 +652,7 @@ export function createDebugRegistry(opts: {
    *  surface (game-scoped, last-attached room wins — and, since Defect 8,
    *  actually CLEANS UP the previous attachment rather than merely
    *  overwriting the pointer). Subscribes to the reserved
-   *  `__vgai:debugCommandResult` reply and resolves/rejects the matching
+   *  `__volter:debugCommandResult` reply and resolves/rejects the matching
    *  in-flight {@link invokeServerCommand} promise by `requestId`. */
   function attachRoom(room: DebugRoomHandle): () => void {
     // Last-wins, but with cleanup: detach whatever room was attached before
@@ -661,7 +661,7 @@ export function createDebugRegistry(opts: {
     detachCurrentRoom?.();
 
     attachedRoom = room;
-    const unsubscribe = room.onMessage('__vgai:debugCommandResult', (message) => {
+    const unsubscribe = room.onMessage('__volter:debugCommandResult', (message) => {
       const reply = message as
         | { requestId?: string; ok?: boolean; result?: unknown; error?: unknown }
         | undefined;

package/src/runtime/dev/instruments.ts

@@ -21,7 +21,7 @@
  * game's own camera writes never fight it because the game keeps rendering
  * through its own canvas untouched. Per the non-redundancy rule that governs
  * this list, a control the editor's own chrome furnishes gets no instrument;
- * agents reach that camera through the editor half of `vgai eval`, not the
+ * agents reach that camera through the editor half of `volter-game-editor eval`, not the
  * game registry.
  *
  * ── THE DOOR ────────────────────────────────────────────────────────────────

package/src/runtime/dev/performance-profiler.ts

@@ -266,7 +266,7 @@ export function createPerformanceProfiler(initiallyEnabled = false) {
         startMs: existing?.startMs ?? phaseStart - frameStart,
       });
       if (recording)
-        performance.measure(`vgai.phase.${name}`, { start: phaseStart, duration: elapsed });
+        performance.measure(`volter.phase.${name}`, { start: phaseStart, duration: elapsed });
     },
     systemObserver: {
       beginSystem() {
@@ -344,7 +344,7 @@ export function createPerformanceProfiler(initiallyEnabled = false) {
       frames.push(frame);
       if (frames.length > 600) frames.splice(0, frames.length - 600);
       if (recording)
-        performance.measure('vgai.frame', { start: frameStart, duration: frame.cpuMs });
+        performance.measure('volter.frame', { start: frameStart, duration: frame.cpuMs });
       publish();
     },
     subscribe(listener: () => void) {

package/src/runtime/dev/register-render-vitals.ts

@@ -3,7 +3,7 @@
  * game's own debug registry (`runtime/debug-registry.ts`), so a running game
  * explains its own frame cost through the SAME seam every other reading and
  * verb uses — `game.state('render.vitals')` / `game.command('render.census')`
- * through `vgai eval`, and `game.providers()`/`game.commands()` to discover
+ * through `volter-game-editor eval`, and `game.providers()`/`game.commands()` to discover
  * them without being told they exist.
  *
  * Engine-owned and first-party, seeded by BOTH three-root mount paths — a game
@@ -175,7 +175,7 @@ export function registerRenderVitals(
         'Meshes grouped by shared (geometry, material) identity, largest group first — the ' +
         'instancing shortlist for a draw-call diet. `structural` is the same scan keyed by ' +
         'VALUE instead of object identity: what would collapse under a <Frozen> wrapper ' +
-        '(vgai add static-batch) even when every mesh carries its own inline material.',
+        '(volter-game-editor add static-batch) even when every mesh carries its own inline material.',
       args: z.tuple([]),
       locus: 'client',
     },

package/src/runtime/dev/static-batch-advisor.ts

@@ -138,7 +138,7 @@ export function decideStaticBatchAdvisory(
     `are repeats of ${grouped(structural.familyCount)} structural families, ` +
     `${where}. If that scenery is mount-static — nothing under it moves, re-colours or ` +
     `unmounts after mount — one wrapper collapses it to a few draws: wrap it in ` +
-    `${fix}…</Frozen>  (vgai add static-batch). Reactive scenery goes outside the wrapper, ` +
+    `${fix}…</Frozen>  (volter-game-editor add static-batch). Reactive scenery goes outside the wrapper, ` +
     `and a subtree that must stay unbatched declares it: userData={{ staticBatch: false }}.`;
 
   return { drawCalls, collapsible, subtree, fix, message };
@@ -150,14 +150,14 @@ export function decideStaticBatchAdvisory(
  * along with everything else on the console. Same mechanism, and the same
  * reason, as dev-tools' unconfigured-section warning.
  */
-const WARNED_KEY = '__vgaiStaticBatchAdvised';
+const WARNED_KEY = '__volterStaticBatchAdvised';
 
 function alreadyWarned(): boolean {
   return (globalThis as unknown as Record<string, boolean | undefined>)[WARNED_KEY] === true;
 }
 
 /**
- * The console IS this advisory's channel: `vgai status` reports console
+ * The console IS this advisory's channel: `volter-game-editor status` reports console
  * warnings, which is where a building agent already looks. An in-editor
  * banner would be one nobody opens, and a provider would be one nobody reads
  * without already knowing to ask.

package/src/runtime/dev-build.ts

@@ -24,7 +24,7 @@
  *     case: it is a dev session by definition even when the editor SPA it
  *     runs inside is a production build.
  *  2. A dev build — `import.meta.env.DEV`. The ordinary local/editor case.
- *  3. A production build's EXPLICIT opt-in — `VITE_VGAI_DEV_BUILD=true`.
+ *  3. A production build's EXPLICIT opt-in — `VITE_VOLTER_DEV_BUILD=true`.
  *     Instrumenting a production bundle is a real, legitimate choice (an
  *     internal playtest build, a QA build), and it must be an opt-in someone
  *     had to type, never something a default drifts into.
@@ -40,8 +40,8 @@ export function devBuildEnabled(override?: boolean | undefined): boolean {
   // of the dev answer importable from ANY program rather than forcing every
   // downstream tsconfig to adopt Vite's ambient types.
   const env = (import.meta as unknown as { env?: unknown }).env as
-    | { DEV?: boolean | undefined; VITE_VGAI_DEV_BUILD?: string | undefined }
+    | { DEV?: boolean | undefined; VITE_VOLTER_DEV_BUILD?: string | undefined }
     | undefined;
   if (env?.DEV === true) return true;
-  return env?.VITE_VGAI_DEV_BUILD === 'true';
+  return env?.VITE_VOLTER_DEV_BUILD === 'true';
 }

package/src/runtime/game.ts

@@ -744,9 +744,9 @@ export interface GameInternal extends Game {
    * 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
+   * `render-control.ts`'s proven `VolterRenderHarness. simulateSubsteps` from
+   * the capture-only door (`?volter-render=1`) to a Game-level primitive every
+   * door can reach (the bridge's `window.__volter.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).
@@ -816,7 +816,7 @@ export function createGame(opts: {
    *  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 `mountManifestRoots`) is what actually resolves
-   *  `manifest.determinism.defaultSeed`/`?vgai-seed=`/explicit config and
+   *  `manifest.determinism.defaultSeed`/`?volter-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). */
@@ -1618,7 +1618,7 @@ export function createGame(opts: {
   // D15/T-D15.4: wire the run-ticks target the instant the Game shell exists
   // (unlike `setVirtualInputTarget`, which waits for a per-world mount, a
   // Game's own `runTicks` needs nothing else) — this is what makes
-  // `window.__vgai.runTicks` (`debug-bridge.ts`) and the editor relay's
+  // `window.__volter.runTicks` (`debug-bridge.ts`) and the editor relay's
   // `run-ticks` case reach the SAME implementation `game.runTicks` above is.
   debugRegistry.setRunTicksTarget({ runTicks: gameInternal.runTicks });
   // D15 (T-D15.1/.3) — same "file after the shell exists" ordering as the

package/src/runtime/input-router.ts

@@ -160,7 +160,7 @@ export function createInputRouter(
     if (claimant && claimant !== bottomId) {
       const entry = byId.get(claimant);
       if (entry) {
-        // The claim is exclusive: the world beneath never hears a press its HUD took.
+        // The claim is exclusive: the world beneath never hears a press the layer above took.
         evt.stopPropagation();
         forwardEvent(entry.canvas, evt);
       }

package/src/runtime/mount-manifest.ts

@@ -130,7 +130,7 @@ export interface MountManifestOptions {
    *  never a real host. See `RootsRuntimeConfig.headless`. */
   readonly headless?: boolean | undefined;
   /**
-   * Task 2.1: overrides for the `?vgai-debug=1` bridge `mountManifestRoots`
+   * Task 2.1: overrides for the `?volter-debug=1` bridge `mountManifestRoots`
    * installs at the tail of every mount — the engine-owned install point so
    * every standalone project gets it with zero template edits. Omit both in
    * a real host (defaults to `window.location`/ `window`); a headless test
@@ -145,7 +145,7 @@ export interface MountManifestOptions {
     | undefined;
   /**
    * D15 (T-D15.1) — the "explicit config" leg of the boot-time seed
-   * precedence (`manifest.determinism.defaultSeed` → `?vgai-seed=` → this),
+   * precedence (`manifest.determinism.defaultSeed` → `?volter-seed=` → this),
    * highest-precedence, for a caller that already knows the exact seed it
    * wants (a future CLI `--seed`/probe fixture `seed` option, T-D15.6).
    * Ignored entirely unless the manifest declares
@@ -154,7 +154,7 @@ export interface MountManifestOptions {
   readonly seed?: number | undefined;
   /** Host identity for a private play run or coordinated Team Test. */
   readonly playtest?: PlaytestContext | null | undefined;
-  /** Where to read `?vgai-seed=` from for the boot-time seed reader. Same
+  /** Where to read `?volter-seed=` from for the boot-time seed reader. Same
    *  override precedent as `debugBridge.url` (defaults to `window.location`
    *  when a real `window` exists; a headless caller with no override gets no
    *  query-param seed, same as `maybeInstallDebugBridge`'s own url default). */
@@ -166,13 +166,13 @@ export interface MountManifestOptions {
  * `mountManifestRoots` threads into `createGameRuntime` (and therefore
  * `createGame`, BEFORE any world's `mount()`/`setup()` runs). Returns
  * `undefined` when the manifest doesn't declare `determinism.seededRandom`
- * at all — `?vgai-seed=` and `defaultSeed` are both ignored in that case
+ * at all — `?volter-seed=` and `defaultSeed` are both ignored in that case
  * (§2.a: "the mount path seeds ctx.random ... iff declared"; an undeclared
  * project's `ctx.random` still exists, just boots from `createGame`'s own
  * fixed default, unaffected by the manifest or the URL).
  *
  * Precedence when declared (highest wins): `explicitSeed` (a caller-supplied
- * config value) → `?vgai-seed=<int>` on `url` → `manifest.determinism
+ * config value) → `?volter-seed=<int>` on `url` → `manifest.determinism
  * .defaultSeed`.
  */
 export function resolveDeterminismSeed(opts: {
@@ -250,7 +250,7 @@ export function resolveManifest(raw: unknown): ResolvedGameManifest {
 
 // ---------------------------------------------------------------------------
 // Per-kind entry -> adapter resolution (mirrors `resolveRootBinding`'s
-// per-identity dispatch, `packages/editor/src/binding-resolver.ts`)
+// per-identity dispatch, `packages/editor-game/src/host/binding-resolver.ts`)
 // ---------------------------------------------------------------------------
 
 function resolveThreeAdapter(
@@ -341,7 +341,7 @@ function buildRootMountSpec(
     zOrder: world.zOrder,
     pausable: world.pausable,
     // `root` is this file's own resolved manifest record; the rest — the
-    // parsed `vgai.adapter.ts`, the entry namespace, the entry's declared
+    // parsed `volter.adapter.ts`, the entry namespace, the entry's declared
     // debug/systems bindings — only the caller who loaded the entry can know.
     ...(entry?.declaration === undefined
       ? {}
@@ -376,7 +376,7 @@ function buildRootMountSpec(
 // ---------------------------------------------------------------------------
 
 /**
- * Mount every world declared by a `vgai.project.json` manifest onto `container`,
+ * Mount every world declared by a `volter.project.json` manifest onto `container`,
  * standalone — no editor, no dev server. The generalization of
  * `examples/tri-world/src/main.ts`'s hand-built `RootMountSpec[]` (D-Z2). Reuses
  * the pure `loadGameManifest` + `createGameRuntime({ roots })` and mirrors
@@ -441,7 +441,7 @@ export async function mountManifestRoots(opts: MountManifestOptions): Promise<Ga
     getGameplayRngTrapControl(session.game)?.setEnabled(true);
   }
 
-  // Task 2.1 — install the `?vgai-debug=1` bridge at the TAIL of every
+  // Task 2.1 — install the `?volter-debug=1` bridge at the TAIL of every
   // manifest mount (engine-owned, so a standalone project gets it with zero
   // template edits). `getDebugRegistry` returns `null` only for a bare
   // `Game`-shaped test stand-in predating T7.1 — real mounts always have one.
@@ -458,7 +458,7 @@ export async function mountManifestRoots(opts: MountManifestOptions): Promise<Ga
       debugRegistry.setRoomDeclared(true);
     }
     // Defect 5 fix: `maybeInstallDebugBridge` adds `window` listeners and
-    // publishes `window.__vgai` with no way to undo either — wire its
+    // publishes `window.__volter` with no way to undo either — wire its
     // `uninstall()` into THIS session's own `stop()` so a caller that tears
     // this mount down doesn't leave the bridge (and its listeners) live.
     const bridgeHandle = maybeInstallDebugBridge({

package/src/runtime/pixi/authoring.ts

@@ -188,7 +188,7 @@ function viewOwnerLabel(view: Container): string | undefined {
  * on a 20 000-node `@pixi/react` world blocked the main thread for 199.5
  * SECONDS in one synchronous run, 69% of all profiler samples inside this
  * search, because `parentRenderGroup` reaches an array of every node in the
- * tree and the search walked it once per unlabeled node. `vgai play`,
+ * tree and the search walked it once per unlabeled node. `volter-game-editor play`,
  * `screenshot` and `stop` all timed out against a tab that was heartbeating
  * normally the whole time.
  */

package/src/runtime/pixi/ingest.ts

@@ -62,7 +62,7 @@ export interface IngestMount2D {
  * `onWait` is the three lane's own seam (`ingest-root-adapter.ts` passes
  * `setCaptureWait`): the capture window PARKS while the tab is hidden, and a
  * parked wait is otherwise indistinguishable from a hung mount at every door.
- * Threading it here is what lets `vgai status` say "waiting for the first
+ * Threading it here is what lets `volter-game-editor status` say "waiting for the first
  * visible frame — the tab is hidden" over a canvas ingest too.
  */
 export async function mountIngestGame2D(

package/src/runtime/presentation.ts

@@ -1,7 +1,7 @@
 /**
  * runtime/presentation.ts — how a game with a DECLARED resolution is presented in a host panel.
  *
- * `vgai.project.json`'s `resolution` is the game's own LOGICAL size: the coordinate space its
+ * `volter.project.json`'s `resolution` is the game's own LOGICAL size: the coordinate space its
  * cameras frame, its DOM overlay lays out in, and its 2D worlds author positions against. A host
  * panel is whatever size the user dragged it to, and the two are not the same number.
  *

package/src/runtime/render-control.ts

@@ -17,14 +17,14 @@
  *
  * Also does NOT install anything by default — a caller must explicitly call
  * {@link installRenderControlHarness}, and even then it only actually
- * publishes `window.__vgaiRender` when the page's URL opts in via
- * `?vgai-render=1` (AC 4: unavailable/protected in normal production
+ * publishes `window.__volterRender` when the page's URL opts in via
+ * `?volter-render=1` (AC 4: unavailable/protected in normal production
  * gameplay unless explicitly enabled). See `render-seed.ts` for the
  * matching `Math.random` determinism hardening, which must run BEFORE this
  * module (or any other game module) is even imported.
  *
  * I5 (`--simulate` render, §15 I5) is implemented HERE, alongside `renderOnce`:
- * {@link VgaiRenderHarness.simulateSubsteps} drives `game.runFrame(fixedDt)` a
+ * {@link VolterRenderHarness.simulateSubsteps} drives `game.runFrame(fixedDt)` a
  * fixed integer number of times — the FULL fixed-step gameplay frame (every
  * phase in `PHASE_ORDER`, including `physics`/`gameLogic`/`animation`), unlike
  * `renderOnce`'s deliberately gameplay-free `preRender`+`render`-only pass.
@@ -109,11 +109,11 @@ export interface SeekableClock {
  */
 export type FrameAdvancer = (dt: number) => void;
 
-/** The `window.__vgaiRender` surface (I2 AC, extended by I8's `advanceFrame`).
+/** The `window.__volterRender` surface (I2 AC, extended by I8's `advanceFrame`).
  *  Every method here is synchronous except the two that genuinely need to
  *  wait on the browser (composited render completion, async readiness
  *  probes). */
-export interface VgaiRenderHarness {
+export interface VolterRenderHarness {
   /** Evaluate every registered sequence/cinematic-participating evaluator at
    *  exact time `t` (seconds) via `clock.seek(t)` — never advances gameplay
    *  substeps. Synchronous: the clock's subscribed evaluators run inline,
@@ -129,7 +129,7 @@ export interface VgaiRenderHarness {
    * by exactly `dt` seconds, in registration order. A render-mode capture
    * loop calls this ONCE per OUTPUT frame, with `dt = 1 / fps`, BEFORE
    * `seekFrame`/`renderOnce` for that frame — see
-   * `packages/vgai-sdk/src/render/render-cinematic.ts`'s `captureFrames`, which
+   * `packages/volter-sdk/src/render/render-cinematic.ts`'s `captureFrames`, which
    * drives exactly this sequence. `advanceFrame` is a genuinely
    * FORWARD-ONLY, INCREMENTAL tick (it has no notion of "time" to seek
    * to — it only knows "advance by `dt` more") — unlike {@link seek}/
@@ -213,7 +213,7 @@ export interface VgaiRenderHarness {
    */
   simulateFixedDt(): number;
   /**
-   * W3d (F11 perf regression gates) — the `vgai perf` sampling seam. Runs
+   * W3d (F11 perf regression gates) — the `volter perf` sampling seam. Runs
    * exactly `steps` FULL fixed-step gameplay frames (the same
    * `game.runFrame(fixedDt)` path {@link simulateSubsteps} drives — every
    * phase in `PHASE_ORDER`, including `render`, so `renderer.info`-backed
@@ -226,7 +226,7 @@ export interface VgaiRenderHarness {
    * from the existing profiler (timings, render counters) or the live world
    * roots themselves (counts).
    *
-   * Honesty notes, recorded here because this seam is what `vgai perf`
+   * Honesty notes, recorded here because this seam is what `volter perf`
    * reports: `gpuMs` is whatever the profiler's render reporter measured —
    * `null` under headless SwiftShader (no usable GPU timer), never a
    * fabricated 0; CPU timings include the profiler's own (small) phase
@@ -237,7 +237,7 @@ export interface VgaiRenderHarness {
   perfSample(steps: number): PerfSampleReport;
 }
 
-/** One measured fixed-step frame from {@link VgaiRenderHarness.perfSample}. */
+/** One measured fixed-step frame from {@link VolterRenderHarness.perfSample}. */
 export interface PerfFrameSample {
   /** CPU time (ms) for the whole `runFrame` pass (profiler `cpuMs`). */
   readonly cpuMs: number;
@@ -255,7 +255,7 @@ export interface PerfFrameSample {
   };
 }
 
-/** Per-world structural counts from {@link VgaiRenderHarness.perfSample}. */
+/** Per-world structural counts from {@link VolterRenderHarness.perfSample}. */
 export interface PerfRootCount {
   readonly id: string;
   readonly kind: string;
@@ -279,7 +279,7 @@ export interface RenderControlHarnessOptions {
   /**
    * `GameInternal` (not just the game-facing `Game`) — this harness is
    * itself a host (the render/capture driver), and I5's
-   * {@link VgaiRenderHarness.simulateSubsteps} needs the host-only
+   * {@link VolterRenderHarness.simulateSubsteps} needs the host-only
    * `runFrame` surface (`runtime/game.ts`'s `GameInternal.runFrame` doc
    * comment: "the host loop ... and `GameSession.step()` are the only
    * callers"). Every real call site already holds a `GameInternal` (the
@@ -292,9 +292,9 @@ export interface RenderControlHarnessOptions {
   /** Where to publish the harness. Defaults to the real `window` — override
    *  in a unit test to avoid touching the global object. */
   readonly target?: Record<string, unknown>;
-  /** Where to read `?vgai-render=1` from. Defaults to `window.location`. */
+  /** Where to read `?volter-render=1` from. Defaults to `window.location`. */
   readonly location?: { readonly search: string };
-  /** I8 render-integration seam — see {@link VgaiRenderHarness.advanceFrame}.
+  /** I8 render-integration seam — see {@link VolterRenderHarness.advanceFrame}.
    *  Zero or more `FrameAdvancer`s invoked, in array order, on every
    *  `harness.advanceFrame(dt)` call. Default `[]` (no-op), which is exactly
    *  what a fixture with nothing gameplay-phase-driven (e.g. I0's fixture)
@@ -303,7 +303,7 @@ export interface RenderControlHarnessOptions {
   readonly frameAdvancers?: readonly FrameAdvancer[];
   /**
    * I5 `--simulate` seam: the fixed substep `dt` (seconds)
-   * {@link VgaiRenderHarness.simulateSubsteps} passes to every
+   * {@link VolterRenderHarness.simulateSubsteps} passes to every
    * `game.runFrame(fixedDt)` call. Default `1/60` — the same fixed timestep
    * every real host's `createGameLoop` config uses (`create-runtime.ts`), so
    * a `--simulate` fixture's Rapier world (whose own `integrationParameters.dt`
@@ -313,7 +313,7 @@ export interface RenderControlHarnessOptions {
    */
   readonly simulateFixedDt?: number;
   /**
-   * I5 AC 5 — see {@link VgaiRenderHarness.excludedFromDeterminism}. A
+   * I5 AC 5 — see {@link VolterRenderHarness.excludedFromDeterminism}. A
    * static, page-declared list of subsystems this fixture/game has that do
    * NOT participate in deterministic capture (e.g. live networking,
    * non-seeded ambient audio) — named here as an explicit, reviewable
@@ -412,7 +412,7 @@ function warnUnrenderable(worldLabel: string, reason: string): void {
 
 /**
  * I5 AC 5 policy text for the two conditions {@link renderableRoots} skips —
- * shared so {@link VgaiRenderHarness.excludedFromDeterminism} names the SAME
+ * shared so {@link VolterRenderHarness.excludedFromDeterminism} names the SAME
  * roots `renderOnce()` warns about, in the SAME words, rather than
  * maintaining a second, driftable description of the same two checks.
  */
@@ -539,17 +539,17 @@ async function buildReadinessReport(hooks: RenderReadinessHooks): Promise<Readin
 
 /**
  * Build (and, when render mode is actually requested, publish) the
- * `window.__vgaiRender` harness. AC 4 — production protection — lives HERE,
+ * `window.__volterRender` harness. AC 4 — production protection — lives HERE,
  * not just at the call site: even if a host application calls this
  * unconditionally on every boot, the harness is only ever constructed *and*
  * attached to `target` when `isRenderModeRequested(location)` is true;
  * otherwise this is a no-op that returns `undefined`. A normal production
- * gameplay page therefore never gets `window.__vgaiRender` no matter how
+ * gameplay page therefore never gets `window.__volterRender` no matter how
  * this function is wired into its entry point.
  */
 export function installRenderControlHarness(
   opts: RenderControlHarnessOptions,
-): VgaiRenderHarness | undefined {
+): VolterRenderHarness | undefined {
   const location = opts.location ?? window.location;
   if (!isRenderModeRequested(location)) return undefined;
 
@@ -559,7 +559,7 @@ export function installRenderControlHarness(
   const simulateFixedDt = opts.simulateFixedDt ?? 1 / 60;
   const declaredExclusions = opts.excludedFromDeterminism ?? [];
 
-  const harness: VgaiRenderHarness = {
+  const harness: VolterRenderHarness = {
     seek(t: number): void {
       clock.seek(t);
     },
@@ -610,7 +610,7 @@ export function installRenderControlHarness(
     },
   };
 
-  target['__vgaiRender'] = harness;
+  target['__volterRender'] = harness;
   return harness;
 }
 

package/src/runtime/render-seed.ts

@@ -54,14 +54,14 @@ export function installDeterministicRandom(seed: number): void {
  *  mode must be unavailable/protected in normal production gameplay unless
  *  explicitly enabled). Shared with `render-control.ts`'s own production
  *  guard so both checks agree on the same flag. */
-export const RENDER_MODE_QUERY_PARAM = 'vgai-render';
+export const RENDER_MODE_QUERY_PARAM = 'volter-render';
 /** Optional query param to pin a specific seed (default below when absent). */
-export const RENDER_SEED_QUERY_PARAM = 'vgai-seed';
+export const RENDER_SEED_QUERY_PARAM = 'volter-seed';
 const DEFAULT_RENDER_SEED = 0x9e3779b9; // golden-ratio constant — an arbitrary but fixed default
 
 /**
  * Seed `Math.random` iff the page's URL opts into render mode
- * (`?vgai-render=1`), reading an optional `?vgai-seed=<int>` override.
+ * (`?volter-render=1`), reading an optional `?volter-seed=<int>` override.
  * Returns whether it seeded, purely for the caller's own diagnostics/log —
  * the bootstrap entry doesn't need to branch on it.
  */

package/src/runtime/run-ticks-settled.ts

@@ -1,6 +1,6 @@
 /**
  * `runTicksWhenSettled` — the settled-aware tick driver behind BOTH session run-ticks doors
- * (the bridge's `window.__vgai.runTicksSettled`, the editor relay's `run-ticks` case), one
+ * (the bridge's `window.__volter.runTicksSettled`, the editor relay's `run-ticks` case), one
  * implementation with byte-identical semantics across doors, exactly as `runTicks` itself is
  * shared (D17).
  *

package/src/services/game-audio.ts

@@ -36,9 +36,9 @@ function resumeSuspended(): void {
 
 /** Install once at editor boot (`audio.service.ts`). Idempotent. */
 export function installGameAudio(): void {
-  const host = window as unknown as { __vgaiAudioUnlock?: boolean } & typeof window;
-  if (host.__vgaiAudioUnlock) return;
-  host.__vgaiAudioUnlock = true;
+  const host = window as unknown as { __volterAudioUnlock?: boolean } & typeof window;
+  if (host.__volterAudioUnlock) return;
+  host.__volterAudioUnlock = true;
   const Orig = window.AudioContext;
   if (typeof Orig !== 'function') return;
   window.AudioContext = class extends Orig {

package/src/services/game-network.ts

@@ -445,9 +445,9 @@ function observeMatchmaking(input: RequestInfo | URL, response: Response): void
 
 /** Install once at editor boot (`network-observer.service.ts`). Idempotent. */
 export function installGameNetwork(): void {
-  const host = window as unknown as { __vgaiNetworkObserver?: boolean } & typeof window;
-  if (host.__vgaiNetworkObserver) return;
-  host.__vgaiNetworkObserver = true;
+  const host = window as unknown as { __volterNetworkObserver?: boolean } & typeof window;
+  if (host.__volterNetworkObserver) return;
+  host.__volterNetworkObserver = true;
   const Orig = window.WebSocket;
   if (typeof Orig === 'function') {
     const Observed = class extends Orig {
@@ -574,7 +574,7 @@ async function roomCall(method: string, args: unknown[], what: string, roomId?:
   const query = new URLSearchParams({ roomId: roomId ?? mirror.roomId, method, args: JSON.stringify(args) });
   const response = await fetch(`${monitorApi(mirror)}/room/call?${query}`);
   if (response.status === 404) {
-    throw new Error(`The room server serves no Monitor view, so ${what} has nowhere to go (its \`server\` configuration sets VGAI_ROOM_MONITOR=1).`);
+    throw new Error(`The room server serves no Monitor view, so ${what} has nowhere to go (its \`server\` configuration sets VOLTER_ROOM_MONITOR=1).`);
   }
   if (!response.ok) throw new Error(`The room server refused ${what} (${response.status}).`);
 }