@volter/editor-game 0.5.68 → 0.5.69

package/src/host/coverage/capability-coverage.ts

@@ -52,7 +52,7 @@ import type {
 } from '@volter/editor-project/adapter';
 import { WRITE_ANCHOR_KINDS } from '@volter/editor-project/adapter';
 import type { AdapterSurface } from '@volter/editor-project/adapter/adapter-surface';
-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 { SYSTEM_ADAPTERS_SHAPE } from '@volter/editor-project/adapter/system-seam-contract';
 import {
@@ -92,7 +92,7 @@ export {
  * gets a row.
  *
  * The rest are contract facts about an ingested game — declarations only a
- * `window.vgaiGame` can make — and they grow with the contract; nothing
+ * `window.volterGame` can make — and they grow with the contract; nothing
  * switches exhaustively on this type, so no consumer breaks when it does.
  */
 export type CapabilityCoverageSeam =
@@ -212,7 +212,7 @@ export interface SystemsPresence {
  * and this file never calls any of them.
  */
 export interface ContractPresence {
-  /** `readGameContract()` answered at all (a v1 `window.vgaiGame`). */
+  /** `readGameContract()` answered at all (a v1 `window.volterGame`). */
   readonly declared: boolean;
   readonly root: boolean;
   readonly start: boolean;
@@ -224,7 +224,7 @@ export interface ContractPresence {
 }
 
 /** Fold a read contract (or its absence) into presence flags. */
-export function measureGameContract(contract: VgaiGameContract | null): ContractPresence {
+export function measureGameContract(contract: VolterGameContract | null): ContractPresence {
   const systems = contract?.systems;
   return {
     declared: contract !== null,
@@ -276,7 +276,7 @@ export interface WriteReachFacts {
    * reads healthy while every one of the 12 belongs to one lane and a whole
    * other lane — a world's physics-placed cargo, or its level-data records —
    * goes unwritten and unexercised. A per-kind tally is what makes an
-   * exhaustive walk possible; `vgai doctor`'s edit-write phase is its reader.
+   * exhaustive walk possible.
    *
    * Optional, because callers older than the vocabulary supply none and a
    * fabricated zero for every kind would read as a measurement.
@@ -307,7 +307,7 @@ export interface DataWriterFacts {
  *    actually holds an adapter for this slot. That is the strongest available
  *    statement: it is the same object the editor's panels will call.
  *  - `empty` — the game POSITIVELY answered "I have no X" through
- *    `window.vgaiGame.systems.systemAdapters` (`evidence` is its own words).
+ *    `window.volterGame.systems.systemAdapters` (`evidence` is its own words).
  *  - `malformed` — a declaration that could not be honoured; `evidence` is the
  *    projection's reason. Reported so a broken shim is loud, never silently
  *    read as either of the two terminal states.
@@ -327,7 +327,7 @@ export interface SystemAdapterMeasurement {
    * shared default would state wrongly.
    *
    * This is what keeps the derivation provenance-NEUTRAL. The default fix text
-   * below names `window.vgaiGame.systems…`, which is true of a game that
+   * below names `window.volterGame.systems…`, which is true of a game that
    * declares a contract and false of a first-party one; rather than have the
    * row builder ask WHO produced the measurement, the measurement carries the
    * answer as a fact (`coverage/system-adapter-coverage.ts` supplies it for a
@@ -474,7 +474,7 @@ type ResolvedCoverageFacts = Required<CapabilityCoverageFacts>;
 
 /**
  * The route for a game whose bytes may not be touched — which is EVERY
- * repo-vendored ingest, by doctrine. "Declare `window.vgaiGame.root`" is the
+ * repo-vendored ingest, by doctrine. "Declare `window.volterGame.root`" is the
  * mechanism, but a game nobody may edit cannot declare anything, so a fix that
  * stopped there would be telling the reader to do something they are not
  * allowed to do. Both host-side carriers now exist, so this names them and
@@ -483,8 +483,8 @@ type ResolvedCoverageFacts = Required<CapabilityCoverageFacts>;
 const UNMODIFIABLE_ROUTE =
   'a game whose bytes must stay unmodified declares it from a host-side carrier ' +
   'instead — a contract shim beside the game (`ingest.contractShim` in its ' +
-  'vgai.project.json, injected ahead of the game`s entry module; see ' +
-  'public/ingest/simcity/vgai.shim.js) or a recorded patch';
+  'volter.project.json, injected ahead of the game`s entry module; see ' +
+  'public/ingest/simcity/volter.shim.js) or a recorded patch';
 
 const CONTRACT_FIX = (endpoint: string): string =>
   `declare ${endpoint} in the game's own entry; ${UNMODIFIABLE_ROUTE}`;
@@ -656,7 +656,7 @@ function loopRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
       missing:
         "nothing in this editor controls the game's frames: ▶/⏸ and Step do not stop it, and " +
         'Edit mode cannot be quiet — it keeps simulating while you author',
-      fix: CONTRACT_FIX('window.vgaiGame.lifecycle.pause + resume'),
+      fix: CONTRACT_FIX('window.volterGame.lifecycle.pause + resume'),
     };
   }
   // No verdict, and that is its own answer — never a gap. The caller supplies
@@ -681,7 +681,7 @@ function contractRootRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
         detail: `the game declares a root, but the seam failed — ${facts.contract.proof.root.detail}`,
         missing:
           'the host cannot trust that the declared element owns the game DOM rather than an unrelated or detached subtree',
-        fix: CONTRACT_FIX('window.vgaiGame.root'),
+        fix: CONTRACT_FIX('window.volterGame.root'),
       };
     }
     return {
@@ -703,7 +703,7 @@ function contractRootRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
       'the host adopts the bare canvas, so any DOM this game owns beside it (HUD, overlays, ' +
       'portals) is stranded at page level over the editor chrome instead of living in the ' +
       'game pane',
-    fix: CONTRACT_FIX('window.vgaiGame.root'),
+    fix: CONTRACT_FIX('window.volterGame.root'),
   };
 }
 
@@ -716,7 +716,7 @@ function contractStartRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
         detail: `lifecycle.start is declared but failed — ${facts.contract.proof.start.detail}`,
         missing:
           'the mount cannot prove it starts cold and enters a session only when Play requests one',
-        fix: CONTRACT_FIX('window.vgaiGame.lifecycle.start'),
+        fix: CONTRACT_FIX('window.volterGame.lifecycle.start'),
       };
     }
     return {
@@ -738,7 +738,7 @@ function contractStartRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
       'the mount cannot be COLD: this game runs its session side-effects (backend ' +
       'connections, audio, narrative) as it loads, so opening it in the editor starts ' +
       'playing it, and ▶ is a wire event the game may ignore',
-    fix: CONTRACT_FIX('window.vgaiGame.lifecycle.start'),
+    fix: CONTRACT_FIX('window.volterGame.lifecycle.start'),
   };
 }
 
@@ -792,7 +792,7 @@ function contractPauseRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
         status: 'gap',
         detail: `pause/resume is declared but failed — ${failed.detail}`,
         missing: pauseFallbackCost(facts),
-        fix: CONTRACT_FIX('window.vgaiGame.lifecycle.pause + resume'),
+        fix: CONTRACT_FIX('window.volterGame.lifecycle.pause + resume'),
       };
     }
     return {
@@ -814,7 +814,7 @@ function contractPauseRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
         ? 'a contract is declared, but it names no lifecycle.pause/resume'
         : 'no game→host contract is declared at all',
     missing: pauseFallbackCost(facts),
-    fix: CONTRACT_FIX('window.vgaiGame.lifecycle.pause + resume'),
+    fix: CONTRACT_FIX('window.volterGame.lifecycle.pause + resume'),
   };
 }
 
@@ -989,7 +989,7 @@ function systemsRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
         detail: `the systems carrier is declared but failed — ${facts.contract.proof.systems.detail}`,
         missing:
           '`game.commands()` / `game.providers()` cannot safely enumerate or invoke this carrier',
-        fix: CONTRACT_FIX('window.vgaiGame.systems (commands + state)'),
+        fix: CONTRACT_FIX('window.volterGame.systems (commands + state)'),
       };
     }
     return {
@@ -1013,7 +1013,7 @@ function systemsRow(facts: ResolvedCoverageFacts): CapabilityCoverageRow {
       'this game exposes no verbs and no state to drive or read it with: `game.commands()` and ' +
       '`game.providers()` enumerate nothing, so there is no `game.command(...)` to play it from ' +
       `${commandLine('eval')} and no \`game.state(...)\` for ${commandLine('status')} to see anything of what it is doing`,
-    fix: CONTRACT_FIX('window.vgaiGame.systems (commands + state)'),
+    fix: CONTRACT_FIX('window.volterGame.systems (commands + state)'),
   };
 }
 
@@ -1063,9 +1063,9 @@ function systemSlotFix(slot: SystemAdapterSlot): string {
     );
   }
   if (slot === 'debug') {
-    return CONTRACT_FIX('window.vgaiGame.systems (commands + state)');
+    return CONTRACT_FIX('window.volterGame.systems (commands + state)');
   }
-  return CONTRACT_FIX(`window.vgaiGame.systems.systemAdapters.${slot}`);
+  return CONTRACT_FIX(`window.volterGame.systems.systemAdapters.${slot}`);
 }
 
 /**
@@ -1571,7 +1571,7 @@ export function formatCapabilityCoverageBlocks(
  * The console door, ONCE PER MOUNT.
  *
  * The report is derived on demand (the status facet re-derives it on every
- * read, so `vgai status` never serves a verdict older than the question), which
+ * read, so `volter-game-editor status` never serves a verdict older than the question), which
  * makes "print it" a thing that could happen many times — per status poll, per
  * re-render, in the limit per frame. The guard is a mount token: the same
  * mount's report is emitted once and then never again, and a NEW mount emits

package/src/host/coverage/game-contract-seam-evidence.ts

@@ -7,9 +7,9 @@ import {
   type SeamEvidenceVerdict,
 } from '@volter/editor-project/adapter';
 import type {
-  VgaiGameContract,
-  VgaiGameLifecycle,
-  VgaiGameSystems,
+  VolterGameContract,
+  VolterGameLifecycle,
+  VolterGameSystems,
 } from '@volter/editor-project/adapter/ingest/game-contract';
 import {
   GAME_CONTRACT_SHAPE,
@@ -21,7 +21,7 @@ import { liveSeamEvidence } from '@volter/editor-sdk/kit/live-seam-evidence';
 const EPOCHS = new WeakMap<object, string>();
 let nextEpoch = 1;
 
-export function gameContractEpoch(contract: VgaiGameContract): string {
+export function gameContractEpoch(contract: VolterGameContract): string {
   const found = EPOCHS.get(contract);
   if (found) return found;
   const epoch = `contract-${nextEpoch++}`;
@@ -38,7 +38,7 @@ export interface GameContractEvidence {
 }
 
 export function inspectGameContractSeams(options: {
-  readonly contract: VgaiGameContract;
+  readonly contract: VolterGameContract;
   readonly subject?: string | undefined;
   readonly epoch?: string | undefined;
   readonly receipts?: readonly SeamEvidenceReceipt[] | undefined;
@@ -46,21 +46,21 @@ export function inspectGameContractSeams(options: {
   const subject = options.subject ?? 'game';
   const epoch = options.epoch ?? gameContractEpoch(options.contract);
   const receipts: SeamEvidenceReceipt[] = [
-    ...inspectSeamShape<VgaiGameContract>({
+    ...inspectSeamShape<VolterGameContract>({
       prefix: 'contract',
       value: options.contract,
       shape: GAME_CONTRACT_SHAPE,
       subject,
       epoch,
     }),
-    ...inspectSeamShape<VgaiGameLifecycle>({
+    ...inspectSeamShape<VolterGameLifecycle>({
       prefix: 'contract.lifecycle',
       value: options.contract.lifecycle,
       shape: GAME_LIFECYCLE_SHAPE,
       subject,
       epoch,
     }),
-    ...inspectSeamShape<VgaiGameSystems>({
+    ...inspectSeamShape<VolterGameSystems>({
       prefix: 'contract.systems',
       value: options.contract.systems,
       shape: GAME_SYSTEMS_SHAPE,

package/src/host/coverage/project-verb-coverage.ts

@@ -22,7 +22,7 @@
  * something the product itself already acts on:
  *
  *  - `export` reads what the export path ACTUALLY requires of a project, taken
- *    from the door's own source: `create-vgai-project/src/deploy.ts` runs
+ *    from the door's own source: `create-volter-project/src/deploy.ts` runs
  *    `npm run build` in the project (`runProjectBuild`) and stages the `dist/`
  *    that emits (`stageBuildOutput`). Ingest roots pass that door because the
  *    ingest project's own build is already its standalone game; arbitrary

package/src/host/coverage/system-adapter-coverage.ts

@@ -8,7 +8,7 @@
  * `editor.*` family — every mounted root, native or ingested, gets a row per
  * `AuthoringAdapter` provider. It deliberately keeps ONLY that family, on the
  * grounds that the remaining facts are "the ingested lane's own questions".
- * That is true of `contract.*` (a native game declares no `window.vgaiGame`
+ * That is true of `contract.*` (a native game declares no `window.volterGame`
  * and never will) and false of `system.*`: a `SystemAdapters` slot is read off
  * the editor's OWN live registry (`authoring/active-systems.ts`), which a
  * native game fills exactly as an ingested one does. So the slots went
@@ -31,7 +31,7 @@
  * `networking` is the exception, and it is the whole point. Nothing engine-side
  * builds it: a game registers a `NetworkingAdapter` itself. So its absence is
  * ruled out only by the PROJECT'S OWN FILE — no `server` block in
- * `vgai.project.json` means there is no room to describe. A game that DOES
+ * `volter.project.json` means there is no room to describe. A game that DOES
  * declare a room and binds nothing is `unanswered`, i.e. a standing warning.
  *
  * ## Provenance neutrality
@@ -59,7 +59,7 @@ import { inspectSystemAdapterSeam } from '@volter/editor-sdk/kit/system-seam-evi
  *  it. Both facts are read off things that already exist; neither is a guess. */
 export interface NativeProjectFacts {
   /**
-   * `vgai.project.json` declares a `server` block (a Colyseus room) — read from
+   * `volter.project.json` declares a `server` block (a Colyseus room) — read from
    * the active project view (`project-manager.ts`'s `ActiveProject.server`).
    * The decisive project-level declaration for whether this game is networked.
    */
@@ -118,7 +118,7 @@ export interface NativeProjectFacts {
  */
 const SLOT_LIBRARIES: Partial<Record<SystemAdapterSlot, readonly string[]>> = {
   physics: ['@react-three/rapier', '@dimforge/rapier3d-compat', '@dimforge/rapier2d-compat'],
-  networking: ['colyseus.js'],
+  networking: ['@colyseus/sdk', 'colyseus.js'],
   navigation: ['recast-navigation', '@recast-navigation/core'],
   audio: ['tone', 'howler'],
 };
@@ -213,7 +213,7 @@ function reasonAcknowledges(reason: string, library: string): boolean {
 
 /** The file fact that rules `networking` out, in the file's own terms. */
 const NO_SERVER_EVIDENCE =
-  "this project's vgai.project.json declares no `server` block, so there is no room for a " +
+  "this project's volter.project.json declares no `server` block, so there is no room for a " +
   'NetworkingAdapter to describe';
 
 /**
@@ -251,7 +251,7 @@ const ENGINE_OWNED_EVIDENCE: Partial<Record<SystemAdapterSlot, string>> = {
 };
 
 /** The fix a native game's author can actually act on, per slot. Never the
- *  ingested lane's `window.vgaiGame` text, which would be false here. */
+ *  ingested lane's `window.volterGame` text, which would be false here. */
 function nativeSlotFix(slot: SystemAdapterSlot, facts: NativeProjectFacts): string {
   if (!facts.mounted) {
     return 'nothing is mounted, so the live system registry has not been asked yet — enter Play, or open a project whose roots mount, and the slot reports its real state';
@@ -349,6 +349,19 @@ export function measureNativeSystemAdapters(
             : `declared absent by root "${absence.rootId}": ${absence.reason}${lastMountNote}`,
       };
     }
+    // A Colyseus client is the editor's to observe: Play binds its observer of the game's room
+    // sockets (`adapter-runtime-bindings.ts`'s `withObservedNetworking`), so an unbound slot while
+    // nothing plays is that observer not yet attached, not an adapter the game owes.
+    if (slot === 'networking' && libraries.length > 0) {
+      return {
+        slot,
+        state: 'empty',
+        attestedBy: 'host',
+        evidence:
+          `this project ships ${libraries.join(' + ')}; the editor observes its room sockets from ` +
+          'Play, and nothing is connected while editing',
+      };
+    }
     // Nothing declared, and the library IS here: the host's inference below
     // would print a confident absence over real evidence to the contrary. That
     // is an UNANSWERED question — the only state that is a work order — not a

package/src/host/game-location-guard.ts

@@ -9,14 +9,14 @@
  * ordinary game code and there is no cooperative way for a game to know better.
  *
  * So the game realm's `location` is a facade: reads of the game's own
- * query keep working, host control-plane keys (`play`, `project`, `vgai-*`,
+ * query keep working, host control-plane keys (`play`, `project`, `volter-*`,
  * …) are stripped from `search`/`href` (bubbo's `getUrlParam('play')` is a
  * debug skip-to-Game; the editor's `?play=1` autoplay is not that flag),
  * and every write that would NAVIGATE is refused with a `console.error`
  * naming the game, the exact assignment, and this mechanism. Refused, never
  * swallowed — a silent no-op would make "the quit button does nothing" an
  * unexplainable bug, and the console line is a real product door
- * (`vgai status` reports page console errors).
+ * (`volter-game-editor status` reports page console errors).
  *
  * `hash` is deliberately NOT refused: it changes the URL without leaving the
  * document, and games use it for their own state.
@@ -49,7 +49,7 @@ const HOST_SEARCH_KEYS = new Set([
 ]);
 
 function isHostSearchKey(key: string): boolean {
-  return HOST_SEARCH_KEYS.has(key) || key.startsWith('vgai');
+  return HOST_SEARCH_KEYS.has(key) || key.startsWith('volter');
 }
 
 /** The search string a game is allowed to read — host keys removed. */

package/src/host/game-module-access.ts

@@ -1,10 +1,10 @@
 import { commandLine } from '@volter/editor-sdk/kit/product-command';
 /**
- * THE MODULE LANE of `vgai eval` — reach the RUNNING mount's own module
+ * THE MODULE LANE of `volter-game-editor eval` — reach the RUNNING mount's own module
  * instances, by served path, using URLs retained by their owning realm.
  *
  * WHY THE MOUNT STAMP IS LOAD-BEARING. Project modules are served per mount
- * as `/<path>?vgai-mount=<id>` (`project-module-instance.ts` propagates the
+ * as `/<path>?volter-mount=<id>` (`project-module-instance.ts` propagates the
  * id through the whole project subtree), so browser module identity is
  * per-instance BY URL. A bare `import('/src/sim/host.ts')` therefore loads a
  * SECOND, never-ticked copy — the phantom-module trap the old string-command
@@ -25,15 +25,15 @@ import { commandLine } from '@volter/editor-sdk/kit/product-command';
 // with a guard test on the one true owner.
 /** Mirrors `project-module-url.ts`'s PROJECT_MOUNT_QUERY (guarded by test —
  *  the two must never drift). */
-const PROJECT_MOUNT_QUERY = 'vgai-mount';
+const PROJECT_MOUNT_QUERY = 'volter-mount';
 
 let focusedInstanceProvider: (() => string) | null = null;
 /** The packaged shell and source-served contributions share the host realm owner. */
 function moduleUrls(instanceId: string): readonly string[] {
   const host = globalThis as typeof globalThis & {
-    __vgaiGameModuleUrls?: (id: string) => readonly string[];
+    __volterGameModuleUrls?: (id: string) => readonly string[];
   };
-  return host.__vgaiGameModuleUrls?.(instanceId) ?? [];
+  return host.__volterGameModuleUrls?.(instanceId) ?? [];
 }
 
 /** Wired once by the editor shell (`command-listener.ts`) at boot. */
@@ -76,7 +76,7 @@ export function loadedGameModulePaths(instanceId: string): string[] {
 }
 
 /**
- * The `modules` binding of `vgai eval`'s `game.run` scope and of the
+ * The `modules` binding of `volter-game-editor eval`'s `game.run` scope and of the
  * `game-eval` op — a RESOLVER, `modules('src/sim/host.ts')`, that also
  * ENUMERATES what it can resolve.
  *

package/src/host/game-realm-page.ts

@@ -70,7 +70,7 @@ function captureOf(options?: boolean | AddEventListenerOptions | EventListenerOp
 
 /** Mark carrying the text this observer last wrote, so its own write is not
  *  re-scoped and a game's next rewrite is. */
-export const SCOPED_STYLE_MARK = 'vgaiScopedCss';
+export const SCOPED_STYLE_MARK = 'volterScopedCss';
 
 /**
  * The `@scope` rewriter, loaded on FIRST USE — the one page-side door to the
@@ -128,7 +128,7 @@ export function loadGameCssScoper(): Promise<(css: string) => string> {
  * `url.fileURLToPath/pathToFileURL`,
  * `source-map-js.SourceMapConsumer/SourceMapGenerator` — straight into the
  * game realm's console, which made the console-silence contract unreachable in
- * a fresh scaffold and every `vgai` verb exit non-zero (measured three times:
+ * a fresh scaffold and every `volter` verb exit non-zero (measured three times:
  * the donut, cold-barrel and lit-lanes probes). The chain was
  * `play-mode.enterPlayModeInner` -> `gated-globals.setGameSurface` ->
  * `GameRealmPage.surface` -> `observeInjectedStyles` -> `import('../server/
@@ -356,7 +356,7 @@ export class GameRealmPage {
     if (!surface) return null;
     if (!this.headElement || this.headElement.parentElement !== surface) {
       const head = document.createElement('div');
-      head.dataset['vgaiGameHead'] = '';
+      head.dataset['volterGameHead'] = '';
       head.hidden = true;
       surface.prepend(head);
       this.headElement = head;

package/src/host/game-realm-reclaim.ts

@@ -26,7 +26,7 @@ import { disposeGameRealm } from './gated-globals';
  *
  * The report is the point: a game that released everything it registered is
  * silent, and a game that did not is named, with the count, on the editor
- * console (and therefore in `vgai console`). The editor reclaims either way.
+ * console (and therefore in `volter-game-editor console`). The editor reclaims either way.
  */
 export function reclaimGameRealm(id: string, name: string): void {
   const released = disposeGameRealm(id);

package/src/host/gameplay-recording.ts

@@ -1,6 +1,6 @@
 /**
  * Live gameplay recording over the SAME clean game compositor used by
- * `vgai screenshot`: world canvases + DOM HUD, no editor chrome.
+ * `volter-game-editor screenshot`: world canvases + DOM HUD, no editor chrome.
  *
  * This is intentionally a browser primitive, not a CLI workflow. The page
  * owns `MediaRecorder` and the live pixels/audio, streams bounded chunks to
@@ -21,7 +21,7 @@
  * A counter for it was written, shipped and REMOVED in the same afternoon: it
  * keyed on `domOverlays === 0` and therefore reported a clean zero over clips
  * visibly missing their HUD. A measurement that can only ever say "fine" is
- * worse than none, so the limit is stated — here, and in the ack `vgai stop`
+ * worse than none, so the limit is stated — here, and in the ack `volter-game-editor stop`
  * prints — rather than counted. Read the world layer as complete evidence and
  * the HUD as present-when-present.
  */
@@ -62,7 +62,7 @@ export interface GameplayRecordingStartOptions {
   readonly canvasFrame?: CaptureOptions['canvasFrame'];
   readonly audio?: AudioRecordingHandle | null | undefined;
   /**
-   * The file this recording lands in, under the project's `.vgai/recordings/`.
+   * The file this recording lands in, under the project's `.volter/recordings/`.
    * During Play, absent is named after the Gameplay Session; outside one it
    * falls back to `play-latest.webm`. A name is the caller's own keepsake. The server owns the literals — see
    * `editor-server.ts`'s `/__editor/recording/start`.
@@ -211,7 +211,7 @@ interface FrameClock {
  * `setInterval` on the page is the obvious pacer and it is the wrong one for
  * the case this recorder exists to serve. Chrome clamps a background tab's
  * timers to 1 Hz, and to roughly 1/min once the tab has been hidden for five
- * minutes — and an agent's `vgai edit` tab is hidden BY DESIGN (worktree
+ * minutes — and an agent's `volter-game-editor edit` tab is hidden BY DESIGN (worktree
  * sessions open behind the human's window; see `after-paint.ts` for the same
  * fact stated for rAF). A 30 fps request would encode as a handful of frames.
  *
@@ -370,7 +370,7 @@ function samplePreviewFrame(recording: ActiveRecording, mediaTimeMs: number): vo
  *
  * The refusal this replaced ("show the editor tab, then start recording")
  * exempted exactly the sessions the recorder exists for: an agent's
- * `vgai edit` tab opens behind the human's window and stays hidden for the
+ * `volter-game-editor edit` tab opens behind the human's window and stays hidden for the
  * whole run, so every unattended playthrough — the ones with no human to
  * describe what happened — would have produced no evidence at all. What a
  * hidden tab actually costs is two things, and both are handled rather than

package/src/host/gated-globals.ts

@@ -248,7 +248,7 @@ function realmFunction(value: unknown, receiver: object): unknown {
  * one pauses its siblings. Neither is fixable in the presentation layer.
  *
  * The lookup key comes from the MODULE'S OWN URL: every project module served
- * under a mount carries `?vgai-mount=<id>` (the isolation transform), and the
+ * under a mount carries `?volter-mount=<id>` (the isolation transform), and the
  * prelude passes `import.meta.url` to {@link gameRealmForModuleUrl}. So a
  * module resolves its own realm with no plugin involvement and no threading.
  */
@@ -402,7 +402,7 @@ export function gameSurfaces(): { surface: HTMLElement; gate: () => boolean }[]
  */
 function gateFor(id: string): () => boolean {
   // AND THE SURFACE TERM (U2). `surfaceHoldsKeyboard()` is true standalone and
-  // under the frame is the workbench's own "is the vgai pane the active
+  // under the frame is the workbench's own "is the volter pane the active
   // editor?", so a keystroke aimed at Monaco in the group beside a running
   // game never reaches the game's listeners. It is read HERE, once, rather
   // than folded into each lane's own predicate, because this is the one place
@@ -434,7 +434,7 @@ function realmGenerationGate(id: string, live: RealmLiveness): () => boolean {
 function mountIdOfUrl(moduleUrl: string): string {
   const query = moduleUrl.split('?')[1];
   if (query === undefined) return DEFAULT_REALM_ID;
-  return new URLSearchParams(query).get('vgai-mount') ?? DEFAULT_REALM_ID;
+  return new URLSearchParams(query).get('volter-mount') ?? DEFAULT_REALM_ID;
 }
 
 /** The realm whose code is synchronously executing right now. Console capture
@@ -865,12 +865,12 @@ export function makeGatedProxy<T extends EventTarget>(
   };
 
   /** Report a refused navigation on the page's own console — which is a real
-   *  product door: `vgai status` reports page console errors. */
+   *  product door: `volter-game-editor status` reports page console errors. */
   const refuseNavigation = (attempt: string): void => {
     // A NEW native console.error site, suppressed to keep this task's diff at
     // zero new lint warnings — and it is deliberately native rather than
     // `editorConsole`: game code runs in the page, and the page console is the
-    // surface `vgai status` already reads (same reasoning as
+    // surface `volter-game-editor status` already reads (same reasoning as
     // `ingest-root-adapter.ts`'s loop-gate warning).
     // biome-ignore lint/suspicious/noConsole: see comment above
     console.error(refusedNavigationMessage(attempt));
@@ -1115,9 +1115,9 @@ function createOwnedRealmProxy<T extends EventTarget>(
     if (refusalReported) return;
     refusalReported = true;
     const realm = options.realmId ? `"${options.realmId}"` : 'the default realm';
-    // biome-ignore lint/suspicious/noConsole: game code runs in the page, and the page console is the surface `vgai status` reads (same reasoning as `refuseNavigation` above)
+    // biome-ignore lint/suspicious/noConsole: game code runs in the page, and the page console is the surface `volter-game-editor status` reads (same reasoning as `refuseNavigation` above)
     console.warn(
-      `vgai: a stopped game tried to register ${what} on its ${options.role} after its realm ` +
+      `volter: a stopped game tried to register ${what} on its ${options.role} after its realm ` +
         `(${realm}) was reclaimed; refused. Later refusals in this generation are silent.`,
     );
   };
@@ -1460,10 +1460,10 @@ function publishDefaultRealmGlobals(): void {
   const g = globalThis as unknown as Record<string, unknown>;
   const base = gameRealmForMountId();
   loopGate = defaultLoopGate;
-  g['__vgaiGameTimers'] = base.timers;
-  g['__vgaiGameWindow'] = base.window;
-  g['__vgaiGameDocument'] = base.document;
-  g['__vgaiGameConsole'] = base.console;
+  g['__volterGameTimers'] = base.timers;
+  g['__volterGameWindow'] = base.window;
+  g['__volterGameDocument'] = base.document;
+  g['__volterGameConsole'] = base.console;
 }
 
 /**
@@ -1494,8 +1494,8 @@ export function installGatedGameGlobals(): void {
   // The microtask pop bounds the window: it runs when the current synchronous
   // evaluation chunk yields, before the mount's own import().then
   // continuation (queued later) can run editor code.
-  g['__vgaiGameModuleUrls'] = loadedGameRealmModuleUrls;
-  g['__vgaiGameRealm'] = (mountId: string): GameRealm => {
+  g['__volterGameModuleUrls'] = loadedGameRealmModuleUrls;
+  g['__volterGameRealm'] = (mountId: string): GameRealm => {
     executingRealms.push(mountId);
     queueMicrotask(() => {
       const at = executingRealms.lastIndexOf(mountId);

package/src/host/ingest/registry.ts

@@ -47,7 +47,7 @@ import type { ResolvedAdapter, ResolvedAdapterRoot } from '@volter/editor-projec
 import { loadGameManifest, type ResolvedGameManifest } from '@volter/editor-project/manifest/load';
 
 /** The one manifest glob. Every in-tree ingest fixture, whatever its surface. */
-const manifestModules = import.meta.glob('./games/*/vgai.project.json', {
+const manifestModules = import.meta.glob('./games/*/volter.project.json', {
   eager: true,
   import: 'default',
 }) as Record<string, unknown>;
@@ -58,7 +58,7 @@ const manifestModules = import.meta.glob('./games/*/vgai.project.json', {
  * the editor's realm. `.d.ts` is excluded: an ambient declaration file
  * is not a module and must never become a dynamic-import chunk.
  *
- * `vgai.adapter.ts` is excluded too, and for a different reason: it is not a
+ * `volter.adapter.ts` is excluded too, and for a different reason: it is not a
  * GAME module at all. It is host-realm DECLARATION (see {@link adapterModules}),
  * read without booting anything, and a manifest that named it as an `entry` or
  * a `contractShim` would be nonsense — so it is not in the set those fields
@@ -68,15 +68,15 @@ export const entryModules = import.meta.glob([
   './games/*/*.js',
   './games/*/*.ts',
   '!./games/*/*.d.ts',
-  '!./games/*/vgai.adapter.ts',
+  '!./games/*/volter.adapter.ts',
 ]) as Record<string, () => Promise<unknown>>;
 
 /**
- * THE ADAPTER GLOB — one `vgai.adapter.ts` per ingest game, keyed by game id.
+ * THE ADAPTER GLOB — one `volter.adapter.ts` per ingest game, keyed by game id.
  *
  * ARCHITECTURE-CORE §The editor protocol: "Placement follows REALM: game-realm
  * code (a shim that runs inside the game) lives with the game's bundle;
- * host-realm declaration (`vgai.adapter.ts`) lives where the host can import it
+ * host-realm declaration (`volter.adapter.ts`) lives where the host can import it
  * as a real module — a repo-vendored bundle's adapter file lives in the host's
  * in-tree registry, never inside the verbatim-served bundle." This directory IS
  * that registry, so it holds BOTH populations:
@@ -86,7 +86,7 @@ export const entryModules = import.meta.glob([
  *     its bytes are served verbatim from `public/ingest/<id>/` and hashed by
  *     `vendor/games/verify-unaltered.mjs`, so nothing host-owned may go there.
  *
- * A folder with no `vgai.project.json` is invisible to {@link manifestModules}
+ * A folder with no `volter.project.json` is invisible to {@link manifestModules}
  * and therefore to {@link discoverIngestEntries} — the second population adds no
  * fixtures, only declarations.
  *
@@ -98,18 +98,18 @@ export const entryModules = import.meta.glob([
  * be used to fix that file"). Vite resolves the glob statically in dev and in
  * a production build alike, so no generated dispatch table is needed.
  */
-const adapterModules = import.meta.glob('./games/*/vgai.adapter.ts') as Record<
+const adapterModules = import.meta.glob('./games/*/volter.adapter.ts') as Record<
   string,
   () => Promise<unknown>
 >;
 
 /** The adapter module's filename — the contract's ONE spelling, host side. */
-const ADAPTER_FILENAME = 'vgai.adapter.ts';
+const ADAPTER_FILENAME = 'volter.adapter.ts';
 
 /** This directory's repo path, so a published `modulePath` names a real file. */
 const REGISTRY_REPO_DIR = 'packages/editor/src/ingest/games';
 
-const ADAPTER_KEY_RE = /^\.\/games\/([^/]+)\/vgai\.adapter\.ts$/;
+const ADAPTER_KEY_RE = /^\.\/games\/([^/]+)\/volter\.adapter\.ts$/;
 
 /**
  * THE LOOKUP KEY IS THE GAME ID; THE STORAGE KEY IS THE FOLDER NAME. What makes
@@ -124,8 +124,8 @@ const ADAPTER_KEY_RE = /^\.\/games\/([^/]+)\/vgai\.adapter\.ts$/;
  *
  * The invariant is therefore `folder id === the id that game's manifest
  * declares`, for BOTH populations this registry serves — in-tree fixtures
- * (`./games/<id>/vgai.project.json`) and public bundles
- * (`public/ingest/<id>/vgai.project.json`, whose registry folder holds only the
+ * (`./games/<id>/volter.project.json`) and public bundles
+ * (`public/ingest/<id>/volter.project.json`, whose registry folder holds only the
  * adapter file). It is guarded ONCE, statically, in
  * `packages/editor/test/ingest-adapter-modules.test.ts`, which reads both id
  * spaces off disk — the only realm that can, since `public/` is outside the
@@ -167,7 +167,7 @@ export const assetUrls = import.meta.glob('./games/*/assets/**', {
   import: 'default',
 }) as Record<string, string>;
 
-const MANIFEST_KEY_RE = /^\.\/games\/([^/]+)\/vgai\.project\.json$/;
+const MANIFEST_KEY_RE = /^\.\/games\/([^/]+)\/volter\.project\.json$/;
 
 /** Folder-relative glob key for a file inside a discovered game's folder. */
 export function gameFileKey(folderId: string, relPath: string): string {
@@ -206,14 +206,14 @@ function buildEntry(folderId: string, raw: unknown): IngestEntry {
   const roots = declaredRoots(manifest);
   if (roots.length !== 1) {
     throw new Error(
-      `ingest registry: "${folderId}/vgai.project.json" must declare exactly one root ` +
+      `ingest registry: "${folderId}/volter.project.json" must declare exactly one root ` +
         `(found ${roots.length}).`,
     );
   }
   const root = roots[0]!;
   if (root.adapter.type !== 'ingest') {
     throw new Error(
-      `ingest registry: "${folderId}/vgai.project.json"'s root must be an { ingest } root ` +
+      `ingest registry: "${folderId}/volter.project.json"'s root must be an { ingest } root ` +
         `(found adapter identity "${root.adapter.identity}").`,
     );
   }