@volter/game-editor 0.5.67 → 0.5.69

package/LICENSE

@@ -9,7 +9,7 @@ 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,
+ours. `volter-game-editor 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

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.10",
-      "@volter/blender-engine": "0.1.9"
+      "@volter/editor-blender": "0.1.12",
+      "@volter/blender-engine": "0.1.10"
     }
   },
   "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,17 +15,17 @@
   "id": "music",
   "packageJson": {
     "dependencies": {
-      "@volter/dawproject": "0.5.67",
-      "@volter/editor-dawproject": "0.5.67"
+      "@volter/dawproject": "0.5.69",
+      "@volter/editor-dawproject": "0.5.69"
     },
-    "vgaiTools": [
+    "volterTools": [
       "./src/tools/music-render.tool.ts"
     ]
   },
   "requires": [],
   "skills": [
-    "vgai-music"
+    "volter-music"
   ],
   "title": "Music (rendered pieces)",
-  "version": "0.4.1"
+  "version": "0.4.2"
 }

package/catalog/project-source/LICENSE

@@ -5,7 +5,7 @@ Copyright (c) 2026 Volter AI, Inc.
 THIS SUBTREE IS NOT AGPL. It sits inside `packages/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
+are not ours. `volter-game-editor 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
 it is the entire point (the shadcn model), and the person who edits it must be

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/music/music-player.ts

@@ -1,7 +1,7 @@
 /**
  * The game's MUSIC, played from a piece's render (`render-piece`'s output folder): the looped
- * mix, a section loop per `<Marker>` (`--sections`), the stems, and one-shot stingers
- * (`--one-shot`), all through the game's own Web Audio graph.
+ * mix, a section loop per `<Marker>` (`--sections`), a loop per launcher `<Scene>`, the stems,
+ * and one-shot stingers (`--one-shot`), all through the game's own Web Audio graph.
  *
  *   horizontal   `queue('Battle')` switches loops on the next bar line of what is playing
  *                (`barSeconds` in the report), or at its loop end; the old loop fades out
@@ -27,6 +27,8 @@ export interface MusicRender {
   readonly barSeconds: readonly number[];
   /** A section per marker: `start` is its second in the whole piece, where its loop begins. */
   readonly sections?: readonly { readonly name: string; readonly start: number; readonly seconds: number; readonly file: string; readonly fileM4a?: string }[];
+  /** A loop per launcher scene (one state of the music), `bars` whole bars from its own start. */
+  readonly scenes?: readonly { readonly name: string; readonly bars: number; readonly seconds: number; readonly file: string; readonly fileM4a?: string }[];
   readonly stems?: { readonly files?: readonly { readonly track: string; readonly file: string; readonly fileM4a?: string }[] };
 }
 
@@ -35,7 +37,7 @@ export interface MusicRender {
  * that cannot decode Vorbis (Safari on iOS before 17.4) gets the same loop from its `.m4a`.
  */
 export async function loadMusic(context: BaseAudioContext, baseUrl: string, render: MusicRender): Promise<Map<string, AudioBuffer>> {
-  const entries = [render, ...(render.sections ?? []), ...(render.stems?.files ?? [])];
+  const entries = [render, ...(render.sections ?? []), ...(render.scenes ?? []), ...(render.stems?.files ?? [])];
   const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
   const decode = async (file: string): Promise<AudioBuffer> => {
     const response = await fetch(new URL(file, base));
@@ -65,7 +67,7 @@ interface Playing {
 export interface MusicPlayer {
   /** The player's output; connect it where the game's music bus is. */
   readonly output: GainNode;
-  /** Start a section's loop (by marker name), or the whole piece's with `null`, at `when` (now). */
+  /** Start a section's loop (by marker name) or a scene's (by scene name), or the whole piece's with `null`, at `when` (now). */
   play(section: string | null, options?: { stems?: boolean; when?: number }): void;
   /** Switch to another loop at the next bar line, or at the playing loop's end. Returns the context time it switches. */
   queue(section: string | null, options?: { at?: 'bar' | 'end'; fade?: number; stems?: boolean }): number;
@@ -104,20 +106,24 @@ export function createMusicPlayer(options: {
   };
 
   const start = (name: string | null, stems: boolean, when: number): Playing => {
-    const section = name === null ? null : render.sections?.find((candidate) => candidate.name === name);
-    if (name !== null && !section) throw new Error(`No section "${name}" in this render (render it with --sections).`);
-    if (stems && section) throw new Error('Stems are rendered for the whole piece, not per section.');
-    const files = stems ? (render.stems?.files ?? []).map((stem) => [stem.track, stem.file] as const) : [[name ?? 'mix', section?.file ?? render.file] as const];
+    const section = name === null ? undefined : render.sections?.find((candidate) => candidate.name === name);
+    const scene = name === null ? undefined : render.scenes?.find((candidate) => candidate.name === name);
+    if (section && scene) throw new Error(`"${name}" names both a section and a scene in this render; rename one of them.`);
+    if (name !== null && !section && !scene) {
+      throw new Error(`No section or scene "${name}" in this render (sections render with --sections; scenes always render).`);
+    }
+    if (stems && (section || scene)) throw new Error('Stems are rendered for the whole piece, not per section or scene.');
+    const files = stems ? (render.stems?.files ?? []).map((stem) => [stem.track, stem.file] as const) : [[name ?? 'mix', (section ?? scene)?.file ?? render.file] as const];
     if (files.length === 0) throw new Error('This render has no stems.');
     // The loop is the decoded buffer's own length (the context may resample the file); its bar
     // lines are the piece's that fall inside it, from its start. A marker off a downbeat starts a
     // loop mid-bar, and its bar lines are still the piece's.
     const seconds = buffer(files[0]![1]).duration;
     const from = section?.start ?? 0;
-    const bars = [
-      ...render.barSeconds.map((second) => second - from).filter((second) => second >= -1e-6 && second < seconds - 1e-3),
-      seconds,
-    ];
+    // A scene's loop is its own: its bar lines divide it evenly, from its start.
+    const bars = scene
+      ? [...Array.from({ length: scene.bars }, (_, bar) => (bar * seconds) / scene.bars), seconds]
+      : [...render.barSeconds.map((second) => second - from).filter((second) => second >= -1e-6 && second < seconds - 1e-3), seconds];
     const gain = context.createGain();
     gain.connect(output);
     const sources = new Map<string, { source: AudioBufferSourceNode; gain: GainNode }>();

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);
 }