@volter/editor-game 0.5.67 → 0.5.69

package/src/ingest/ingest-evidence-hook.ts

@@ -1,7 +1,7 @@
 /**
- * The `__vgaiIngest` / `__vgaiIngest2D` / `__vgaiIngestReact` dev hooks: the
+ * The `__volterIngest` / `__volterIngest2D` / `__volterIngestReact` dev hooks: the
  * headless-readable evidence a live ingest mount publishes for automation,
- * screenshots and `vgai doctor`.
+ * screenshots and probes.
  *
  * Everything here is EVIDENCE, not control: names read off the live adapter,
  * counters read off the live gate, the coverage report re-derived on demand.
@@ -18,7 +18,7 @@ import type { IngestMount } from './authoring/ingest-root-adapter';
 import { ingestCoverageReport } from './mount-coverage';
 
 /** The window key each surface's mount publishes its evidence under. */
-export type IngestHookKey = '__vgaiIngest' | '__vgaiIngest2D' | '__vgaiIngestReact';
+export type IngestHookKey = '__volterIngest' | '__volterIngest2D' | '__volterIngestReact';
 
 const AUTHORING_PROVIDER_KEYS = [
   'hierarchy',
@@ -57,7 +57,7 @@ export function ingestHookEvidence(adapter: AuthoringAdapter): Record<string, un
 }
 
 /**
- * The loop fields the `__vgaiIngest` dev hook publishes — the measured verdict
+ * The loop fields the `__volterIngest` dev hook publishes — the measured verdict
  * plus the gate's own counters, so automation can drive Play/Pause/Step through
  * exactly the seam the editor's own buttons use rather than a parallel one.
  */
@@ -85,10 +85,10 @@ export function defineLoopHookFields(target: Record<string, unknown>, mount: Ing
 
 /**
  * D-L1 — the LIVE value behind
- * `__vgaiIngestReact.domEvidence()`, shared by both react ingest routes.
+ * `__volterIngestReact.domEvidence()`, shared by both react ingest routes.
  * Evaluated at scrape time (a function result, never memoized),
  * same "read the live state fresh on every call" discipline as
- * `__vgaiSiblingMounts` (D-H1).
+ * `__volterSiblingMounts` (D-H1).
  *
  * `elementCount` prefers the DOM's real `querySelectorAll('*').length` — a
  * real browser `HTMLElement` (what `reactRoot()` actually returns in

package/src/ingest/ingest-frame-snapshot.ts

@@ -1,12 +1,12 @@
 /**
- * SAME-FRAME PIXELS for an ingested game's canvas — the reason `vgai
+ * SAME-FRAME PIXELS for an ingested game's canvas — the reason `volter-game-editor
  * screenshot` no longer returns black over a running ingest.
  *
  * ## The failure
  *
  * `composite-screenshot.ts` reads a game's canvas with `drawImage`, and that
  * only works on a WebGL canvas whose context was created with
- * `preserveDrawingBuffer: true`. Every canvas the vgai RUNTIME mounts sets it
+ * `preserveDrawingBuffer: true`. Every canvas the volter RUNTIME mounts sets it
  * (`@volter/editor-game/runtime/create-runtime`), which is why the composite leg has always
  * worked for first-party play. An INGESTED game creates its own canvas: the
  * racing-game's `<Canvas>` passes no `gl` prop, so fiber's default

package/src/ingest/ingest-play-commands.ts

@@ -1,6 +1,6 @@
 /**
  * Relay play-control dispatch for an INGEST session — the SimCity ledger's S-2
- * ("`vgai play` destroys a working source-mount").
+ * ("`volter-game-editor play` destroys a working source-mount").
  *
  * ## The defect
  *

package/src/ingest/ingest-play-control.ts

@@ -12,13 +12,13 @@ import { gameContractEpoch } from '../host/coverage/game-contract-seam-evidence'
 import { recordLiveSeamEvidence } from '@volter/editor-sdk/kit/live-seam-evidence';
 import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
 import { activateLiveDocument } from '@volter/editor-sdk/kit/live-document';
-import type { VgaiGameContract } from '@volter/editor-project/adapter/ingest/game-contract';
+import type { VolterGameContract } from '@volter/editor-project/adapter/ingest/game-contract';
 import { activeIngest, type IngestLifecycleControl } from './active-ingest';
 import { readIngestGameContract } from './game-contract-realm';
 
 /**
  * The play-state control surface for the CURRENT ingest session (F17/F21):
- * mounts are COLD by doctrine — the adapter sets `window.__vgaiMountCold`
+ * mounts are COLD by doctrine — the adapter sets `window.__volterMountCold`
  * before the game's entry executes, and a session-driven game may defer its
  * side-effects (backend connection, narrative, audio) until the first
  * `play()`. Everything is contract-first (game-contract.ts): `lifecycle.start`
@@ -72,9 +72,9 @@ export function setIngestPlaying(playing: boolean): void {
  */
 export function resetIngestPlaySurface(): void {
   setIngestPlaying(false);
-  const w = window as unknown as { __vgaiMountCold?: boolean; __vgaiIngestPlayed?: boolean };
-  delete w.__vgaiMountCold;
-  delete w.__vgaiIngestPlayed;
+  const w = window as unknown as { __volterMountCold?: boolean; __volterIngestPlayed?: boolean };
+  delete w.__volterMountCold;
+  delete w.__volterIngestPlayed;
 }
 
 /**
@@ -90,7 +90,7 @@ export interface IngestLifecycleFallback {
 }
 
 function runContractLifecycleEffect(
-  contract: VgaiGameContract,
+  contract: VolterGameContract,
   member: 'start' | 'pause' | 'resume',
   run: () => void,
 ): void {
@@ -132,7 +132,7 @@ export function bindIngestLifecycle(
       runContractLifecycleEffect(contract, 'start', () => declared.start?.());
       return;
     }
-    window.dispatchEvent(new CustomEvent('vgai:ingest-play'));
+    window.dispatchEvent(new CustomEvent('volter:ingest-play'));
   };
 
   const hasPause = typeof declared?.pause === 'function';
@@ -209,7 +209,7 @@ function fanOutSiblingPause(paused: boolean): void {
  * either from its own entry, or from the host-added module the manifest names
  * in `ingest.contractShim`, which the mount imports first.
  */
-export function activeIngestContract(): VgaiGameContract | null {
+export function activeIngestContract(): VolterGameContract | null {
   return readIngestGameContract();
 }
 
@@ -247,9 +247,9 @@ export function getIngestPlayControl(): IngestPlayControl | null {
       // Late-constructed game clients must not re-defer: the flag records
       // that play already happened this session — and makes ▶-after-⏸ a
       // RESUME, so `lifecycle.start` fires at most once per mount.
-      const w = window as unknown as { __vgaiIngestPlayed?: boolean };
-      if (w.__vgaiIngestPlayed) return release();
-      w.__vgaiIngestPlayed = true;
+      const w = window as unknown as { __volterIngestPlayed?: boolean };
+      if (w.__volterIngestPlayed) return release();
+      w.__volterIngestPlayed = true;
       lifecycle.start();
       // A mount ends HELD (see `ingestContentTimeForMode`), so the first ▶ is
       // ALSO the release of that hold — same path every later ▶ takes.

package/src/ingest/ingest-render-debug.ts

@@ -72,7 +72,7 @@ import { collectRenderMemory } from '../runtime/dev/render-memory';
 import { createWebGLFrameCapture } from '../runtime/dev/webgl-frame-capture';
 import { pixiRenderingContext } from '../runtime/pixi/render-pass-bracket';
 import type { ObservationDeclaration } from '@volter/editor-project/adapter/adapter-module';
-import type { VgaiGameSystems } from '@volter/editor-project/adapter/ingest/game-contract';
+import type { VolterGameSystems } from '@volter/editor-project/adapter/ingest/game-contract';
 import type { SystemAdapters } from '@volter/editor-project/adapter/system-adapter';
 import type { RenderPassHooks } from '@volter/threejs-runtime/adapter/ingest/scene-capture';
 import type * as THREE from 'three';
@@ -223,7 +223,7 @@ export interface IngestSystemsWiring {
  * accessor-trap for three, the renderer's runners for Pixi).
  */
 export function wireIngestSystems(opts: {
-  readonly contractSystems: VgaiGameSystems | undefined;
+  readonly contractSystems: VolterGameSystems | undefined;
   /**
    * THIS MOUNT'S SURFACE, stated rather than inferred from which runtime is
    * present — the recognized-Phaser/Babylon canvas branch captures neither
@@ -271,8 +271,8 @@ export function wireIngestSystems(opts: {
     'game' in opts ? opts.game : typeof window === 'undefined' ? null : ingestGameRealmWindow(),
   );
   const { adapter: debug, collisions } = mergeDebugAdapters([
-    { label: "the game's own contract (window.vgaiGame.systems)", adapter: contractDebug },
-    { label: "its adapter's observation table (vgai.adapter.ts)", adapter: observationDebug },
+    { label: "the game's own contract (window.volterGame.systems)", adapter: contractDebug },
+    { label: "its adapter's observation table (volter.adapter.ts)", adapter: observationDebug },
   ]);
   const declared = projectContractSystemAdapters(opts.contractSystems, opts.surface);
   const renderDebug = opts.runtime
@@ -284,7 +284,7 @@ export function wireIngestSystems(opts: {
   // (last writer wins), so this is the only place that may install it, and
   // anything needing the game's render pass multiplexes here rather than
   // opening a second seam. The second consumer is the same-frame canvas
-  // snapshot (`ingest-frame-snapshot.ts`) that makes `vgai screenshot` readable
+  // snapshot (`ingest-frame-snapshot.ts`) that makes `volter-game-editor screenshot` readable
   // over a game whose canvas has no `preserveDrawingBuffer`; it costs nothing
   // until armed, and `deliverArmedIngestFrame` no-ops while no source is set —
   // which is the canvas lane's state, because a Pixi ingest is already

package/src/ingest/ingest-siblings.ts

@@ -20,7 +20,7 @@
  *    the exact resolve+mount `module-mode.ts`'s `mountModuleRootRuntime`
  *    proves out, reused via `mountModuleRootRuntime`, but with NONE of that
  *    route's global side effects (no `setActiveAuthoring`/`setActiveSystems`,
- *    no viewport-tab switch, no `__vgaiModule` hook, no play-surface writes).
+ *    no viewport-tab switch, no `__volterModule` hook, no play-surface writes).
  *    Its `SiblingMount.setPaused` (D-B1) is wired straight from the scoped
  *    `GameSession.pause()`/`.resume()` `mountModuleRootRuntime` hands back —
  *    the SAME honest, already-existing capability `play-mode.ts`'s own
@@ -159,7 +159,7 @@ async function mountDefaultReactSibling(
   const Entry = await resolveReactAdapterRootComponent(world, realm);
 
   const layer = document.createElement('div');
-  layer.dataset['vgaiRootSurface'] = 'true';
+  layer.dataset['volterRootSurface'] = 'true';
   styleSiblingLayer(layer, world, 'none');
   gameContainer.appendChild(layer);
 
@@ -241,7 +241,7 @@ async function mountDefaultReactSibling(
  * runtime `module-mode.ts`'s `mountModuleRootRuntime` provides — the exact
  * resolve+mount the primary module route performs, reused here with none
  * of that route's global side effects: no `setActiveAuthoring`/
- * `setActiveSystems`, no viewport-tab switch, no `__vgaiModule` hook, no
+ * `setActiveSystems`, no viewport-tab switch, no `__volterModule` hook, no
  * mount-failure-report clear. Mounts into its OWN layer div (never straight
  * into the shared `gameContainer` the way the primary/single-world routes
  * do) so its internal canvas/DOM stacking never collides with the ingest

package/src/ingest/module-mode.ts

@@ -74,7 +74,7 @@ export function exitModuleMode(): void {
   } catch {
     /* ignore */
   }
-  delete (window as unknown as Record<string, unknown>)['__vgaiModule'];
+  delete (window as unknown as Record<string, unknown>)['__volterModule'];
   editorConsole.log('Module adapter mode stopped', 'adapter');
 }
 
@@ -152,7 +152,7 @@ export async function enterModuleModeFromManifestRoot(
   // Measured from the mounted adapter rather than declared by the route.
   const reach = measureAdapterReach(mounted);
 
-  (window as unknown as Record<string, unknown>)['__vgaiModule'] = {
+  (window as unknown as Record<string, unknown>)['__volterModule'] = {
     worldId: world.id,
     adapterId,
     reach,

package/src/ingest/mount-canvas-ingest-root.ts

@@ -148,10 +148,10 @@ function publishCanvasIngestSystems(
   setActiveSystems(systems);
   editorConsole.log(
     contractSystems
-      ? `canvas ingest: "${gameName}" declares the vgai game contract — ` +
+      ? `canvas ingest: "${gameName}" declares the volter game contract — ` +
           `${contractSystems.commands?.length ?? 0} commands, ` +
           `${contractSystems.state?.length ?? 0} state providers`
-      : `canvas ingest: "${gameName}" declares no vgai game contract — game.commands()/` +
+      : `canvas ingest: "${gameName}" declares no volter game contract — game.commands()/` +
           'game.state() have nothing to answer and will refuse by naming that',
     'ingest',
   );
@@ -361,7 +361,7 @@ function publishStructuralCanvasRuntime(
     'ingest',
   );
 
-  publishIngestHook('__vgaiIngest2D', {
+  publishIngestHook('__volterIngest2D', {
     gameId: sessionId,
     ...ingestHookEvidence(adapter),
     runtime: recognized.runtime,
@@ -481,7 +481,7 @@ async function mountCanvasIngestRootInner(
   // F26: same cold-mount announcement the three adapter makes
   // (ingest-root-adapter.ts) — a pixi game may declare the game contract and
   // defer its session until ▶; games that ignore the flag behave as before.
-  (window as unknown as { __vgaiMountCold?: boolean }).__vgaiMountCold = true;
+  (window as unknown as { __volterMountCold?: boolean }).__volterMountCold = true;
   // THE namespace the game's own modules will resolve `pixi.js` to.
   //
   // `installSceneCapture2D` wraps `Application.prototype.render` on the
@@ -518,7 +518,7 @@ async function mountCanvasIngestRootInner(
       // unfocused editor window).
       preferStructuralRuntime: async () => {
         const realm = ingestGameRealmWindow() as unknown as PhaserRealmLike & BabylonRealmLike;
-        await realm.__vgaiBabylon?.ready;
+        await realm.__volterBabylon?.ready;
         return recognizeStructuralCanvasRuntime(store, realm) !== null;
       },
     });
@@ -578,8 +578,8 @@ async function mountCanvasIngestRootInner(
   const stage = mount.stage as Container;
   // The game's async setup may add display objects after its first captured frame —
   // wait for the stage to settle. `nextPaint()` rather than a bare rAF because
-  // this mount is awaited by `vgai play`: in a hidden tab (every agent-worktree
-  // `vgai edit` opens one — see `after-paint.ts`) no frame ever arrives, so a
+  // this mount is awaited by `volter-game-editor play`: in a hidden tab (every agent-worktree
+  // `volter-game-editor edit` opens one — see `after-paint.ts`) no frame ever arrives, so a
   // bare chain hangs this bounded loop on iteration 1 and play stalls in its
   // boot phase with nothing to report.
   for (let i = 0; i < 90 && (stage.children?.length ?? 0) === 0; i++) {
@@ -776,7 +776,7 @@ async function mountCanvasIngestRootInner(
   // PD-3: the mount stood — but `contract-ready` may only be recorded when the
   // declared promise actually ANSWERED. The three lane's `awaitWorldReady`
   // (`authoring/ingest-root-adapter.ts`) is the precedent: a game that declares
-  // `window.vgaiGame.ready` is awaited exactly once, and a declared signal that
+  // `window.volterGame.ready` is awaited exactly once, and a declared signal that
   // REJECTS does not fail the mount (the frame is already captured) — it
   // degrades to the measured wait, LOUDLY, and the row then reports `measured`,
   // which is the truth about which answer stood. Recording `contract-ready`
@@ -789,7 +789,7 @@ async function mountCanvasIngestRootInner(
       readinessStood = 'declared';
     } catch (err) {
       editorConsole.error(
-        `Ingest game "${game.id}" declared \`window.vgaiGame.ready\` and it REJECTED ` +
+        `Ingest game "${game.id}" declared \`window.volterGame.ready\` and it REJECTED ` +
           `(${String(err)}) — the frame was already captured, so the host fell back to the ` +
           'measured settle wait. This root now reports readiness as measured.',
         'ingest',
@@ -828,7 +828,7 @@ async function mountCanvasIngestRootInner(
     'ingest',
   );
 
-  publishIngestHook('__vgaiIngest2D', {
+  publishIngestHook('__volterIngest2D', {
     gameId: sessionId,
     ...ingestHookEvidence(adapter),
     drawCount: () => mount.capture.getDrawCount(),

package/src/ingest/mount-coverage.ts

@@ -5,7 +5,7 @@
  * Everything here is a measurement or the plumbing of one — the mount-time
  * one-shot probe (the editor capabilities reached),
  * the live re-read of the loop verdict, the once-per-mount
- * console door, and the report the status facet and the `__vgaiIngest` hook
+ * console door, and the report the status facet and the `__volterIngest` hook
  * both serve. Mount PLUMBING lives in the `mount-*-ingest-root.ts` siblings
  * and deliberately not here: a reader asking "what did the editor actually
  * measure about this game, and where does that number come from" should have
@@ -37,7 +37,7 @@ import {
   type ContractSurface,
   projectContractSystemAdapters,
 } from '../runtime/adapter/ingest/contract-system-adapters';
-import type { VgaiGameContract } from '@volter/editor-project/adapter/ingest/game-contract';
+import type { VolterGameContract } from '@volter/editor-project/adapter/ingest/game-contract';
 import type { SystemAdapters } from '@volter/editor-project/adapter/system-adapter';
 import { activeIngest } from './active-ingest';
 import type { IngestMount } from './authoring/ingest-root-adapter';
@@ -163,7 +163,7 @@ export const LOOP_PROBE_ABSENT =
  */
 export function measureSystemAdapters(
   active: SystemAdapters,
-  contract: VgaiGameContract | null,
+  contract: VolterGameContract | null,
   /** The mount's surface when the caller has one — see
    *  `contract-system-adapters.ts`'s header for the one slot it decides
    *  (`physics`, whose vocabulary follows the surface). */

package/src/ingest/mount-dom-ingest-root.ts

@@ -72,7 +72,7 @@ async function mountDomIngestRootInner(store: EditorShellStore, folderId: string
   const projectRoot = ingestGameDomProjectRoot(folderId);
   if (!projectRoot) {
     editorConsole.error(
-      `React ingest "${folderId}": no __VGAI_ENGINE_ROOT__ available to resolve its entry`,
+      `React ingest "${folderId}": no __VOLTER_ENGINE_ROOT__ available to resolve its entry`,
       'ingest',
     );
     return;
@@ -95,7 +95,7 @@ async function mountDomIngestRootInner(store: EditorShellStore, folderId: string
   // F26: same cold-mount announcement as the other ingest routes — the react
   // world's entry executes in the editor realm and may declare the game
   // contract to defer its session until ▶. Opt-in, never demanded.
-  (window as unknown as { __vgaiMountCold?: boolean }).__vgaiMountCold = true;
+  (window as unknown as { __volterMountCold?: boolean }).__volterMountCold = true;
   const { createGameRuntime } = await import('../runtime/create-runtime');
   const specs = await resolveAllRoots(game.manifest, projectRoot);
   const w = gameContainer.clientWidth;
@@ -155,7 +155,7 @@ async function mountDomIngestRootInner(store: EditorShellStore, folderId: string
   const coverage = domMountCoverage(adapter);
   recordMountCoverage(coverage);
 
-  publishIngestHook('__vgaiIngestReact', {
+  publishIngestHook('__volterIngestReact', {
     gameId: folderId,
     worldId: game.worldId,
     ...ingestHookEvidence(adapter),
@@ -169,7 +169,7 @@ async function mountDomIngestRootInner(store: EditorShellStore, folderId: string
     domEvidence: () => reactDomEvidence(root, adapter),
     // D-L1: honest `typeof === 'function'` check on the REAL session
     // control this route just installed above — never an independent
-    // literal `true` (mirrors `__vgaiSiblingMounts`'s identical discipline).
+    // literal `true` (mirrors `__volterSiblingMounts`'s identical discipline).
     setPausedPresent: typeof lifecycle.setPaused === 'function',
   });
 }
@@ -177,7 +177,7 @@ async function mountDomIngestRootInner(store: EditorShellStore, folderId: string
 /**
  * D-Y2 (slice S2) — the manifest-route sibling of {@link mountDomIngestRoot}: an
  * EXTERNAL-FOLDER `ingest-react` world (the opened project's OWN
- * `vgai.project.json`, not the in-tree `ingest/games/<id>` fixture registry)
+ * `volter.project.json`, not the in-tree `ingest/games/<id>` fixture registry)
  * enters the same react ingest session. Exactly the same roots-path recipe
  * (one-element `resolveAllRoots` + roots-path `createGameRuntime`) and the same
  * `DomAuthoringAdapter` D-K4 wiring — only the SOURCE of
@@ -215,7 +215,7 @@ export async function mountDomIngestRootFromManifest(
 
   // F26: same cold-mount announcement the vendored route makes — an
   // external-folder game may declare the game contract too.
-  (window as unknown as { __vgaiMountCold?: boolean }).__vgaiMountCold = true;
+  (window as unknown as { __volterMountCold?: boolean }).__volterMountCold = true;
   const { createGameRuntime } = await import('../runtime/create-runtime');
   const specs = await resolveAllRoots({ ...manifest, roots: [world] }, projectRoot);
   const w = gameContainer.clientWidth;
@@ -260,7 +260,7 @@ export async function mountDomIngestRootFromManifest(
   const coverage = domMountCoverage(adapter);
   recordMountCoverage(coverage);
 
-  publishIngestHook('__vgaiIngestReact', {
+  publishIngestHook('__volterIngestReact', {
     worldId: world.id,
     ...ingestHookEvidence(adapter),
     noAuthoring: false,

package/src/ingest/mount-ingest-root.ts

@@ -173,7 +173,7 @@ registerEditorStateFacet(() => ({
  * mount is attempted (that flag is what swaps the viewport onto the live
  * scene). When the mount then throws, that flag, plus any authoring
  * adapter/adopted scene a partial mount installed, used to survive — so
- * `vgai status` reported `playing`, the hierarchy kept presenting whatever tree
+ * `volter-game-editor status` reported `playing`, the hierarchy kept presenting whatever tree
  * was underneath, and the only trace of the failure was one console line. This
  * is the single teardown every failure path runs: drop the partial session,
  * reset the play surface, and record + broadcast the failure so the status item
@@ -509,7 +509,7 @@ async function tryManifestIngestRoute2D(
  * DOM sibling of {@link tryManifestIngestRoute}/{@link tryManifestIngestRoute2D}
  * (D-Y2, slice S2): a manifest-backed project declaring an `ingest-react` root
  * mounts the native-React ingest session straight from that root (external
- * folder — `vgai edit <folder>` — not the in-tree `ingest/games/<id>` fixture
+ * folder — `volter-game-editor edit <folder>` — not the in-tree `ingest/games/<id>` fixture
  * registry). Same "applied or not" contract, same D-V2 composite scan/
  * route-selection/sibling-mount shape as its three/canvas siblings above.
  */
@@ -689,7 +689,7 @@ async function autoLaunchIngestInner(store: EditorShellStore): Promise<void> {
 // and several of that module's suites run under the Node vitest environment
 // where a bare top-level `window` write is a load-time ReferenceError.
 if (import.meta.env.DEV && typeof window !== 'undefined') {
-  (window as unknown as Record<string, unknown>)['__vgaiIngestApi'] = {
+  (window as unknown as Record<string, unknown>)['__volterIngestApi'] = {
     enter: (gameId: string) => {
       if (!_boundStore) throw new Error('ingest roots not bound');
       return mountThreeIngestRootById(_boundStore, gameId);
@@ -700,7 +700,7 @@ if (import.meta.env.DEV && typeof window !== 'undefined') {
     isActive: () => activeIngest()?.kind === 'three',
   };
   // Canvas sibling (T6.1 slice 4) — same shape, over the canvas ingest session.
-  (window as unknown as Record<string, unknown>)['__vgaiIngestApi2D'] = {
+  (window as unknown as Record<string, unknown>)['__volterIngestApi2D'] = {
     enter: (gameId: string) => {
       if (!_boundStore) throw new Error('ingest roots not bound');
       return mountCanvasIngestRootById(_boundStore, gameId);
@@ -710,7 +710,7 @@ if (import.meta.env.DEV && typeof window !== 'undefined') {
   };
   // DOM sibling (Track N, N2) — same shape, over the native-React ingest
   // session.
-  (window as unknown as Record<string, unknown>)['__vgaiIngestApiReact'] = {
+  (window as unknown as Record<string, unknown>)['__volterIngestApiReact'] = {
     enter: (folderId: string) => {
       if (!_boundStore) throw new Error('ingest roots not bound');
       return mountDomIngestRoot(_boundStore, folderId);
@@ -722,19 +722,19 @@ if (import.meta.env.DEV && typeof window !== 'undefined') {
   // `packages/editor/src/authoring/mount-failure-report.ts`'s multi-entry
   // list is otherwise only ever read by the status bar's `mount-failure`
   // contribution (a React component), invisible to `page.evaluate()`. This is
-  // a plain function returning the LIVE list — `vgai doctor`'s browser
+  // a plain function returning the LIVE list — a probe's browser
   // phase is this surface's first consumer, but any other dev/e2e caller can
-  // poll it the same way `__vgaiIngestApi*` are already polled.
-  (window as unknown as Record<string, unknown>)['__vgaiMountFailureReports'] = () =>
+  // poll it the same way `__volterIngestApi*` are already polled.
+  (window as unknown as Record<string, unknown>)['__volterMountFailureReports'] = () =>
     getMountFailureReports();
   // D-H1 (Slice B): headless-readable per-sibling signal — the live slot's
   // `siblings` (D-V2's composite-sibling handles, `ingest-siblings.ts`'s
   // `SiblingMount[]`) is otherwise invisible to `page.evaluate()`, same blind spot
-  // `__vgaiMountFailureReports` closed for mount failures. A plain function
+  // `__volterMountFailureReports` closed for mount failures. A plain function
   // returning a LIVE view (never a snapshot, re-reads the slot on every call) of
   // honest per-sibling flags only — no capture/draw proof, see
   // `DoctorSiblingEvidence`'s doc comment (`packages/editor/src/doctor/report.ts`).
-  (window as unknown as Record<string, unknown>)['__vgaiSiblingMounts'] = () =>
+  (window as unknown as Record<string, unknown>)['__volterSiblingMounts'] = () =>
     (activeIngest()?.siblings ?? []).map((s) => ({
       worldId: s.worldId,
       setPausedPresent: typeof s.setPaused === 'function',

package/src/ingest/mount-three-ingest-root.ts

@@ -80,7 +80,7 @@ function captureMechanism(via: CaptureMechanism | null): string {
 
 /**
  * Publish a captured three ingest to the whole editor: resize lifecycle,
- * hierarchy/inspector adapter, viewport adoption and the `__vgaiIngest`
+ * hierarchy/inspector adapter, viewport adoption and the `__volterIngest`
  * proof hook.
  */
 function activateCapturedThreeIngest(args: {
@@ -143,7 +143,7 @@ function activateCapturedThreeIngest(args: {
   // physics/input/animation/etc.) → those are correctly N/A while ingested. Only
   // the asset-path remap (done at mount) is a first-party asset-adapter behavior.
   // The ONE exception is earned, never inferred: a game that DECLARES verbs and
-  // state in its contract (`window.vgaiGame.systems`) gets a `debug` adapter
+  // state in its contract (`window.volterGame.systems`) gets a `debug` adapter
   // projected from those declarations by `mountIngestGame`, so `game.commands()`
   // /`game.state()` reach it through the ordinary bridge. A game that declares
   // nothing still lands here with `{}` and the pre-contract floor stands.
@@ -211,7 +211,7 @@ function activateCapturedThreeIngest(args: {
     ...(import.meta.env.DEV ? { adapter: liveAuthoring, store } : {}),
   };
   defineLoopHookFields(hook, mount);
-  publishIngestHook('__vgaiIngest', hook);
+  publishIngestHook('__volterIngest', hook);
 }
 
 async function mountThreeIngestRootInner(
@@ -314,7 +314,7 @@ async function mountThreeIngestRootInner(
  * {@link mountThreeIngestRootFromManifest} builds the descriptor straight from
  * an arbitrary project's manifest instead (the CLI-on-folder route, for a game
  * folder never registered in source) — both end up here. `sessionId` is the
- * id this session is known by — the `__vgaiIngest` dev-hook's reported
+ * id this session is known by — the `__volterIngest` dev-hook's reported
  * `gameId` and the id every log line names; it is always the world/game id
  * (`game.id`), passed explicitly rather than re-read off `game` so the two
  * callers' "id" concept — a fixture's registry-era id vs. a manifest's world
@@ -350,7 +350,7 @@ export async function mountThreeIngestRootById(
 /**
  * Mount straight from a manifest's `ingest-three` world — the CLI-on-folder
  * route (T3.3 slice 3): a game folder never registered in source, whose
- * `vgai.project.json` declares an ingest-three world. Builds the descriptor via
+ * `volter.project.json` declares an ingest-three world. Builds the descriptor via
  * `resolveIngestDescriptor` (ingest/resolve-three.ts — parameterized by the
  * manifest's ingest fields, no registry lookup) and mounts it exactly like any
  * other {@link IngestGame}. The session is known by the world id — the same

package/src/ingest/resolve-three.ts

@@ -32,8 +32,8 @@ import type { IngestGame } from './types';
  *
  *  - A THREE ingest's teardown disposes the R3F root, so a remount MUST
  *    re-evaluate the entry — `remountEpochs: true` gives every `load()` its
- *    own `?vgai-ingest-remount=` buster (see `INGEST_REMOUNT_QUERY` for why
- *    it is deliberately NOT `vgai-mount`, whose realm-keying and subgraph
+ *    own `?volter-ingest-remount=` buster (see `INGEST_REMOUNT_QUERY` for why
+ *    it is deliberately NOT `volter-mount`, whose realm-keying and subgraph
  *    stamping the ingest readers cannot follow; an ingest's `load` IS its
  *    mount). A bare URL made stop → ▶ a NO-OP: browser module identity is
  *    per-URL, the already-evaluated entry's top-level boot did not re-run,

package/src/ingest/served-bundle.ts

@@ -3,13 +3,13 @@
  *
  * `public/ingest/<id>/` holds games vendored as build output rather than as
  * source (CLAUDE.md, "Repo layout"). Those folders carry their own
- * `vgai.project.json`, so `vgai edit public/ingest/<id>` opens them like any
+ * `volter.project.json`, so `volter-game-editor edit public/ingest/<id>` opens them like any
  * other project — and the manifest ingest route then built the entry's import
  * url with `fsImportPath`, i.e. `/@fs/<abs>/…`, putting a file that lives in
  * VITE'S OWN `public/` DIRECTORY into Vite's module graph.
  *
  * That is the one thing Vite refuses outright. Measured on this route
- * (2026-08-20, `vgai edit public/ingest/tanks`, identically for `simcity`):
+ * (2026-08-20, `volter-game-editor edit public/ingest/tanks`, identically for `simcity`):
  *
  *   [vite] Internal Server Error
  *   Cannot import non-asset file /ingest/tanks/three-r170.module.js which is
@@ -27,7 +27,7 @@
  * not stop being served because the door that opened it was a session rather
  * than a `?project=` id, so the LOCAL route resolves the same way: by URL.
  *
- * The `__VGAI_ENGINE_ROOT__` read is the exact inverse of
+ * The `__VOLTER_ENGINE_ROOT__` read is the exact inverse of
  * `imported-gallery.ts`'s `importedProjectPath` (gallery card → absolute folder);
  * this is absolute folder → served URL.
  */
@@ -36,7 +36,7 @@ import { importServedModule } from '../host/browser-transpile';
 import { ensureServedBundleRuntimeModules } from '../host/served-bundle-runtime-modules';
 import { bootDeclaredDocument, declaresClassicEntry, readDeclaredBoot } from './served-html-boot';
 
-declare const __VGAI_ENGINE_ROOT__: string;
+declare const __VOLTER_ENGINE_ROOT__: string;
 
 function withoutTrailingSlash(path: string): string {
   return path.endsWith('/') ? path.slice(0, -1) : path;
@@ -52,8 +52,8 @@ function withoutTrailingSlash(path: string): string {
  * checkout, not about the game.
  */
 export function servedProjectBaseUrl(projectRoot: string): string | undefined {
-  if (typeof __VGAI_ENGINE_ROOT__ !== 'string' || !__VGAI_ENGINE_ROOT__) return undefined;
-  const publicRoot = `${withoutTrailingSlash(__VGAI_ENGINE_ROOT__)}/public/`;
+  if (typeof __VOLTER_ENGINE_ROOT__ !== 'string' || !__VOLTER_ENGINE_ROOT__) return undefined;
+  const publicRoot = `${withoutTrailingSlash(__VOLTER_ENGINE_ROOT__)}/public/`;
   const dir = `${withoutTrailingSlash(projectRoot)}/`;
   if (!dir.startsWith(publicRoot) || dir === publicRoot) return undefined;
   return `/${dir.slice(publicRoot.length)}`;

package/src/ingest/served-html-boot.ts

@@ -166,10 +166,10 @@ export function declaresClassicEntry(boot: DeclaredBoot | null, entryUrl: string
  */
 export async function stageDeclaredDom(boot: DeclaredBoot): Promise<void> {
   const realmDocument = ingestGameRealmWindow().document;
-  realmDocument.querySelector('[data-vgai-declared-dom]')?.remove();
+  realmDocument.querySelector('[data-volter-declared-dom]')?.remove();
   if (boot.bodyHtml.trim().length === 0 && boot.inlineCss.length === 0) return;
   const holder = realmDocument.createElement('div');
-  holder.setAttribute('data-vgai-declared-dom', '');
+  holder.setAttribute('data-volter-declared-dom', '');
   // `pointer-events:none` on the WRAPPER, restored per child: the holder is a
   // host artifact, not part of the game's page, and it blanketed the game's
   // canvas — a Babylon game whose whole UI is in-canvas (space-truckers' GUI
@@ -212,7 +212,7 @@ export async function stageDeclaredDom(boot: DeclaredBoot): Promise<void> {
   for (const staged of holder.querySelectorAll('[id]')) {
     if (surface.id === staged.id) surface.removeAttribute('id');
     for (const stub of surface.querySelectorAll(
-      `[data-vgai-dom-stub][id="${CSS.escape(staged.id)}"]`,
+      `[data-volter-dom-stub][id="${CSS.escape(staged.id)}"]`,
     )) {
       if (stub !== staged) stub.remove();
     }
@@ -278,15 +278,15 @@ export async function bootDeclaredDocument(
   // violation ("trap returned falsish for property 'window'"), so the traps
   // delegate to the captured realm window instead of proxying it.
   const scope =
-    'var __vgaiPristine = new Set(Object.getOwnPropertyNames(globalThis));\n' +
-    '__vgaiPristine.add("__vgaiPristine"); __vgaiPristine.add("__vgaiRealmGlobals");\n' +
-    'var __vgaiRealmGlobals = (function (w) {\n' +
+    'var __volterPristine = new Set(Object.getOwnPropertyNames(globalThis));\n' +
+    '__volterPristine.add("__volterPristine"); __volterPristine.add("__volterRealmGlobals");\n' +
+    'var __volterRealmGlobals = (function (w) {\n' +
     '  return new Proxy({}, {\n' +
-    '    has: function (_, k) { return typeof k === "string" && !__vgaiPristine.has(k) && k in w; },\n' +
+    '    has: function (_, k) { return typeof k === "string" && !__volterPristine.has(k) && k in w; },\n' +
     '    get: function (_, k) { return typeof k === "string" ? w[k] : undefined; },\n' +
     '    set: function (_, k, v) { w[k] = v; return true; },\n' +
     '  });\n' +
     '})(window);\n';
-  const body = `${GAME_GLOBALS_PRELUDE}\n${scope}\nreturn (function(){ with (__vgaiRealmGlobals) {\n${sources.join('\n;\n')}\n} }).call(window);`;
+  const body = `${GAME_GLOBALS_PRELUDE}\n${scope}\nreturn (function(){ with (__volterRealmGlobals) {\n${sources.join('\n;\n')}\n} }).call(window);`;
   gameRealmPage().withCurrentScript(entryUrl, () => new Function(body)());
 }