@volter/editor-game 0.5.67 → 0.5.69

package/NOTICE

@@ -1,15 +1,15 @@
 Copyright 2026 Volter AI, Inc.
 
-The files in this package were imported from volter-ai/vgai-engine at commit
+The files in this package were imported from volter-ai/volter-engine at commit
 09c2749ce. LICENSE contains the AGPL-3.0-only license they retain.
 
-  packages/game/src, packages/game/contributions (@vgai/game)
+  packages/game/src, packages/game/contributions
     -> src, contributions
-  packages/dom/src, packages/dom/contributions (@vgai/dom)
+  packages/dom/src, packages/dom/contributions
     -> src/react, contributions/react
   packages/threejs/src except viewport/ and capture/, packages/threejs/contributions
-  (@vgai/threejs) -> src/three, contributions/three
-  host modules of packages/editor/src (@vgai/editor) -> src/host, including
+  -> src/three, contributions/three
+  host modules of packages/editor/src -> src/host, including
   gameplay-export.ts and document-preview-three.ts, and the world-root stage
   (components/world-root-stage.ts and the modules it draws with)
   src/host/components/world-root-stage-binding.tsx is transcribed from the
@@ -18,6 +18,6 @@ The files in this package were imported from volter-ai/vgai-engine at commit
   contributions/scene-document.service.ts from the Scene document half of
   packages/editor/src/components/CenterDocuments.tsx
 
-src/host/sdk/tools.ts was imported from packages/vgai-sdk/src/tools.ts, part of
-the Apache-2.0 @vgai/sdk package, and retains that license. It re-exports the
+src/host/sdk/tools.ts was imported from src/tools.ts of the Apache-2.0 SDK
+package of volter-ai/volter-engine, and retains that license. It re-exports the
 Apache-2.0 tool contract of @volter/editor-sdk.

package/contributions/autoplay.service.ts

@@ -12,7 +12,7 @@
  * which fires at once when one is already registered) rather than for a React
  * mount.
  *
- * It reports its failure to the editor console — `vgai console` is what reads
+ * It reports its failure to the editor console — `volter-game-editor console` is what reads
  * it — rather than leaving a stopped surface with no reason on it.
  */
 import { onShellStore } from '@volter/editor-sdk/kit/shell-store-door';

package/contributions/build-player.document.tsx

@@ -0,0 +1,95 @@
+/**
+ * BUILD PLAYER (`workspace.document`) — the project's last build, run as a
+ * player runs it: its own `dist/`, served by the editor server, in a frame
+ * with nothing of the editor inside it. Build Profiles' Build And Run opens
+ * it, as Unity's Build And Run launches the player and Godot's Web export
+ * runs in a browser; each run reloads the frame.
+ *
+ * What the build prints reaches the editor's console, prefixed
+ * `[Build Player]`, as a Godot export run with remote debug reports into the
+ * editor's debugger: its console calls, and its uncaught errors. The capture
+ * door photographs the build itself (`framed-document-capture.ts`).
+ */
+
+import type { ToolContributionProps } from '@volter/editor-sdk/contributions';
+import { registerFramedCapture } from '@volter/editor-sdk/kit/framed-document-capture';
+import { useSyncExternalStore } from 'react';
+import { BUILD_PLAYER_URL, buildRunCount, subscribeBuildRuns } from '../src/build/build-session';
+
+export const point = 'workspace.document';
+export const title = 'Build Player';
+
+const FORWARDED = ['log', 'info', 'warn', 'error'] as const;
+
+const HOOKED = Symbol('build-player-output');
+
+/** Hook the player's document once it exists: the build's module scripts run
+ *  before `load`, after its HTML is parsed and while their bundle is fetched,
+ *  so the frame is watched from insertion until its document is the build's. */
+function watchFrame(frame: HTMLIFrameElement | null): void {
+  if (!frame) return;
+  const tick = () => {
+    if (!frame.isConnected) return;
+    const player = frame.contentWindow as (Window & typeof globalThis & { [HOOKED]?: true }) | null;
+    if (player?.location.pathname === new URL(BUILD_PLAYER_URL, location.href).pathname) {
+      if (!player[HOOKED]) {
+        forwardOutput(player);
+        registerFramedCapture(frame, {
+          container: () => player.document.getElementById('game-canvas') ?? player.document.body,
+          canvasFrame: (canvas) => copyAfterRender(player, canvas),
+        });
+      }
+      if (player.document.readyState === 'complete') return;
+    }
+    setTimeout(tick, 0);
+  };
+  tick();
+}
+
+/** A copy of `canvas` taken in the player's next frame, after the game's own
+ *  frame callbacks (registered a frame earlier) have drawn it. */
+function copyAfterRender(player: Window & typeof globalThis, canvas: HTMLCanvasElement): Promise<CanvasImageSource | null> {
+  return new Promise((resolve) => {
+    player.requestAnimationFrame(() => {
+      const copy = player.document.createElement('canvas');
+      copy.width = canvas.width;
+      copy.height = canvas.height;
+      const context = copy.getContext('2d');
+      if (!context) return resolve(null);
+      context.drawImage(canvas, 0, 0);
+      resolve(copy);
+    });
+  });
+}
+
+function forwardOutput(player: Window & typeof globalThis & { [HOOKED]?: true }): void {
+  player[HOOKED] = true;
+  for (const level of FORWARDED) {
+    const own = player.console[level].bind(player.console);
+    player.console[level] = (...args: unknown[]) => {
+      own(...args);
+      console[level]('[Build Player]', ...args);
+    };
+  }
+  player.addEventListener('error', (event) => {
+    console.error('[Build Player] Uncaught', event.error ?? event.message);
+  });
+  player.addEventListener('unhandledrejection', (event) => {
+    console.error('[Build Player] Unhandled rejection', event.reason);
+  });
+  console.info(`[Build Player] Running ${player.document.title || 'the build'}`);
+}
+
+export default function BuildPlayerDocument(_props: ToolContributionProps) {
+  const run = useSyncExternalStore(subscribeBuildRuns, buildRunCount);
+  return (
+    <iframe
+      key={run}
+      title="Build Player"
+      data-build-player={run}
+      src={`${BUILD_PLAYER_URL}?run=${run}`}
+      ref={watchFrame}
+      style={{ width: '100%', height: '100%', border: 0, display: 'block', background: '#000' }}
+    />
+  );
+}

package/contributions/build-profiles.document.tsx

@@ -3,7 +3,7 @@
  * as a center document: the build-role targets, the manifest fields a build
  * reads, and the Build trigger. A document rather than a dialog because the
  * configuration is a persistent authored surface (it writes
- * `vgai.project.json` through the history service) someone tunes and re-runs,
+ * `volter.project.json` through the history service) someone tunes and re-runs,
  * and because a modal would block the viewport while a build streams.
  *
  * It ships with `@volter/editor-game`, so a folder of models has no Build Profiles tab

package/contributions/build-progress.status.tsx

@@ -23,7 +23,7 @@ export default function BuildProgressStatus() {
   if (session.phase === 'building') {
     return (
       <span
-        className="vgai-status-copy"
+        className="volter-status-copy"
         data-testid="status-build-progress"
         data-build-phase="building"
         data-status-tone="accent"
@@ -34,7 +34,7 @@ export default function BuildProgressStatus() {
   }
   return (
     <span
-      className="vgai-status-copy"
+      className="volter-status-copy"
       data-testid="status-build-progress"
       data-build-phase={session.result?.ok ? 'complete' : 'failed'}
       data-status-tone={session.result?.ok ? 'success' : 'danger'}

package/contributions/build.header.tsx

@@ -25,7 +25,7 @@ export default function BuildHeader() {
       aria-label="Export project"
       disabled={playing}
       title={playing ? 'Stop Play mode before exporting the project' : 'Export project'}
-      className="vgai-chrome-island vgai-glass-island"
+      className="volter-chrome-island volter-glass-island"
       onClick={() => {
         openBuildProfilesDocument();
       }}

package/contributions/connection.status.tsx

@@ -31,7 +31,7 @@ export default function ConnectionStatus() {
       type="button"
       variant="ghost"
       size="compact"
-      className="vgai-status-action"
+      className="volter-status-action"
       data-testid="status-connection"
       data-connection-state={state}
       onClick={() => editorHost().workspace.showUtility(NETWORK_UTILITY_ID)}

package/contributions/coverage.service.ts

@@ -15,7 +15,7 @@
  *
  * ## The two doors, both the host's own, neither of them new vocabulary
  *
- *  - `session.reportFacet(collect, { reusableKeys })` — the four `vgai status`
+ *  - `session.reportFacet(collect, { reusableKeys })` — the four `volter-game-editor status`
  *    facets. The keys are declared REUSABLE because grading a root re-walks
  *    its tree (76ms–1.3s, measured), which is exactly the cost
  *    `command-listener.ts`'s `REUSABLE_DERIVED_FACETS` exists to keep off the
@@ -86,7 +86,7 @@ function coverageFacets(reuse: Record<string, unknown> | null): Record<string, u
       : null,
     // The THIRD derived family, and the one that lives outside both adapter
     // contracts: the native verbs whose subject is the PROJECT rather than a
-    // mounted root — its committed proof route, whether `vgai add` can land a
+    // mounted root — its committed proof route, whether `volter-game-editor add` can land a
     // capability here, and whether it can produce a standalone build at all
     // (`@editor/coverage/project-verb-coverage`). Without it a project could
     // be green in the other two families and silently have none of the three.

package/contributions/game-eval.command.ts

@@ -1,13 +1,13 @@
 /**
  * The STEP verbs of the session wire (`@volter/editor-sdk/commands`, a
  * `workspace.command` contribution): `game-eval`, the module lane behind
- * `vgai eval`'s `game.run(...)`, and `page-script`, the in-page Playwright
+ * `volter-game-editor eval`'s `game.run(...)`, and `page-script`, the in-page Playwright
  * shim behind `page(...)`. Both carry a step function's own SOURCE over the
  * wire and reconstruct it here — closures do not survive the trip — so both
  * are gated on a live game surface (a play session or an ingest mount) and
  * rooted at the game container, never editor chrome.
  *
- * The module lane's page-side door (`window.__vgaiGameEval`) and the two
+ * The module lane's page-side door (`window.__volterGameEval`) and the two
  * providers it needs are installed when this module loads, which is when the
  * verbs themselves become available: one handler, two doors, registered
  * together.
@@ -37,7 +37,7 @@ export const point = 'workspace.command';
  * source in the editor page (same wire contract as `page-script`: closures do
  * not survive) and runs it against a scope of { page, modules, instanceId } —
  * `modules(path)` importing the RUNNING mount's own module instances
- * (`game-module-access.ts`). This is what makes `vgai eval` able to touch the
+ * (`game-module-access.ts`). This is what makes `volter-game-editor eval` able to touch the
  * game's exported modules directly, in the browser, with no registry: the
  * step is literal JS against the game's real functions.
  *
@@ -51,12 +51,12 @@ export const point = 'workspace.command';
  */
 declare global {
   interface Window {
-    __vgaiGameEval?: (src: string, instance?: string) => Promise<unknown>;
+    __volterGameEval?: (src: string, instance?: string) => Promise<unknown>;
   }
 }
 if (typeof window !== 'undefined') {
   setFocusedInstanceProvider(focusedInstanceId);
-  window.__vgaiGameEval = async (src: string, instance?: string) => {
+  window.__volterGameEval = async (src: string, instance?: string) => {
     const result = await handleGameEval({
       type: 'game-eval',
       src,
@@ -151,7 +151,7 @@ async function handlePageScript(cmd: EditorCommandMessage): Promise<EditorComman
   // first-party `play-mode.ts` session. Keep the Playwright-style page door on
   // the same reachability rule as bridge calls/screenshots: a real ingest
   // container is sufficient, while the genuinely-unmounted case still
-  // refuses below. Without this, `vgai play` could start an ingested game and
+  // refuses below. Without this, `volter-game-editor play` could start an ingested game and
   // `game.commands()` would work, yet `page(...)` answered "not in play mode"
   // against that very same visible game.
   if (!isPlayModeActive() && !isIngestActive()) return notPlayingResult();

package/contributions/gameplay.command.ts

@@ -96,7 +96,7 @@ export const commands: CommandContribution['commands'] = {
       }
       // D15/T-D15.5 (review objection 2's fix) — resolved through the SAME
       // per-world `DebugRegistry.getVirtualInputTarget(worldId?)` the debug
-      // bridge's `window.__vgai.input.*` calls, instead of the old
+      // bridge's `window.__volter.input.*` calls, instead of the old
       // `Game.input` (always the DEFAULT world only) — an explicit
       // `cmd['worldId']` reaches that world specifically; omitted resolves
       // to the same default both doors now share. Throws
@@ -217,7 +217,7 @@ export const commands: CommandContribution['commands'] = {
   // session's `GameInternal.runTicks` through `getPlayRuntimeAccess()`'s
   // `runTicks` accessor (itself backed by the SAME
   // `DebugRegistry.getRunTicksTarget()` the bridge's
-  // `window.__vgai.runTicks` calls — one implementation, byte-identical
+  // `window.__volter.runTicks` calls — one implementation, byte-identical
   // behavior across doors, D17). `runTicks` itself throws a structured
   // `DebugError` (`RUN_TICKS_PAUSED`) while paused — never a silent no-op —
   // which `structuredErrorResult` below carries through as `data.code`.

package/contributions/generations.status.tsx

@@ -38,7 +38,7 @@ export default function GenerationsStatus() {
       type="button"
       variant="ghost"
       size="compact"
-      className="vgai-status-action"
+      className="volter-status-action"
       data-testid="status-generations"
       aria-label={`Generations, ${unseen} unseen, ${running} running`}
       title={`${unseen} unseen generation results, ${running} running — open Generations`}

package/contributions/ingest.service.ts

@@ -9,7 +9,7 @@
  *    registration, its `ingest`/`ingestCaptureWait` state facets and its
  *    `onShellStore` binding are module-load side effects of
  *    `mount-ingest-root.ts`. The static import below is therefore load-bearing
- *    — `vgai status` carries `ingest: null` / `ingestCaptureWait: null` before
+ *    — `volter-game-editor status` carries `ingest: null` / `ingestCaptureWait: null` before
  *    contribution pass. A product that composes no `@volter/editor-game` reports
  *    neither key, which is the honest state: no lane claims to mount
  *    unmodified games.
@@ -24,7 +24,7 @@
  *    `isIngestActive()` is answered by a mount this hook already made.
  *
  * 3. REGISTERING THIS LANE'S ADAPTER DECLARATIONS. A repo-vendored game does
- *    not ship its own `vgai.adapter.ts` — by the REALM rule its host-realm
+ *    not ship its own `volter.adapter.ts` — by the REALM rule its host-realm
  *    declaration lives in the in-tree registry (`@editor/ingest/registry`),
  *    which the host used to import directly and therefore carried in every
  *    editor boot, a `models` build that mounts no unmodified game included.

package/contributions/play.command.ts

@@ -116,7 +116,7 @@ export const commands: CommandContribution['commands'] = {
       // guard here: `play` on an already-playing (or still-booting) session
       // is a RESTART, not a no-op, matching the SDK's own documented contract
       // (`play.start`'s summary: "Start (or restart) play mode" —
-      // `packages/vgai-sdk/src/play/lifecycle-operations.ts`). What used to
+      // `packages/volter-sdk/src/play/lifecycle-operations.ts`). What used to
       // make a restart unsafe was `enterPlayMode()` having no reentrancy
       // guard for the async-boot window before it assigns `_session` — two
       // overlapping calls ran their entire prologues concurrently and
@@ -127,11 +127,11 @@ export const commands: CommandContribution['commands'] = {
       // SDK, a UI Play-button click racing a relayed command — gets a safe,
       // clean restart for free without needing a guard here too.
       try {
-        // D15/T-D15.6 (objection-4 fix) — `vgai play --seed <n>` relays as
+        // D15/T-D15.6 (objection-4 fix) — `volter-game-editor play --seed <n>` relays as
         // `cmd['seed']`; `enterPlayMode`'s explicit-config seed leg (beats
-        // manifest.determinism.defaultSeed/?vgai-seed=).
+        // manifest.determinism.defaultSeed/?volter-seed=).
         const seed = cmd['seed'];
-        // `vgai play --name <text>` rides the same wire as `--seed`: a plain
+        // `volter-game-editor play --name <text>` rides the same wire as `--seed`: a plain
         // field on the relayed command, slugified server-side into this run's
         // log filename and journal line. Absent, everything is unchanged.
         const runName = cmd['name'];
@@ -173,11 +173,11 @@ export const commands: CommandContribution['commands'] = {
       // EVERY PLAY RECORDS. There is no flag and no opt-in — see
       // `play-recording.ts` for why the capability had to stop being one an
       // agent must remember to switch on. `cmd['record']` only NAMES the file
-      // (`vgai play --record <name>`); its absence names the clip after the
+      // (`volter-game-editor play --record <name>`); its absence names the clip after the
       // durable Gameplay Session.
       //
       // Started here rather than inside `enterPlayMode` on purpose: this
-      // handler is the RELAYED play (`vgai play`, the SDK's `play.start`),
+      // handler is the RELAYED play (`volter-game-editor play`, the SDK's `play.start`),
       // which is exactly the population the recording exists for. A human
       // clicking the editor's own Play button is their own witness and gets
       // play unchanged.

package/contributions/react/react-inspector.service.ts

@@ -62,7 +62,7 @@
  * the DOM projection and the CSS inspection estate
  * (`components/RootSelectionOverlay.tsx`); the surgical JSX writer and the
  * structural write pipe (`authoring/r3f-source-authoring-adapter.ts`,
- * `@vgai/canvas/pixi-source-write-target.ts`); the breakpoint state
+ * `@volter/canvas/pixi-source-write-target.ts`); the breakpoint state
  * (`components/BoardRulers.tsx`); `authoring/react-story-board.ts`, the
  * board's geometry, which three host surfaces read
  * (`components/RootSelectionOverlay.tsx:98`,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/editor-game",
   "author": "Volter AI, Inc.",
   "license": "AGPL-3.0-only",
-  "version": "0.5.67",
+  "version": "0.5.69",
   "publishConfig": {
     "access": "public"
   },
@@ -30,7 +30,7 @@
     "./host/stories/story-pixi-preview": "./src/host/stories/story-pixi-preview.ts",
     "./host/stories/story-media-captures": "./src/host/stories/story-media-captures.ts"
   },
-  "vgai": {
+  "volter": {
     "contributions": [
       "./contributions/asset-budget-asset.menu.ts",
       "./contributions/asset-budget.action.ts",
@@ -42,6 +42,7 @@
       "./contributions/autoplay.service.ts",
       "./contributions/bridge.command.ts",
       "./contributions/build-profiles.document.tsx",
+      "./contributions/build-player.document.tsx",
       "./contributions/build-progress.status.tsx",
       "./contributions/build.action.ts",
       "./contributions/build.command.ts",
@@ -100,11 +101,11 @@
     "serving": "./dist-node/serving.mjs"
   },
   "dependencies": {
-    "@volter/editor-sdk": "0.5.67",
-    "@volter/editor-project": "0.5.67",
-    "@volter/editor-threejs": "0.5.67",
-    "@volter/threejs-runtime": "0.5.67",
-    "@volter/game-runtime": "0.5.67",
+    "@volter/editor-sdk": "0.5.69",
+    "@volter/editor-project": "0.5.69",
+    "@volter/editor-threejs": "0.5.69",
+    "@volter/threejs-runtime": "0.5.69",
+    "@volter/game-runtime": "0.5.69",
     "@colyseus/msgpackr": "^1.11.3",
     "@colyseus/schema": "^4.0.14",
     "@colyseus/sdk": "^0.17.34",
@@ -137,7 +138,7 @@
     "xstate": "^5.32.4",
     "zod": "^4.3.6",
     "@fortawesome/fontawesome-svg-core": "^7.2.0",
-    "@volter/editor-react": "0.5.67"
+    "@volter/editor-react": "0.5.69"
   },
   "peerDependencies": {
     "@sparkjsdev/spark": "^2.1.0",

package/serving/index.ts

@@ -1,5 +1,5 @@
 /**
- * `@volter/editor-game`'s server half (`package.json#vgai.serving`): the one deep specifier a
+ * `@volter/editor-game`'s server half (`package.json#volter.serving`): the one deep specifier a
  * game's own contributions name, `@editor/game-module-access` (the template's
  * `src/contributions/use-game-modules.ts`), resolved to this package's module. The page
  * bundle maps the same specifier for its own copy (`src/host/served-bundle-runtime-modules.ts`);

package/src/asset-budget/AssetBudgetPanel.tsx

@@ -882,7 +882,7 @@ function OptimizeActions({ entry, onApplied }: { entry: AssetBudgetEntry; onAppl
       {lodCandidates.length > 0 ? (
         <div style={{ display: 'flex', gap: spaceVar[2], marginTop: spaceVar[3] }}>
           <Select
-            className="vgai-select"
+            className="volter-select"
             aria-label="LOD base node"
             data-testid="asset-budget-op-lod-node"
             value={chosenLodNode}

package/src/asset-budget/asset-budget-model.ts

@@ -12,7 +12,7 @@
  *   - the project REFERENCE GRAPH: which manifest entries, code files, or
  *     sibling assets mention each asset ("what uses this", critique P5),
  *     the unused list derived from it, and duplicate groups by sha256
- *   - provenance stamps projected from `.vgai/provenance.json`
+ *   - provenance stamps projected from `.volter/provenance.json`
  *
  * Anti-shim: anything unmeasurable is reported as absent/unknown with a
  * reason (`inspectError`, `gpuBytes: null`, `unknownTextureCount`) — never a
@@ -190,7 +190,7 @@ export interface AssetBudgetSource {
    * Reference-owner documents living OUTSIDE the walked snapshot, scanned for
    * references but never budget rows. Server mode uses this for the project
    * manifest: `HttpStorage` is hard-rooted at `public/` (its own doc comment;
-   * the T3.3 "two-`.vgai`-dirs" finding), so `vgai.project.json` is unreachable
+   * the T3.3 "two-`.volter`-dirs" finding), so `volter.project.json` is unreachable
    * through the seam and is fetched over the dev server instead — without it,
    * every manifest-referenced asset (input maps, scenes) would be reported
    * unused, a fabricated finding.
@@ -213,7 +213,7 @@ export interface AssetBudgetSource {
   readonly codeReferencesScannable?: boolean;
   readBytes(path: string): Promise<Uint8Array>;
   readText(path: string): Promise<string>;
-  /** Parsed `.vgai/provenance.json` (or null/undefined when absent). */
+  /** Parsed `.volter/provenance.json` (or null/undefined when absent). */
   readonly provenance?: unknown;
 }
 
@@ -282,7 +282,7 @@ export function isEngineVendoredRuntimePath(path: string): boolean {
 // --- Reference scanning ------------------------------------------------------
 
 const CODE_OWNER_PATTERN = /\.(?:tsx?|jsx?|mjs|cjs)$/i;
-const MANIFEST_NAME = 'vgai.project.json';
+const MANIFEST_NAME = 'volter.project.json';
 
 /**
  * The manifest is the ONLY JSON document that owns asset references. An
@@ -450,7 +450,7 @@ const IGNORED_DIRS = new Set([
   '.git',
   'dist',
   'build',
-  '.vgai',
+  '.volter',
   '.ci-scaffold',
   'coverage',
   'test-results',
@@ -476,21 +476,21 @@ export async function collectProjectBudgetSource(
   await walk('');
 
   // Server mode: `HttpStorage` is hard-rooted at the project's `public/`
-  // folder (its doc comment; the T3.3 "two-`.vgai`-dirs" finding), so BOTH
+  // folder (its doc comment; the T3.3 "two-`.volter`-dirs" finding), so BOTH
   // project-root documents the budget needs live outside the seam. Use the
   // dev server's own idioms for each: the raw manifest served at
-  // `/vgai.project.json` (`manifest-project.ts`) and the `.vgai/`-scoped
-  // `/__editor/vgai-file` route (`project-provenance.ts`). Anything
+  // `/volter.project.json` (`manifest-project.ts`) and the `.volter/`-scoped
+  // `/__editor/volter-file` route (`project-provenance.ts`). Anything
   // unavailable stays honestly absent — no fabricated owners or stamps.
   if (isPublicRootedBackend(backend)) {
     const ownerFiles: AssetBudgetFile[] = [];
     const virtualTexts = new Map<string, string>();
     try {
-      const manifestRes = await fetch('/vgai.project.json');
+      const manifestRes = await fetch('/volter.project.json');
       if (manifestRes.ok) {
         const text = await manifestRes.text();
-        virtualTexts.set('vgai.project.json', text);
-        ownerFiles.push({ path: 'vgai.project.json', size: text.length });
+        virtualTexts.set('volter.project.json', text);
+        ownerFiles.push({ path: 'volter.project.json', size: text.length });
       }
     } catch {
       // No reachable manifest → no manifest-owned references.
@@ -501,7 +501,7 @@ export async function collectProjectBudgetSource(
       // answers `text/plain` raw file bytes, which that JSON-only reader would
       // reject as a non-answer. See `optimize-apply.ts`'s `readLedgerText`.
       const provenanceRes = await fetch(
-        `/__editor/vgai-file?${new URLSearchParams({ path: '.vgai/provenance.json' })}`,
+        `/__editor/volter-file?${new URLSearchParams({ path: '.volter/provenance.json' })}`,
       );
       if (provenanceRes.ok) provenance = JSON.parse(await provenanceRes.text());
     } catch {
@@ -525,8 +525,8 @@ export async function collectProjectBudgetSource(
 
   let provenance: unknown = null;
   try {
-    if (await backend.exists('.vgai/provenance.json')) {
-      provenance = JSON.parse(await backend.read('.vgai/provenance.json'));
+    if (await backend.exists('.volter/provenance.json')) {
+      provenance = JSON.parse(await backend.read('.volter/provenance.json'));
     }
   } catch {
     provenance = null; // unreadable provenance = no stamps, never a crash

package/src/asset-budget/optimize-apply.ts

@@ -2,7 +2,7 @@
  * Storage-side APPLY flow for Asset Budget optimizations (W4a M3).
  *
  * One place owns "optimized bytes land in the project": write through the
- * storage seam, stamp central provenance (`.vgai/provenance.json`, the SAME
+ * storage seam, stamp central provenance (`.volter/provenance.json`, the SAME
  * document/idiom the generative-assets pipeline stamps and
  * `project-provenance.ts` projects — one operation with an `outputs` entry
  * carrying path/bytes/sha256), invalidate the engine's URL-keyed asset cache
@@ -27,7 +27,7 @@ import { handleProjectMutationFailure } from '@volter/editor-sdk/kit/source-conf
 import { isPublicRootedBackend, type StorageBackend } from '@volter/editor-sdk/kit/storage-types';
 import { invalidateCachedAsset } from '@volter/threejs-runtime/asset-loaders';
 
-const PROVENANCE_PATH = '.vgai/provenance.json';
+const PROVENANCE_PATH = '.volter/provenance.json';
 
 /** Serving path (`/models/x.glb`) or bare path → storage path under public/. */
 export function assetStoragePath(path: string): string {
@@ -74,10 +74,10 @@ function ledgerAssetPath(storagePath: string): string {
 
 /**
  * Ledger IO honoring the backend's reach: server-mode `HttpStorage` is
- * hard-rooted at `public/`, so writing `.vgai/provenance.json` through it
- * would land at `public/.vgai/provenance.json` — a divergent second ledger
- * (the exact T3.3 "two-`.vgai`-dirs" bug class). The dev server's
- * `.vgai/`-scoped `/__editor/vgai-file` GET/POST route pair is the recorded
+ * hard-rooted at `public/`, so writing `.volter/provenance.json` through it
+ * would land at `public/.volter/provenance.json` — a divergent second ledger
+ * (the exact T3.3 "two-`.volter`-dirs" bug class). The dev server's
+ * `.volter/`-scoped `/__editor/volter-file` GET/POST route pair is the recorded
  * fix for that class; every other
  * backend reaches the project root directly.
  */
@@ -88,7 +88,7 @@ async function readLedgerText(backend: StorageBackend): Promise<string | null> {
     // file bytes, and that reader's whole rule is "the editor server answers
     // JSON" — it would reject this route's successes.
     const res = await fetch(
-      `/__editor/vgai-file?${new URLSearchParams({ path: PROVENANCE_PATH })}`,
+      `/__editor/volter-file?${new URLSearchParams({ path: PROVENANCE_PATH })}`,
     );
     if (res.status === 404) return null;
     if (!res.ok) throw new Error(`read ${PROVENANCE_PATH}: HTTP ${res.status}`);
@@ -101,7 +101,7 @@ async function readLedgerText(backend: StorageBackend): Promise<string | null> {
 async function writeLedgerText(backend: StorageBackend, content: string): Promise<void> {
   if (isPublicRootedBackend(backend)) {
     const write = async () => {
-      const res = await fetch('/__editor/vgai-file', {
+      const res = await fetch('/__editor/volter-file', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ path: PROVENANCE_PATH, content, ...sourceMutationAttribution() }),

package/src/bridge/call.ts

@@ -17,7 +17,7 @@ import { dispatchBridgeMethod, hasLiveDebugPlane } from './dispatch';
  *  this package); everything else is `dispatchBridgeMethod`'s own structured
  *  failure, caught here and shipped back via `structuredErrorResult` so
  *  `code`/`data` survive the relay round trip byte-equivalent to the
- *  page-transport's `unwrap()` path (`packages/vgai-live/src/game-client/client.ts`). */
+ *  page-transport's `unwrap()` path (`packages/volter-live/src/game-client/client.ts`). */
 export async function handleBridgeCall(cmd: EditorCommandMessage): Promise<EditorCommandResult> {
   // The precondition is "no plane at all", not "not playing" — see
   // `hasLiveDebugPlane`. The per-method preconditions inside
@@ -28,7 +28,7 @@ export async function handleBridgeCall(cmd: EditorCommandMessage): Promise<Edito
   // the still edit world can be driven.
   if (!isPlayModeActive() && !hasLiveDebugPlane()) {
     // A LIVE INGEST that publishes no plane is a third state, and answering it
-    // with "not in play mode" sends the reader to `vgai play` over a game that
+    // with "not in play mode" sends the reader to `volter-game-editor play` over a game that
     // is already running and visible. MEASURED on the `flappy` canvas ingest:
     // `game.waitSimTime(...)` refused with the play sentence while the mount's
     // own play state read `playing`. The mount is what is missing a plane, so
@@ -43,7 +43,7 @@ export async function handleBridgeCall(cmd: EditorCommandMessage): Promise<Edito
             'this ingest mount is live, but it publishes no debug plane — the mount installs no ' +
             'SystemAdapters.debug, so there is nothing to enumerate, read or drive through the ' +
             'game seam. Starting play will not change that; the game itself must declare the ' +
-            'vgai game contract (or carry a contract shim beside it) for these calls to have an ' +
+            'volter game contract (or carry a contract shim beside it) for these calls to have an ' +
             'answer.',
         }
       : notPlayingResult();