@volter/game-editor 0.5.68 → 0.5.70

package/LICENSE

@@ -1,25 +1,24 @@
                     NOTICE — ONE SUBTREE IS EXCLUDED FROM THIS GRANT
 
-`packages/editor` is licensed under the GNU Affero General Public License,
+`packages/game-editor` is licensed under the GNU Affero General Public License,
 version 3 only, whose text follows — with ONE exception, stated here because a
 reader who finds our code inside their own MIT game needs to find this line.
-`packages/editor/catalog/project-source/` IS NOT UNDER THE AGPL. It is
-licensed MIT (`packages/editor/catalog/project-source/LICENSE`, the same text
-the starter template carries), and it is excluded from the grant below.
+`packages/game-editor/catalog/project-source/` IS NOT UNDER THE AGPL. It is
+licensed MIT (`packages/game-editor/catalog/project-source/LICENSE`, the same
+text the starter template carries), and it is excluded from the grant below.
 
 That subtree is the CAPABILITY DISTRIBUTION: source whose whole purpose is to
 be copied, byte for byte, out of this package and into projects that are not
-ours. `vgai add <id>` copies a capability's declared files into a user's game,
-and `npm run capabilities:sync` copies the same bytes into the MIT starter
-template (`packages/editor/template/`) — the two copies are identical, which
-`capabilities:sync -- --check` proves file by file. The copy becomes the
+ours. `volter-game-editor add <id>` copies a capability's declared files into a
+user's game, and the MIT starter template (`packages/game-editor/template/`)
+carries the same bytes for the capabilities it starts with. The copy becomes the
 project's, editing it is the entire point, and a person must be able to
 relicense their game under any terms they choose. So the licence is attached at
 the source: the file does not change licence on the way into a game, because it
 was never AGPL to begin with.
 
-Everything else in `packages/editor` — the editor application that does the
-copying — is governed by the AGPL text below.
+Everything else in `packages/game-editor` — the editor application that does
+the copying — is governed by the AGPL text below.
 
 --------------------------------------------------------------------------
 

package/LICENSE-BLENDER

@@ -1,6 +1,6 @@
                     NOTICE — WHAT THIS PACKAGE IS, AND WHOSE IT IS
 
-This package (`@vgai/blender`) is the EDITOR-SIDE half of Blender in the tab:
+This package (`@volter/editor-blender`) is the EDITOR-SIDE half of Blender in the tab:
 the Model document and its presenters, the Properties tabs, the outliner, the
 node and UV editors, the display transforms, the sky, the status items, the
 layouts, the finder and the Blender LOOK. Our code here is ours. Its ICON
@@ -57,7 +57,7 @@ package is:
 that means the whole package must be conveyed under terms that satisfy both.
 Both licence texts follow: the AGPL first, then the GPL.
 
-This package is NOT `@vgai/blender-engine`, which is Blender ITSELF compiled to
+This package is NOT `@volter/blender-engine`, which is Blender ITSELF compiled to
 WebAssembly and is GPL-3.0-or-later in whole (`packages/blender-engine/LICENSE`).
 This package imports only that engine's wire TYPES plus the one tab-side handle
 that owns the worker; the process boundary is the package boundary

package/NOTICE

@@ -6,10 +6,10 @@ LICENSE-BLENDER preserves the integration license and attribution. The
 separately installed Blender engine has its own GPL license and
 corresponding-source requirements.
 
-Transferred from the AGPL-3.0-only vgai-engine repository at revision
+Transferred from the AGPL-3.0-only volter-engine repository at revision
 09c2749ce:
   - packages/game-editor (the product entry and its create presets)
-  - packages/create-vgai-project (the project scaffolder, in node/scaffold)
+  - the project scaffolder package (now node/scaffold)
   - packages/editor/template (template/)
   - packages/editor/template-dotfiles (template-dotfiles/)
   - packages/editor/catalog/project-source and catalog/entries (catalog/)

package/additions/canvas/package.json

@@ -0,0 +1,8 @@
+{
+  "private": true,
+  "description": "The `canvas` addition's files and the packages they import, merged into a project scaffolded with a 2D scene.",
+  "dependencies": {
+    "@pixi/react": "8.0.5",
+    "pixi.js": "^8.6.0"
+  }
+}

package/additions/canvas/src/canvas-mount.ts

@@ -0,0 +1,46 @@
+/**
+ * The standalone boot's `canvas` root mount: a `@pixi/react` `<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). Only a project with a `canvas` root
+ * carries this file and the two packages; `main.ts` reaches it through the manifest's generated
+ * module, so a game without a 2D scene imports no Pixi at all.
+ */
+
+import { Application, extend } from '@pixi/react';
+import * as PIXI from 'pixi.js';
+import { type ComponentType, createElement } from 'react';
+import { createRoot } from 'react-dom/client';
+
+extend(PIXI as unknown as Parameters<typeof extend>[0]);
+
+export interface CanvasMountOptions {
+  /** The bottom world clears opaque; a world stacked above it clears transparent. */
+  readonly bottom: boolean;
+  /** Pixi's own hit test for interactive objects, handed to the boot's input routing. */
+  readonly onHitTest: (canvas: HTMLCanvasElement, hit: (x: number, y: number) => boolean) => void;
+}
+
+export function mountCanvasRoot(layer: HTMLElement, Entry: ComponentType, options: CanvasMountOptions): void {
+  createRoot(layer).render(
+    createElement(
+      Application,
+      {
+        resizeTo: layer,
+        antialias: true,
+        resolution: globalThis.devicePixelRatio ?? 1,
+        autoDensity: true,
+        backgroundAlpha: options.bottom ? 1 : 0,
+        onInit: (app) => {
+          // Pixi points its boundary at the last rendered scene inside its own pointer handlers.
+          options.onHitTest(app.canvas, (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;
+          });
+        },
+      },
+      createElement(Entry),
+    ),
+  );
+}

package/additions/canvas/src/scene2d.tsx

@@ -0,0 +1,18 @@
+import type { Graphics } from 'pixi.js';
+import { useCallback } from 'react';
+
+/**
+ * This game's 2D scene: a `canvas` root, ordinary `@pixi/react` source, 2D game rendering (sprites,
+ * tilemaps, the 2D world). Not its UI: menus and the HUD are the React `dom` root.
+ */
+export default function Scene2D() {
+  const draw = useCallback((graphics: Graphics) => {
+    graphics.clear();
+    graphics.rect(-40, -40, 80, 80).fill({ color: 0x579eff });
+  }, []);
+  return (
+    <pixiContainer label="Scene">
+      <pixiGraphics label="Block" x={160} y={120} draw={draw} />
+    </pixiContainer>
+  );
+}

package/catalog/entries/bake.json

@@ -26,7 +26,7 @@
       "three-bvh-csg": "^0.0.18",
       "three-mesh-bvh": "^0.9.12"
     },
-    "vgaiTools": ["./src/tools/bake-module.tool.ts", "./src/tools/bake-preview.tool.ts"]
+    "volterTools": ["./src/tools/bake-module.tool.ts", "./src/tools/bake-preview.tool.ts"]
   },
   "requires": [],
   "skills": [],

package/catalog/entries/blender.json

@@ -1,11 +1,11 @@
 {
-  "description": "Blender-style modeling \u2014 TWO PACKAGES. `@volter/blender-engine` is Blender itself, compiled to WebAssembly and running headless in the editor tab's worker (GPL-3.0-or-later, because Blender is); `@volter/editor-blender` is the editor-side half that drives it: the Model document (a `.blend` the engine opens, edits and saves), the `modelsFromBlendFiles` finder, the display transforms and the Blender look \u2014 style, keymap, palette, icons and the Model/Sculpt/Texture layouts (ARCHITECTURE-CORE \u00a7Blender north star). Adding this capability declares both dependencies and copies in the starter model: `src/models/cube.blend` \u2014 a real Blender document \u2014 and `src/models/cube.py`, the bpy script that authored it, which stays in the project as the asset's source. Select the finder in `vgai.adapter.ts`: `{ finder: 'modelsFromBlendFiles', include: ['src/models/**/*.blend'] }`.",
+  "description": "Blender-style modeling \u2014 TWO PACKAGES. `@volter/blender-engine` is Blender itself, compiled to WebAssembly and running headless in the editor tab's worker (GPL-3.0-or-later, because Blender is); `@volter/editor-blender` is the editor-side half that drives it: the Model document (a `.blend` the engine opens, edits and saves), the `modelsFromBlendFiles` finder, the display transforms and the Blender look \u2014 style, keymap, palette, icons and the Model/Sculpt/Texture layouts (ARCHITECTURE-CORE \u00a7Blender north star). Adding this capability declares both dependencies and copies in the starter model: `src/models/cube.blend` \u2014 a real Blender document \u2014 and `src/models/cube.py`, the bpy script that authored it, which stays in the project as the asset's source. Select the finder in `volter.adapter.ts`: `{ finder: 'modelsFromBlendFiles', include: ['src/models/**/*.blend'] }`.",
   "files": [],
   "id": "blender",
   "packageJson": {
     "dependencies": {
-      "@volter/editor-blender": "0.1.11",
-      "@volter/blender-engine": "0.1.9"
+      "@volter/editor-blender": "0.1.13",
+      "@volter/blender-engine": "0.1.11"
     }
   },
   "requires": [

package/catalog/entries/music.json

@@ -1,5 +1,5 @@
 {
-  "description": "Music composed as code with the editor's DAW, delivered as mastered audio. Adds @volter/dawproject (a piece is a React component of DAWproject elements) and @volter/editor-dawproject (the piece document, the renderer and the checks), the vgai-music skill, and src/lib/music/music-player.ts, which plays a render's loops, section loops switched on the bar line, stems and stingers through the game's own Web Audio graph. Selects the piece finder (src/music/**/*.tsx) in vgai.adapter.ts.",
+  "description": "Music composed as code with the editor's DAW, delivered as mastered audio. Adds @volter/dawproject (a piece is a React component of DAWproject elements) and @volter/editor-dawproject (the piece document, the renderer and the checks), the volter-music skill, and src/lib/music/music-player.ts, which plays a render's loops, section loops switched on the bar line, stems and stingers through the game's own Web Audio graph. Selects the piece finder (src/music/**/*.tsx) in volter.adapter.ts.",
   "documents": [
     {
       "finder": "piecesFromModules",
@@ -15,16 +15,16 @@
   "id": "music",
   "packageJson": {
     "dependencies": {
-      "@volter/dawproject": "0.5.68",
-      "@volter/editor-dawproject": "0.5.68"
+      "@volter/dawproject": "0.5.70",
+      "@volter/editor-dawproject": "0.5.70"
     },
-    "vgaiTools": [
+    "volterTools": [
       "./src/tools/music-render.tool.ts"
     ]
   },
   "requires": [],
   "skills": [
-    "vgai-music"
+    "volter-music"
   ],
   "title": "Music (rendered pieces)",
   "version": "0.4.2"

package/catalog/project-source/LICENSE

@@ -2,20 +2,20 @@ MIT License
 
 Copyright (c) 2026 Volter AI, Inc.
 
-THIS SUBTREE IS NOT AGPL. It sits inside `packages/editor`, which is
+THIS SUBTREE IS NOT AGPL. It sits inside `packages/game-editor`, which is
 AGPL-3.0-only, and it is deliberately excluded from that grant and licensed MIT
 instead — because every file here is COPIED, byte for byte, into projects that
-are not ours. `vgai add <id>` copies a capability's declared files into a user's
-game; `npm run capabilities:sync` copies the same bytes into the MIT starter
-template (`packages/editor/template/`). The copy becomes the project's, editing
+are not ours. `volter-game-editor add <id>` copies a capability's declared files into a user's
+game, and the MIT starter template (`packages/game-editor/template/`) carries
+the same bytes for the capabilities it starts with. The copy becomes the project's, editing
 it is the entire point (the shadcn model), and the person who edits it must be
 able to relicense their game under any terms they choose. Source that lands in
 someone's game under the editor's copyleft would be a trap, so it is MIT at the
 source: the licence of the file does not change on the way in.
 
-The AGPL continues to govern the rest of `packages/editor` — the editor
+The AGPL continues to govern the rest of `packages/game-editor` — the editor
 application that does the copying. See LICENSE.md at the repository root for
-the per-package map, and `packages/editor/template/LICENSE` for the template's
+the per-package map, and `packages/game-editor/template/LICENSE` for the template's
 own copy of this grant.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

package/catalog/project-source/src/contributions/bake.kind.ts

@@ -2,11 +2,11 @@
  * The `bake` CONFIGURATION KIND (ARCHITECTURE-CORE §The project model): a
  * build-role configuration that bakes one project-authored Object3D module
  * into a GLB — the bake capability's own `project.bake.module` tool, run by
- * the host as a build. Declare one in `vgai.project.json`:
+ * the host as a build. Declare one in `volter.project.json`:
  *
  *   { "id": "cube-glb", "kind": "bake", "modulePath": "src/models/cube.ts", "name": "cube" }
  *
- * and `vgai build cage-glb` (or Export) bakes it. This module is a plain
+ * and Build Profiles (Export) bakes it. This module is a plain
  * object the HOST registers; it mounts no UI.
  */
 

package/catalog/project-source/src/contributions/builder-document.tsx

@@ -10,7 +10,7 @@ import type { BuilderState } from './builder-state';
  *
  * This is a plain helper with explicit inputs and outputs — NOT a registry, base
  * class, or generator kind. Each lib still owns its own contribution file and
- * its own `vgaiTools` entry; the file just shrinks to the handful of facts that
+ * its own `volterTools` entry; the file just shrinks to the handful of facts that
  * are genuinely its own (what to build, what it is called, and where its
  * source lives).
  */

package/catalog/project-source/src/contributions/builder-ui.tsx

@@ -1,6 +1,6 @@
 import type { CSSProperties } from 'react';
 
-export const hintStyle: CSSProperties = { color: 'var(--vgai-content-muted)', fontSize: 11 };
+export const hintStyle: CSSProperties = { color: 'var(--volter-content-muted)', fontSize: 11 };
 export const fieldLabelStyle: CSSProperties = { fontSize: 12, fontWeight: 600 };
 export const inputStyle: CSSProperties = { width: '100%', minWidth: 0, boxSizing: 'border-box' };
 
@@ -36,10 +36,10 @@ export function BuilderSliderRow({
         step={step}
         value={value}
         onChange={(event) => onChange(Number(event.target.value))}
-        style={{ width: '100%', minWidth: 0, accentColor: 'var(--vgai-accent)' }}
+        style={{ width: '100%', minWidth: 0, accentColor: 'var(--volter-accent)' }}
       />
       <input
-        className="vgai-input"
+        className="volter-input"
         type="number"
         min={min}
         max={max}

package/catalog/project-source/src/contributions/module-source.ts

@@ -115,8 +115,8 @@ export async function resolveProjectModule(
  *    from them). It is not a new convention invented here: `bakeObject3DSource`
  *    has always taken exactly `{ root, animations, dispose }` from its `build`
  *    callback, so the bake lane consumed this shape while the MODULE lane —
- *    `project.bake.module`, `project.bake.preview`, `vgai screenshot <module>`
- *    — refused it. Measured (cold fox, 2026-08-29): `vgai screenshot
+ *    `project.bake.module`, `project.bake.preview`, `volter-game-editor screenshot <module>`
+ *    — refused it. Measured (cold fox, 2026-08-29): `volter-game-editor screenshot
  *    src/lib/fox/generate.ts` died with "export 'createFox' must return a
  *    THREE.Object3D, got object", closing the fast look door to every
  *    parametric lib including the kit's own worked examples.
@@ -172,7 +172,7 @@ function asModuleBuild(built: unknown): ModuleBuild | undefined {
  * editor server, and it is a ONE-SHOT door: Node's ESM cache keys on the URL
  * and never invalidates, so inside a long-lived server it returned the first
  * version of `src/models/barrel.ts` for every later look until the server was
- * restarted (the blind modeling bench measured three `vgai restart`s in one
+ * restarted (the blind modeling bench measured three `volter-game-editor restart`s in one
  * barrel, 2026-09-05).
  */
 export async function buildFromModule(
@@ -198,7 +198,7 @@ export async function buildFromModule(
   }
   // A MODEL MODULE's builder is `build` (`lib/mesh/geometry`'s contract), so a
   // caller asking for the default export of a module that has none but has
-  // `build` gets the model — `vgai screenshot src/models/cube.ts` needs no flag.
+  // `build` gets the model — `volter-game-editor screenshot src/models/cube.ts` needs no flag.
   const exp = mod[exportName] ?? (exportName === 'default' ? mod['build'] : undefined);
   if (exp === undefined) {
     throw new ToolError(

package/catalog/project-source/src/lib/reflections/volume-reflection-material.ts

@@ -81,13 +81,13 @@ function cubeUvSamplingFunctions(): string {
     .replace(
       /\b(textureCubeUV|bilinearCubeUV)\(([^)]*)\)/g,
       (_match, name: string, args: string) =>
-        `${name === 'textureCubeUV' ? 'vgaiTextureCubeUV' : 'vgaiBilinearCubeUV'}(${args.trim()}, ${args.includes('sampler2D') ? 'vec3 ' : ''}vgaiAtlasSize)`,
+        `${name === 'textureCubeUV' ? 'volterTextureCubeUV' : 'volterBilinearCubeUV'}(${args.trim()}, ${args.includes('sampler2D') ? 'vec3 ' : ''}volterAtlasSize)`,
     )
-    .replace(/\b(getFace|getUV|roughnessToMip)\b/g, 'vgai$1')
-    .replace(/\bcubeUV_(\w+)\b/g, 'vgaiCubeUV_$1')
-    .replaceAll('CUBEUV_MAX_MIP', 'vgaiAtlasSize.z')
-    .replaceAll('CUBEUV_TEXEL_WIDTH', 'vgaiAtlasSize.x')
-    .replaceAll('CUBEUV_TEXEL_HEIGHT', 'vgaiAtlasSize.y');
+    .replace(/\b(getFace|getUV|roughnessToMip)\b/g, 'volter$1')
+    .replace(/\bcubeUV_(\w+)\b/g, 'volterCubeUV_$1')
+    .replaceAll('CUBEUV_MAX_MIP', 'volterAtlasSize.z')
+    .replaceAll('CUBEUV_TEXEL_WIDTH', 'volterAtlasSize.x')
+    .replaceAll('CUBEUV_TEXEL_HEIGHT', 'volterAtlasSize.y');
 }
 
 /**
@@ -104,21 +104,21 @@ function atlasSizeOf(texture: Texture | null): Vector3 {
 
 function probeWeight(index: number): string {
   return `
-    vec3 lp = (vgaiProbeWorldToLocal[${index}] * vec4(${IBL_WORLD_POSITION}, 1.0)).xyz;
+    vec3 lp = (volterProbeWorldToLocal[${index}] * vec4(${IBL_WORLD_POSITION}, 1.0)).xyz;
     float weight = 0.0;
-    if (vgaiProbeShape[${index}] < 0.5) {
-      vec3 edge = vgaiProbeExtents[${index}] - abs(lp);
+    if (volterProbeShape[${index}] < 0.5) {
+      vec3 edge = volterProbeExtents[${index}] - abs(lp);
       if (all(greaterThanEqual(edge, vec3(0.0)))) {
         float nearest = min(edge.x, min(edge.y, edge.z));
-        weight = vgaiProbeBlendDistance[${index}] > 0.0001
-          ? clamp(nearest / vgaiProbeBlendDistance[${index}], 0.0, 1.0)
+        weight = volterProbeBlendDistance[${index}] > 0.0001
+          ? clamp(nearest / volterProbeBlendDistance[${index}], 0.0, 1.0)
           : 1.0;
       }
     } else {
-      float edge = vgaiProbeRadius[${index}] - length(lp);
+      float edge = volterProbeRadius[${index}] - length(lp);
       if (edge >= 0.0) {
-        weight = vgaiProbeBlendDistance[${index}] > 0.0001
-          ? clamp(edge / vgaiProbeBlendDistance[${index}], 0.0, 1.0)
+        weight = volterProbeBlendDistance[${index}] > 0.0001
+          ? clamp(edge / volterProbeBlendDistance[${index}], 0.0, 1.0)
           : 1.0;
       }
     }`;
@@ -126,29 +126,29 @@ function probeWeight(index: number): string {
 
 function probeWeightBlock(index: number): string {
   return `
-  if (vgaiProbeReady[${index}] > 0.5) {${probeWeight(index)}
-    if (weight > 0.0) bestPriority = max(bestPriority, vgaiProbePriority[${index}]);
+  if (volterProbeReady[${index}] > 0.5) {${probeWeight(index)}
+    if (weight > 0.0) bestPriority = max(bestPriority, volterProbePriority[${index}]);
   }`;
 }
 
 function probeSampleBlock(index: number, roughness: string, direction: string): string {
   return `
-  if (vgaiProbeReady[${index}] > 0.5 && abs(vgaiProbePriority[${index}] - bestPriority) < 0.001) {${probeWeight(index)}
+  if (volterProbeReady[${index}] > 0.5 && abs(volterProbePriority[${index}] - bestPriority) < 0.001) {${probeWeight(index)}
     if (weight > 0.0) {
-      vec3 probeDirection = (vgaiProbeWorldToLocal[${index}] * vec4(${direction}, 0.0)).xyz;
-      if (vgaiProbeParallax[${index}] > 0.5) {
-        vec3 boxPos = lp - vgaiProbeParallaxOffset[${index}];
+      vec3 probeDirection = (volterProbeWorldToLocal[${index}] * vec4(${direction}, 0.0)).xyz;
+      if (volterProbeParallax[${index}] > 0.5) {
+        vec3 boxPos = lp - volterProbeParallaxOffset[${index}];
         vec3 safeDirection = sign(probeDirection) * max(abs(probeDirection), vec3(0.00001));
-        vec3 rayMax = (vgaiProbeParallaxExtents[${index}] - boxPos) / safeDirection;
-        vec3 rayMin = (-vgaiProbeParallaxExtents[${index}] - boxPos) / safeDirection;
+        vec3 rayMax = (volterProbeParallaxExtents[${index}] - boxPos) / safeDirection;
+        vec3 rayMin = (-volterProbeParallaxExtents[${index}] - boxPos) / safeDirection;
         vec3 rayDistance = mix(rayMin, rayMax, greaterThan(safeDirection, vec3(0.0)));
         float nearestFace = min(rayDistance.x, min(rayDistance.y, rayDistance.z));
         probeDirection = boxPos + safeDirection * nearestFace
-          + vgaiProbeParallaxOffset[${index}] - vgaiProbeCaptureOffset[${index}];
+          + volterProbeParallaxOffset[${index}] - volterProbeCaptureOffset[${index}];
       }
-      accumulated += vgaiTextureCubeUV(
-        vgaiProbeMap${index}, probeDirection, ${roughness}, vgaiProbeAtlasSize[${index}]
-      ).rgb * vgaiProbeIntensity[${index}] * weight;
+      accumulated += volterTextureCubeUV(
+        volterProbeMap${index}, probeDirection, ${roughness}, volterProbeAtlasSize[${index}]
+      ).rgb * volterProbeIntensity[${index}] * weight;
       totalWeight += weight;
     }
   }`;
@@ -157,7 +157,7 @@ function probeSampleBlock(index: number, roughness: string, direction: string):
 function volumeReflectionShader(probeCount: number): string {
   const samplers = Array.from(
     { length: probeCount },
-    (_, index) => `uniform sampler2D vgaiProbeMap${index};`,
+    (_, index) => `uniform sampler2D volterProbeMap${index};`,
   ).join('\n');
   const weights = Array.from({ length: probeCount }, (_, index) => probeWeightBlock(index)).join(
     '\n',
@@ -171,25 +171,25 @@ function volumeReflectionShader(probeCount: number): string {
   return `${baseIblFunctions()}
 ${cubeUvSamplingFunctions()}
 #ifdef USE_ENVMAP
-uniform float vgaiProbeReady[${probeCount}];
-uniform mat4 vgaiProbeWorldToLocal[${probeCount}];
-uniform vec3 vgaiProbeExtents[${probeCount}];
-uniform vec3 vgaiProbeParallaxExtents[${probeCount}];
-uniform vec3 vgaiProbeParallaxOffset[${probeCount}];
-uniform vec3 vgaiProbeCaptureOffset[${probeCount}];
-uniform vec3 vgaiProbeAtlasSize[${probeCount}];
-uniform float vgaiProbeShape[${probeCount}];
-uniform float vgaiProbeRadius[${probeCount}];
-uniform float vgaiProbeBlendDistance[${probeCount}];
-uniform float vgaiProbePriority[${probeCount}];
-uniform float vgaiProbeIntensity[${probeCount}];
-uniform float vgaiProbeParallax[${probeCount}];
-uniform float vgaiBaseEnvironment;
+uniform float volterProbeReady[${probeCount}];
+uniform mat4 volterProbeWorldToLocal[${probeCount}];
+uniform vec3 volterProbeExtents[${probeCount}];
+uniform vec3 volterProbeParallaxExtents[${probeCount}];
+uniform vec3 volterProbeParallaxOffset[${probeCount}];
+uniform vec3 volterProbeCaptureOffset[${probeCount}];
+uniform vec3 volterProbeAtlasSize[${probeCount}];
+uniform float volterProbeShape[${probeCount}];
+uniform float volterProbeRadius[${probeCount}];
+uniform float volterProbeBlendDistance[${probeCount}];
+uniform float volterProbePriority[${probeCount}];
+uniform float volterProbeIntensity[${probeCount}];
+uniform float volterProbeParallax[${probeCount}];
+uniform float volterBaseEnvironment;
 ${samplers}
 
 vec3 getIBLIrradiance(const in vec3 normal) {
 #ifdef ENVMAP_TYPE_CUBE_UV
-  vec3 baseIrradiance = getBaseIBLIrradiance(normal) * vgaiBaseEnvironment;
+  vec3 baseIrradiance = getBaseIBLIrradiance(normal) * volterBaseEnvironment;
   vec3 worldNormal = inverseTransformDirection(normal, viewMatrix);
   float bestPriority = -1000000.0;
 ${weights}
@@ -206,7 +206,7 @@ ${irradiance}
 
 vec3 getIBLRadiance(const in vec3 viewDir, const in vec3 normal, const in float roughness) {
 #ifdef ENVMAP_TYPE_CUBE_UV
-  vec3 baseRadiance = getBaseIBLRadiance(viewDir, normal, roughness) * vgaiBaseEnvironment;
+  vec3 baseRadiance = getBaseIBLRadiance(viewDir, normal, roughness) * volterBaseEnvironment;
   vec3 reflected = reflect(-viewDir, normal);
   reflected = normalize(mix(reflected, normal, roughness * roughness));
   vec3 worldReflect = inverseTransformDirection(reflected, viewMatrix);
@@ -236,60 +236,60 @@ function writeProbeUniforms(
     shader.uniforms[name] = { value };
   };
   values(
-    'vgaiProbeReady',
+    'volterProbeReady',
     probes.map((probe) => Number(probe.ready && !capturing)),
   );
   values(
-    'vgaiProbeWorldToLocal',
+    'volterProbeWorldToLocal',
     probes.map((probe) => probe.worldToLocal),
   );
   values(
-    'vgaiProbeExtents',
+    'volterProbeExtents',
     probes.map((probe) => probe.extents),
   );
   values(
-    'vgaiProbeParallaxExtents',
+    'volterProbeParallaxExtents',
     probes.map((probe) => probe.parallaxExtents),
   );
   values(
-    'vgaiProbeParallaxOffset',
+    'volterProbeParallaxOffset',
     probes.map((probe) => probe.parallaxOffset),
   );
   values(
-    'vgaiProbeCaptureOffset',
+    'volterProbeCaptureOffset',
     probes.map((probe) => probe.captureOffset),
   );
   values(
-    'vgaiProbeAtlasSize',
+    'volterProbeAtlasSize',
     probes.map((probe) => atlasSizeOf(probe.texture)),
   );
   values(
-    'vgaiProbeShape',
+    'volterProbeShape',
     probes.map((probe) => Number(probe.mark.config.shape === 'sphere')),
   );
   values(
-    'vgaiProbeRadius',
+    'volterProbeRadius',
     probes.map((probe) => Math.max(0.01, probe.mark.config.radius)),
   );
   values(
-    'vgaiProbeBlendDistance',
+    'volterProbeBlendDistance',
     probes.map((probe) => Math.max(0, probe.mark.config.blendDistance)),
   );
   values(
-    'vgaiProbePriority',
+    'volterProbePriority',
     probes.map((probe) => probe.mark.config.priority),
   );
   values(
-    'vgaiProbeIntensity',
+    'volterProbeIntensity',
     probes.map((probe) => Math.max(0, probe.mark.config.intensity)),
   );
   values(
-    'vgaiProbeParallax',
+    'volterProbeParallax',
     probes.map((probe) => Number(probe.mark.config.parallaxProjection)),
   );
-  values('vgaiBaseEnvironment', baseEnvironment ? 1 : 0);
+  values('volterBaseEnvironment', baseEnvironment ? 1 : 0);
   probes.forEach((probe, index) => {
-    values(`vgaiProbeMap${index}`, probe.texture);
+    values(`volterProbeMap${index}`, probe.texture);
   });
 }
 
@@ -377,7 +377,7 @@ function ownVolumeReflectionMaterial<T extends MeshStandardMaterial>(
     installedCount = count;
     override = overrideMaterialIbl(material, {
       fragment: () => volumeReflectionShader(count),
-      cacheKey: () => `vgai-volume-reflections:${count}`,
+      cacheKey: () => `volter-volume-reflections:${count}`,
       onCompile: (shader) =>
         writeProbeUniforms(shader, eligible, hasBaseEnvironment(), isCapturing),
     });

package/catalog/project-source/src/lib/static-batch/Frozen.tsx

@@ -64,7 +64,7 @@ export function Frozen({ name = 'Frozen', children, ...props }: FrozenProps) {
     const batch = freezeSubtree(root, name);
     // Degrade LOUDLY — a wrapper that silently declined most of its subtree
     // looks identical to one that worked. Under the dev gate, though: this is
-    // an authoring signal (`vgai status` reports console warnings, which is
+    // an authoring signal (`volter-game-editor status` reports console warnings, which is
     // where the building agent already looks), and a player's console is not
     // where it belongs.
     if (import.meta.env.DEV) {

package/catalog/project-source/src/lib/static-batch/mutation-watch.ts

@@ -82,7 +82,7 @@ export interface FrozenMutationWatch {
 }
 
 function warnOnConsole(message: string): void {
-  // biome-ignore lint/suspicious/noConsole: console is this tripwire's vgai-status channel.
+  // biome-ignore lint/suspicious/noConsole: console is this tripwire's volter-status channel.
   console.warn(message);
 }
 

package/catalog/project-source/src/tools/bake-preview.tool.ts

@@ -10,14 +10,14 @@
  * asset namespace is untouched — a look is not an export
  * (ARCHITECTURE-CORE §Agent surface, the look-verb decision).
  *
- * The PNGs land under `<project>/.vgai/screenshots/` — the same
- * machine-written-evidence namespace `vgai screenshot` already writes to,
+ * The PNGs land under `<project>/.volter/screenshots/` — the same
+ * machine-written-evidence namespace `volter-game-editor screenshot` already writes to,
  * beside the run artifacts and the session file, and gitignored like the rest of
  * it.
  *
  * A live session is REQUIRED and cannot be worked around: Node has no GPU, so
  * "build the model here, photograph it there" is the whole shape of this
- * tool. With no session it refuses by name and points at `vgai edit`, rather
+ * tool. With no session it refuses by name and points at `volter-game-editor edit`, rather
  * than building an Object3D nobody will ever see.
  */
 
@@ -47,7 +47,7 @@ export const NO_EDITOR_SESSION_ERROR: ToolErrorDefinition = {
   code: 'NO_EDITOR_SESSION',
   summary:
     'No live editor session for this project — rasterization happens in the editor, so a look ' +
-    'is impossible without one. Run `vgai edit <project>`.',
+    'is impossible without one. Run `volter-game-editor edit <project>`.',
   data: z.object({ projectRoot: z.string(), reason: z.string() }),
 };
 
@@ -155,7 +155,7 @@ export function orbitShotSet(frames: number): {
 export const BakePreviewResultSchema = z.object({
   directory: z
     .string()
-    .describe('Project-relative directory the PNGs were written to, under .vgai/screenshots/.'),
+    .describe('Project-relative directory the PNGs were written to, under .volter/screenshots/.'),
   files: z
     .array(z.string())
     .describe(
@@ -326,7 +326,7 @@ export const tool = defineTool({
     'builder to get a native THREE.Object3D, exports it to an IN-MEMORY GLB, and hands those ' +
     "bytes to the live editor session's Asset Lab for the standard four-view contact sheet — " +
     'or, with `orbit`, for that many evenly spaced headings around the subject. ' +
-    'The PNGs are written under <project>/.vgai/screenshots/. Nothing is written under ' +
+    'The PNGs are written under <project>/.volter/screenshots/. Nothing is written under ' +
     'public/, no provenance record is created, and no GLB reaches disk — this is the read-only ' +
     'sibling of project.bake.module, for looking at a builder while iterating on it.',
   input: BakePreviewInputSchema,
@@ -348,7 +348,7 @@ export const tool = defineTool({
   permission: {
     risk: 'read',
     summary:
-      'Imports and runs a project module, then writes look-only PNGs under .vgai/screenshots/. ' +
+      'Imports and runs a project module, then writes look-only PNGs under .volter/screenshots/. ' +
       'Never touches the project asset namespace.',
   },
   async impl(input, ctx) {
@@ -371,7 +371,7 @@ export const tool = defineTool({
       throw new ToolError(
         NO_EDITOR_SESSION_ERROR.code,
         'project.bake.preview renders through the live editor session (Node has no GPU), and ' +
-          `none is open for this project. Run \`vgai edit ${projectRoot}\` first. (${reason})`,
+          `none is open for this project. Run \`volter-game-editor edit ${projectRoot}\` first. (${reason})`,
         { projectRoot, reason },
       );
     }
@@ -424,7 +424,7 @@ export const tool = defineTool({
     const capture = orbit ?? (await session.editor.assetPreview(source, options));
 
     const directory = join(
-      '.vgai',
+      '.volter',
       'screenshots',
       `${bakePreviewSlug(input.modulePath, input.exportName)}-${new Date()
         .toISOString()