@volter/game-editor 0.5.68 → 0.5.70

package/template/src/main.ts

@@ -1,16 +1,15 @@
 /**
  * Standalone entry point: this game's own boot, in its own libraries.
  *
- * Every root `vgai.project.json` declares gets one layer in `#game-canvas`,
+ * Every root `volter.project.json` declares gets one layer in `#game-canvas`,
  * stacked by `zOrder`. A `three` root's entry default-exports a React Three
  * Fiber component and renders inside `<Canvas>`; a `dom` root's entry
  * default-exports a React component and renders with react-dom, in a layer
  * that lets pointer events fall through to the world except where its own
- * elements claim them (`pointer-events: auto`); a `canvas` root's entry default-exports a
- * `@pixi/react` component and renders inside `<Application>`, with every `pixi.js` class
- * registered first, as the editor's own canvas mount registers them (so a node the editor created,
- * a TilingSprite or a BitmapText, mounts here too). The editor mounts the same entries itself;
- * nothing here runs inside it.
+ * elements claim them (`pointer-events: auto`): a game's UI is that `dom` root.
+ * A `canvas` root (2D game rendering) mounts through `src/canvas-mount.ts`, which
+ * only a project with a canvas root carries, so a game without one imports no Pixi.
+ * The editor mounts the same entries itself; nothing here runs inside it.
  *
  * `manifestEntryModules` is generated from the manifest's `entry` paths
  * (`manifest-entry-modules-plugin.ts`), so the manifest stays the one list of
@@ -20,8 +19,8 @@
 import { Canvas } from '@react-three/fiber';
 import { type ComponentType, createElement } from 'react';
 import { createRoot } from 'react-dom/client';
-import { manifestEntryModules } from 'virtual:vgai-manifest-entries';
-import manifest from '../vgai.project.json';
+import { manifestEntryModules, mountCanvasRoot } from 'virtual:volter-manifest-entries';
+import manifest from '../volter.project.json';
 
 interface DeclaredRoot {
   readonly id: string;
@@ -51,7 +50,7 @@ const roots = [...(manifest.roots as readonly DeclaredRoot[])].sort(
 const bottomWorld = roots.find((root) => root.adapter === 'three' || root.adapter === 'canvas');
 
 // A `canvas` world above the bottom one claims the points where Pixi finds an interactive object (a
-// HUD's button), as the editor's input router does: the press goes to that world alone, and every
+// sprite the player taps), as the editor's input router does: the press goes to that world alone, and every
 // other point falls through to the world beneath. Topmost first.
 const claims: { readonly zOrder: number; readonly canvas: HTMLCanvasElement; readonly hit: (x: number, y: number) => boolean }[] = [];
 const forwarded = new WeakSet<Event>();
@@ -95,36 +94,18 @@ for (const root of roots) {
     layer.style.pointerEvents = 'none';
     createRoot(layer).render(createElement(Entry));
   } else if (root.adapter === 'canvas') {
-    const [{ Application, extend }, PIXI] = await Promise.all([import('@pixi/react'), import('pixi.js')]);
-    extend(PIXI as unknown as Parameters<typeof extend>[0]);
-    createRoot(layer).render(
-      createElement(
-        Application,
-        {
-          resizeTo: layer,
-          antialias: true,
-          resolution: globalThis.devicePixelRatio ?? 1,
-          autoDensity: true,
-          backgroundAlpha: root === bottomWorld ? 1 : 0,
-          onInit: (app) => {
-            if (root === bottomWorld) return;
-            claims.push({
-              zOrder: root.zOrder ?? 0,
-              canvas: app.canvas,
-              // Pixi points its boundary at the last rendered scene inside its own pointer handlers.
-              hit: (x, y) => {
-                const rendered = app.renderer.lastObjectRendered;
-                if (!rendered) return false;
-                app.renderer.events.rootBoundary.rootTarget = rendered;
-                return app.renderer.events.rootBoundary.hitTest(x, y) !== null;
-              },
-            });
-            claims.sort((a, b) => b.zOrder - a.zOrder);
-          },
+    if (!mountCanvasRoot) {
+      throw new Error(`main.ts: root "${root.id}" is a canvas root, and this project carries no src/canvas-mount.ts.`);
+    }
+    if (root === bottomWorld) mountCanvasRoot(layer, Entry, { bottom: true, onHitTest: () => {} });
+    else
+      mountCanvasRoot(layer, Entry, {
+        bottom: false,
+        onHitTest: (canvas, hit) => {
+          claims.push({ zOrder: root.zOrder ?? 0, canvas, hit });
+          claims.sort((a, b) => b.zOrder - a.zOrder);
         },
-        createElement(Entry),
-      ),
-    );
+      });
   } else {
     throw new Error(
       `main.ts: root "${root.id}" declares adapter ${JSON.stringify(root.adapter)}, which this boot does not mount.`,

package/template/src/manifest-entry-modules.d.ts

@@ -1,3 +1,14 @@
-declare module 'virtual:vgai-manifest-entries' {
+declare module 'virtual:volter-manifest-entries' {
   export const manifestEntryModules: Readonly<Record<string, unknown>>;
+  /** `src/canvas-mount.ts`'s mount when the manifest declares a `canvas` root, else `undefined`. */
+  export const mountCanvasRoot:
+    | ((
+        layer: HTMLElement,
+        Entry: import('react').ComponentType,
+        options: {
+          readonly bottom: boolean;
+          readonly onHitTest: (canvas: HTMLCanvasElement, hit: (x: number, y: number) => boolean) => void;
+        },
+      ) => void)
+    | undefined;
 }

package/template/src/net/NetworkedPlayers.tsx

@@ -10,7 +10,7 @@
  */
 
 import type { Room } from '@colyseus/sdk';
-import { useFrame } from '@react-three/fiber';
+import { type ThreeElements, useFrame } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
 import { actionPressed } from '../input';
 import { joinGameRoom } from './game-room';
@@ -42,7 +42,7 @@ interface StateShape {
   orbs: { forEach(fn: (orb: OrbView, id: string) => void): void };
 }
 
-export function NetworkedPlayers({ name = 'Networked Players' }: { readonly name?: string }) {
+export function NetworkedPlayers({ name = 'Networked Players', ...props }: ThreeElements['group']) {
   const [room, setRoom] = useState<Room | null>(null);
   const [running, setRunning] = useState(false);
   const [players, setPlayers] = useState<readonly PlayerView[]>([]);
@@ -115,7 +115,7 @@ export function NetworkedPlayers({ name = 'Networked Players' }: { readonly name
   });
 
   return (
-    <group name={name}>
+    <group {...props} name={name}>
       {players.map((player) => (
         <mesh key={player.id} name={player.name || player.id} position={[player.x, 0.45, player.z]} castShadow>
           <sphereGeometry args={[0.45, 24, 16]} />

package/template/src/prefabs/HeroBox.stories.tsx

@@ -19,5 +19,5 @@ export default meta;
 type Story = StoryObj<typeof meta>;
 
 export const Default: Story = {
-  parameters: { vgai: { default: true } },
+  parameters: { volter: { default: true } },
 };

package/template/src/world.tsx

@@ -74,7 +74,7 @@ function World() {
       <GameKeyboard />
       {/* The resident QA tester's hands on the frame — everything else about
           the playtesting loop (the seat, the repertoire, pause/handoff) is
-          plain application code in src/bot/, reached from `vgai eval` via
+          plain application code in src/bot/, reached from `volter-game-editor eval` via
           `game.run(({ modules }) => …)` like every other module. */}
       <QaTester />
       <Scene name="Main Scene" />

package/template/tsconfig.json

@@ -31,6 +31,6 @@
       "@editor/*": ["node_modules/@volter/editor-core/src/*"]
     }
   },
-  "include": ["src", "vgai.adapter.ts"],
+  "include": ["src", "volter.adapter.ts"],
   "exclude": ["src/tools", "src/contributions"]
 }

package/template/validate-manifest.ts

@@ -9,18 +9,18 @@ import { loadGameManifestFile } from '@volter/editor-project/manifest/load-file'
 // Single source of truth for game-manifest validation, shipped IN the
 // project template so every scaffolded game
 // gets a working `npm run validate-manifest`. Validates each given
-// `vgai.project.json` path via `loadGameManifestFile` (parse -> cross-field
+// `volter.project.json` path via `loadGameManifestFile` (parse -> cross-field
 // checks -> resolution) and prints the
 // resolved adapter-root list (id, adapter identity) on success. Any failure
 // prints a descriptive error and
 // exits 1.
 //
-// Defaults to THIS template's own manifest (`vgai.project.json`, a sibling of
+// Defaults to THIS template's own manifest (`volter.project.json`, a sibling of
 // this script) when no path is given, so `npm run validate-manifest` works
 // out of the box both from the monorepo root and from a scaffolded project.
 // ---------------------------------------------------------------------------
 
-const defaultManifestPath = fileURLToPath(new URL('./vgai.project.json', import.meta.url));
+const defaultManifestPath = fileURLToPath(new URL('./volter.project.json', import.meta.url));
 
 const args = process.argv.slice(2);
 const manifestPaths = args.length > 0 ? args.map((p) => resolve(p)) : [defaultManifestPath];

package/template/vite.config.ts

@@ -4,21 +4,21 @@ import { defineConfig } from 'vite';
 // Config-relative TS imports get bundled the same way — that is what lets the
 // project's executable Zod schemas reach the build-time check below.
 import { manifestEntryModulesPlugin } from './manifest-entry-modules-plugin';
-import manifest from './vgai.project.json';
+import manifest from './volter.project.json';
 
-/** A vgai runtime package served as SOURCE, the way the editor serves it. */
+/** A volter runtime package served as SOURCE, the way the editor serves it. */
 const packageSource = (name: string) =>
   path.join(path.dirname(createRequire(import.meta.url).resolve(`${name}/package.json`)), 'src');
 
 /**
  * Run-4 dry-run friction #2 — auto-detect drvfs the SAME way the editor dev
- * server does (`packages/editor/server/server-utils.ts`'s
+ * server does (`packages/editor-core/server/server-utils.ts`'s
  * `resolveWatcherPollOptions`, and `dev.ts`'s own `projectOnDrvfs` check):
  * on WSL, a project living on a Windows drive (`/mnt/<drive>/…`) never fires
  * inotify, so without polling this standalone server (`npm run dev:standalone`)
  * silently misses every external file edit — the same failure mode
  * `dev.ts`'s comment documents for the editor. Before this fix, this file
- * read ONLY `VGAI_WATCH_POLL`, so a project on drvfs polled in the editor
+ * read ONLY `VOLTER_WATCH_POLL`, so a project on drvfs polled in the editor
  * but NOT in the standalone server — the two disagreed for no reason a
  * developer could see.
  *
@@ -26,11 +26,11 @@ const packageSource = (name: string) =>
  * contract, so this
  * duplicates the tiny drvfs check rather than reaching across a package
  * boundary that doesn't exist here — same contract as the editor's own
- * helper: `VGAI_WATCH_POLL=0` forces polling off anywhere, `=1`/`=<ms>`
+ * helper: `VOLTER_WATCH_POLL=0` forces polling off anywhere, `=1`/`=<ms>`
  * forces it on with that interval, unset auto-enables on a drvfs mount.
  */
 function resolveWatchOption(): { usePolling: true; interval: number } | undefined {
-  const raw = process.env['VGAI_WATCH_POLL'];
+  const raw = process.env['VOLTER_WATCH_POLL'];
   if (raw !== undefined && raw !== '') {
     if (raw === '0') return undefined;
     const ms = Number(raw);
@@ -68,7 +68,7 @@ export default defineConfig({
   //
   // This project has no `@vitejs/plugin-react`; Vite's built-in esbuild does
   // the JSX transform, and it picks the runtime from the tsconfig nearest the
-  // FILE. That covers `src/**`, but the vgai runtime packages are served as
+  // FILE. That covers `src/**`, but the volter runtime packages are served as
   // source out of their installed directories (see the aliases below), where
   // the project's tsconfig does not reach — so their `.tsx` compiled with the CLASSIC runtime, emitting
   // bare `React.createElement` calls into a module that never imports React.
@@ -97,7 +97,7 @@ export default defineConfig({
     // example modules (or injected by the JSX transform, like the React
     // runtimes) so Vite does not discover them at runtime, re-optimize, and
     // hard-reload the standalone runtime the first time a game selects them —
-    // that mid-session reload resets `window.__vgaiScene`/the menu out from
+    // that mid-session reload resets `window.__volterScene`/the menu out from
     // under whatever is driving the page (the dep-optimize-reload flake the
     // 04 spec hit: the first cold select of `editor-tutorial` reloaded on
     // `react/jsx-dev-runtime`). Verified against a cold scaffold: with these
@@ -146,20 +146,20 @@ export default defineConfig({
     // WSL when the project lives on a Windows drive (/mnt/c, drvfs: inotify
     // never fires there), or edits to src/data/ or src/ generally silently never
     // hot-reload into the running game.
-    // `VGAI_WATCH_POLL` is an explicit override (`=0` off anywhere, `=1`/
+    // `VOLTER_WATCH_POLL` is an explicit override (`=0` off anywhere, `=1`/
     // `=<ms>` on anywhere) — see `resolveWatchOption` above, which the
     // EDITOR dev server's own auto-detect mirrors, so one behavior covers
     // both surfaces without the developer having to set anything. Safe to
     // enable here: this standalone server only watches the project tree,
     // which is small.
     //
-    // VGAI_NO_WATCH=1 (set by a harness driving this page):
+    // VOLTER_NO_WATCH=1 (set by a harness driving this page):
     // disable watching entirely — a mid-run Vite reload resets
-    // `window.__vgai`/whatever is driving the standalone page out from under
+    // `window.__volter`/whatever is driving the standalone page out from under
     // an in-flight run (the hollowstone reload-kills-the-run
     // lesson). Mutually exclusive with the poll option (same `server.watch`
     // key) — NO_WATCH wins when both would otherwise apply.
-    ...(process.env['VGAI_NO_WATCH']
+    ...(process.env['VOLTER_NO_WATCH']
       ? { watch: null }
       : // Watch source; never watch output: a build (`npm run build`,
         // `vercel build`) rewriting dist/ or .vercel/output/ inside the

package/template/{vgai.adapter.ts → volter.adapter.ts}

@@ -7,7 +7,7 @@
  * whatever it declares about itself. An adapter's SIZE measures this game's
  * distance from native — which is why yours fits on a screen.
  *
- * Regions are derived mechanically from `vgai.project.json`'s `roots[]` — add
+ * Regions are derived mechanically from `volter.project.json`'s `roots[]` — add
  * a root to the manifest and its region appears here for free, with no edit to
  * this file. `regionIncludes` states the PARAMETERS that derivation cannot
  * produce: which source files each region owns beyond its entry's import reach.

package/template/{vgai.project.json → volter.project.json}

@@ -1,5 +1,5 @@
 {
-  "$schema": "./node_modules/@volter/editor-project/schemas/vgai-project.schema.json",
+  "$schema": "./node_modules/@volter/editor-project/schemas/volter-project.schema.json",
   "manifestVersion": 2,
   "name": "My Game",
   "appId": "com.example.mygame",
@@ -19,7 +19,7 @@
       "entry": "server/main.ts",
       "command": "npx tsx --tsconfig server/tsconfig.json server/main.ts",
       "port": 2567,
-      "env": { "VGAI_ROOM_MONITOR": "1" }
+      "env": { "VOLTER_ROOM_MONITOR": "1" }
     },
     { "id": "play + server", "kind": "compound", "run": ["server", "play"] }
   ],

package/template-dotfiles/gitignore

@@ -10,58 +10,58 @@ dist-server/
 .vite/
 
 # Editor autosaved UI state (panel layout etc.) — local-machine ephemeral.
-# NOT the rest of .vgai/: .vgai/scaffold-baseline.json is committed project
-# state `vgai upgrade` diffs against (packages/create-vgai-project/src/baseline.ts),
-# and .vgai/overlays/*.json + .vgai/thumbnail.png + .vgai/provenance.json +
-# .vgai/generations.json are real project data too.
-.vgai/editor-state.json
-.vgai/workbench-storage.json
+# NOT the rest of .volter/: .volter/scaffold-baseline.json is committed project
+# state: the scaffold's record of the files it wrote (node/scaffold/baseline.ts),
+# and .volter/overlays/*.json + .volter/thumbnail.png + .volter/provenance.json +
+# .volter/generations.json are real project data too.
+.volter/editor-state.json
+.volter/workbench-storage.json
 # Which Code-OSS workbench THIS machine opens the project in — an absolute path
 # to an extracted release or a fork checkout, so it is a fact about this box and
 # never about the project. The product's `create --workbench <dir>` writes it;
-# `vgai edit --workbench <dir>` overrides it for one launch.
-.vgai/workbench.json
+# `volter-game-editor edit --workbench <dir>` overrides it for one launch.
+.volter/workbench.json
 # The editor's chat panel: which agent harness this machine chose and its conversations.
-.vgai/chat-selection.json
-.vgai/chat-sessions.json
+.volter/chat-selection.json
+.volter/chat-sessions.json
 # #146 — more local-machine ephemera: the live session's discovery file
 # (written by the dev server at boot, removed on shutdown) and agent
-# screenshot captures (GET /__vgai/screenshot).
-.vgai/session.json
-.vgai/collaboration.json
-.vgai/captures/
-.vgai/tmp/
-.vgai/last-run/
-# `vgai screenshot`'s default output directory — looking at the game is the
+# screenshot captures (GET /__volter/screenshot).
+.volter/session.json
+.volter/collaboration.json
+.volter/captures/
+.volter/tmp/
+.volter/last-run/
+# `volter-game-editor screenshot`'s default output directory — looking at the game is the
 # documented way to verify it, so an ordinary session leaves dozens of PNGs here.
-.vgai/screenshots/
-# `vgai play`'s gameplay video. EVERY play records, so this directory is
+.volter/screenshots/
+# `volter-game-editor play`'s gameplay video. EVERY play records, so this directory is
 # written on every run — and it is bounded by design, not by cleanup: the
 # unnamed clip is one rotating file (play-latest.webm) that each play
 # overwrites, and `--record <name>` keepsakes are the user's own. Never
 # committed either way: video is build-shaped output, and a repo that carries
 # one run's footage is carrying the wrong artifact.
-.vgai/recordings/
+.volter/recordings/
 # Run artifacts a driving script writes (screenshots a failure block points at,
 # the last run's scratch). Overwritten every run — nothing here is worth
 # committing.
-.vgai/prev-run/
+.volter/prev-run/
 # The idiom scanner's last findings (check-idioms.ts writes it every run, and
-# `vgai status` reads it so open ERROR findings surface from the first status
+# `volter-game-editor status` reads it so open ERROR findings surface from the first status
 # call instead of at handoff). A cache of a fact recomputable in under a
 # second — machine-local, never project state.
-.vgai/check-idioms.json
+.volter/check-idioms.json
 # Rebuildable Scene/Canvas Content preview images. Authored framing remains in
-# .vgai/thumbnails.json; only these generated pixels are machine-local.
-.vgai/cache/document-previews/
+# .volter/thumbnails.json; only these generated pixels are machine-local.
+.volter/cache/document-previews/
 # The build-discipline tripwires' announce gate (which step each tripwire has
 # already announced, keyed on what makes it go quiet). Persisted so a dev-server
 # restart cannot re-arm a long dirty batch at "nothing announced" — machine-local
 # by nature, and it MUST stay untracked: a tracked gate file would add itself to
 # the very dirty-file count the commit-cadence tripwire reports.
-.vgai/tripwire-gate.json
+.volter/tripwire-gate.json
 
-# `vgai play`'s run logs (logs/play-*.jsonl — see packages/vgai-cli/src/index.ts)
+# `volter-game-editor play`'s run logs (logs/play-*.jsonl)
 logs/
 *.jsonl
 

package/workbench/src/media/game-cover.css

@@ -1,12 +1,12 @@
 /* THE GAME EDITOR'S OWN SPLASH — what this product draws into the kit's opening cover
-   (`VgaiProduct.cover`, `packages/editor-core/workbench/src/vgaiCover.ts`).
+   (`VolterProduct.cover`, `packages/editor-core/workbench/src/volterCover.ts`).
 
    IT SPELLS CLASSIC'S PALETTE, for the same reason the model editor's spells Blender's: the
    cover paints BEFORE any theme extension is registered — the web workbench's first frame is
    the page config's `initialColorTheme` — so a splash written against `--vscode-*` would wear
    the workbench's default dark for exactly the seconds it exists instead of this product's
    look. Classic is the editor's own Graphite and it ships no theme extension at all, so these
-   values come from `@vgai/editor-sdk`'s `widgets/theme.ts`, named beside them:
+   values come from `@volter/editor-sdk`'s `widgets/theme.ts`, named beside them:
 
      #1a1a1a  GRAPHITE_BG[0]        surface.shell — the window's outermost band
      #242424  GRAPHITE_BG[1]        surface.panel
@@ -18,7 +18,7 @@
    Nothing here names a font: Classic is the workbench's own UI font, which is what this
    product wearing no look extension means. */
 
-.vgai-game-cover {
+.volter-game-cover {
 	position: absolute;
 	inset: 0;
 	display: flex;
@@ -33,26 +33,26 @@
 /* THE MARK: a play triangle inside the panel surface — the one glyph this product's whole
    transport is built around. Inline SVG in the product's own markup, so there is no image to
    fetch and the first frame is the first frame. */
-.vgai-game-cover-mark {
+.volter-game-cover-mark {
 	width: 56px;
 	height: 56px;
 	opacity: 0.92;
 }
 
-.vgai-game-cover-title {
+.volter-game-cover-title {
 	font-size: 26px;
 	font-weight: 600;
 	letter-spacing: 0.02em;
 }
 
-.vgai-game-cover-folder {
+.volter-game-cover-folder {
 	font-size: 12px;
 	color: #9aa0a6;
 }
 
 /* Indeterminate ON PURPOSE: this product knows WHAT it is waiting for and not how far along it
    is, and a bar that invented a percentage would be a lie a person can see. */
-.vgai-game-cover-rail {
+.volter-game-cover-rail {
 	position: relative;
 	width: 220px;
 	height: 2px;
@@ -61,22 +61,22 @@
 	background: #333333;
 }
 
-.vgai-game-cover-rail::after {
+.volter-game-cover-rail::after {
 	content: "";
 	position: absolute;
 	top: 0;
 	bottom: 0;
 	width: 40%;
 	background: #579eff;
-	animation: vgai-game-cover-travel 1.25s ease-in-out infinite;
+	animation: volter-game-cover-travel 1.25s ease-in-out infinite;
 }
 
-@keyframes vgai-game-cover-travel {
+@keyframes volter-game-cover-travel {
 	0% { left: -40%; }
 	100% { left: 100%; }
 }
 
-.vgai-game-cover-state {
+.volter-game-cover-state {
 	font-size: 11px;
 	min-height: 14px;
 	color: #9aa0a6;

package/workbench/src/product.contribution.ts

@@ -8,7 +8,7 @@
  *
  *  It is the counterpart of `packages/game-editor/src/index.ts`, which composes the SAME
  *  product in the editor's own realm. There is exactly one piece of workbench code that is a
- *  game editor's and not any editor's, and it is `vgaiGameSkew.ts` beside this file: what the
+ *  game editor's and not any editor's, and it is `volterGameSkew.ts` beside this file: what the
  *  frame must answer for a GAME layout — immersive Play, the semantic dock commands, and the
  *  surface-keyboard probe. Everything else a game editor draws is the kit's.
  *
@@ -19,19 +19,19 @@
  *
  *  IT DOES SHIP ONE STYLESHEET, and only one: `media/game-cover.css`, this product's own
  *  opening splash. It spells Classic's palette because the cover paints before any theme is
- *  registered at all — see that file's header, and `vgaiProduct.ts`'s `cover`.
+ *  registered at all — see that file's header, and `volterProduct.ts`'s `cover`.
  *--------------------------------------------------------------------------------------------*/
 
 import './media/game-cover.css';
 import { $ } from '../../../../base/browser/dom.js';
 import { mainWindow } from '../../../../base/browser/window.js';
 import { localize } from '../../../../nls.js';
-import { registerVgaiProduct, type VgaiProductCover, type VgaiProductCoverContext, type VgaiProductMountContext } from '../../vgai/browser/vgaiProduct.js';
-import { VgaiGameSkew, type VgaiGameBridge } from './vgaiGameSkew.js';
+import { registerVolterProduct, type VolterProductCover, type VolterProductCoverContext, type VolterProductMountContext } from '../../volter/browser/volterProduct.js';
+import { VolterGameSkew, type VolterGameBridge } from './volterGameSkew.js';
 
 /** What this product reads off the mount to know its Game document is open and drawn — a
- *  MIRROR of the kit's `VgaiDocumentsBridge`, declared here for the same reason
- *  `VgaiGameBridge` is: a product declares the shape it expects (`vgaiProduct.ts`'s header),
+ *  MIRROR of the kit's `VolterDocumentsBridge`, declared here for the same reason
+ *  `VolterGameBridge` is: a product declares the shape it expects (`volterProduct.ts`'s header),
  *  and a door this build's kit does not have reads as missing rather than as a crash. */
 interface DocumentsRegistry {
 	whenRestored?(): Promise<void>;
@@ -73,13 +73,13 @@ const GAME_OPEN_BUDGET_MS = 60_000;
  *  cover it drew. Set by `cover`, cleared by the handle's `dispose`. */
 let splash: { say(text: string): void } | undefined;
 
-registerVgaiProduct({
+registerVolterProduct({
 	id: 'game-editor',
 	layout: {
 		sidebarWidth: 260,
 		containers: [
 			{
-				id: 'workbench.view.vgai',
+				id: 'workbench.view.volter',
 				title: 'Game',
 				location: 'sidebar',
 				views: [
@@ -88,39 +88,39 @@ registerVgaiProduct({
 				],
 			},
 			{
-				id: 'workbench.view.vgai.inspector',
+				id: 'workbench.view.volter.inspector',
 				title: 'Inspector',
 				location: 'auxiliarybar',
 				views: [{ part: 'properties', title: 'Inspector', weight: 100 }],
 			},
 		],
 	},
-	title: localize('vgaiGameTitle', "Volter Game Editor"),
+	title: localize('volterGameTitle', "Volter Game Editor"),
 	// The workbench's own trust prompt, in this product's words: a game project runs its own
 	// code the moment it opens — its contributions from its `node_modules`, its dev server, and
 	// the game itself in the pane.
-	trustSentence: localize('vgaiGameTrustRequest', "Volter Game Editor runs this project's own code — its editor contributions, its dev server and its game. Trust this folder to open it."),
+	trustSentence: localize('volterGameTrustRequest', "Volter Game Editor runs this project's own code — its editor contributions, its dev server and its game. Trust this folder to open it."),
 	// THIS PRODUCT'S OWN SPLASH (F4). The kit owns the cover's mechanism — when it goes up,
 	// that it comes away whole, what a refusal looks like; this is the picture inside it, in
 	// Classic's own palette and this product's own words, drawn with no image to fetch so the
 	// first painted frame is already this.
-	cover(host: HTMLElement, context: VgaiProductCoverContext): VgaiProductCover {
-		const root = $('.vgai-game-cover');
+	cover(host: HTMLElement, context: VolterProductCoverContext): VolterProductCover {
+		const root = $('.volter-game-cover');
 		// THE MARK, built as ELEMENTS. Not `innerHTML` — the page carries a Trusted Types
 		// policy and the workbench's own code never assigns markup — and not a file either,
 		// because an image to fetch is a frame to wait for.
-		const mark = $.SVG<SVGElement>('svg', { class: 'vgai-game-cover-mark', viewBox: '0 0 48 48', 'aria-hidden': 'true' });
+		const mark = $.SVG<SVGElement>('svg', { class: 'volter-game-cover-mark', viewBox: '0 0 48 48', 'aria-hidden': 'true' });
 		mark.append(
 			$.SVG<SVGElement>('rect', { x: '4', y: '4', width: '40', height: '40', rx: '9', fill: '#242424', stroke: '#333333' }),
 			$.SVG<SVGElement>('path', { d: 'M20 16 L34 24 L20 32 Z', fill: '#579eff' }),
 		);
-		const title = $('.vgai-game-cover-title');
-		title.textContent = localize('vgaiGameCoverTitle', "Game");
-		const folder = $('.vgai-game-cover-folder');
+		const title = $('.volter-game-cover-title');
+		title.textContent = localize('volterGameCoverTitle', "Game");
+		const folder = $('.volter-game-cover-folder');
 		folder.textContent = context.folderName;
-		const state = $('.vgai-game-cover-state');
-		state.textContent = localize('vgaiGameCoverStarting', "Starting the editor…");
-		root.append(mark, title, folder, $('.vgai-game-cover-rail'), state);
+		const state = $('.volter-game-cover-state');
+		state.textContent = localize('volterGameCoverStarting', "Starting the editor…");
+		root.append(mark, title, folder, $('.volter-game-cover-rail'), state);
 		host.appendChild(root);
 		splash = { say: (text: string) => { state.textContent = text; } };
 		return {
@@ -134,7 +134,7 @@ registerVgaiProduct({
 	// mount resolving is the EDITOR being assembled — the project's own modules still have to
 	// load and the scene still has to draw, and the editor's own "No document open yet" is
 	// what a person would otherwise watch in that window.
-	async ready(context: VgaiProductMountContext): Promise<void> {
+	async ready(context: VolterProductMountContext): Promise<void> {
 		const registry = context.mount['documents'] as DocumentsRegistry | undefined;
 		// A bridge without the door is a MISSING door: with nothing to watch, the mount
 		// resolving is the answer, which is what this product did before `ready` existed.
@@ -144,7 +144,7 @@ registerVgaiProduct({
 		if (registry.list().length === 0) { return; }
 		const open = (): boolean => openDocument(registry);
 		if (!open()) {
-			splash?.say(localize('vgaiGameCoverWaiting', "Opening the game…"));
+			splash?.say(localize('volterGameCoverWaiting', "Opening the game…"));
 			await new Promise<void>((resolve, reject) => {
 				let unsubscribe: (() => void) | undefined;
 				let timer: number | undefined;
@@ -158,7 +158,7 @@ registerVgaiProduct({
 				};
 				timer = mainWindow.setTimeout(() => {
 					stop();
-					reject(new Error(localize('vgaiGameCoverTimedOut', "No document opened within {0}s. The project's own modules load through the editor session; `volter-game-editor console` is where it says why.", Math.round(GAME_OPEN_BUDGET_MS / 1000))));
+					reject(new Error(localize('volterGameCoverTimedOut', "No document opened within {0}s. The project's own modules load through the editor session; `volter-game-editor console` is where it says why.", Math.round(GAME_OPEN_BUDGET_MS / 1000))));
 				}, GAME_OPEN_BUDGET_MS);
 				unsubscribe = registry.subscribe?.(() => { if (open()) { stop(); resolve(); } });
 				// One more read after subscribing: the document can land between the check
@@ -169,16 +169,16 @@ registerVgaiProduct({
 		// DRAWN, not merely registered — the pane paints the active document on the frame
 		// after the registry names it, so the cover lifts onto the game and not onto the empty
 		// pane it was covering.
-		splash?.say(localize('vgaiGameCoverDrawing', "Drawing…"));
+		splash?.say(localize('volterGameCoverDrawing', "Drawing…"));
 		await new Promise<void>((resolve) => mainWindow.requestAnimationFrame(() => mainWindow.requestAnimationFrame(() => resolve())));
 	},
-	mount(context: VgaiProductMountContext): void {
-		// THE GAME SKEW'S THREE FRAME ANSWERS (vgaiGameSkew.ts, U2). The bridge publishes its
+	mount(context: VolterProductMountContext): void {
+		// THE GAME SKEW'S THREE FRAME ANSWERS (volterGameSkew.ts, U2). The bridge publishes its
 		// half beside the kit's doors; a bridge without it is a missing door rather than a
 		// crash, which is the same rule every other door here follows.
-		const bridge = context.mount['game'] as VgaiGameBridge | undefined;
+		const bridge = context.mount['game'] as VolterGameBridge | undefined;
 		if (!bridge) { return; }
-		context.store.add(context.instantiationService.createInstance(VgaiGameSkew, bridge, {
+		context.store.add(context.instantiationService.createInstance(VolterGameSkew, bridge, {
 			pane: context.ids.pane,
 			hierarchyView: context.ids.hierarchyView,
 			inspectorView: context.ids.inspectorView,