@volter/game-editor 0.5.68 → 0.5.69

package/template/server/rooms/game-room.ts

@@ -7,7 +7,7 @@
  *
  * Messages (client → server only):
  *   position  { x, y, z }   — client movement input
- *   __vgai:debugCommand { name, args, requestId } — a `locus: 'server'`
+ *   __volter:debugCommand { name, args, requestId } — a `locus: 'server'`
  *     debug command's client leg (the "Multiplayer locus" note,
  *     build plan Task 4.2); see
  *     `DEBUG_COMMANDS`/`onCreate` below.
@@ -155,9 +155,9 @@ export class GameRoom extends Room {
     // Off by default (FROZEN DECISION: env-var OR room-option) — the loopback harness/
     // the loopback harness (`../loopback.ts`) opt in via the room option; a
     // plain `npm run server` boot never accepts debug commands unless
-    // VGAI_ALLOW_DEBUG_COMMANDS is set in its environment.
+    // VOLTER_ALLOW_DEBUG_COMMANDS is set in its environment.
     const debugCommandsAllowed =
-      options?.allowDebugCommands === true || Boolean(process.env['VGAI_ALLOW_DEBUG_COMMANDS']);
+      options?.allowDebugCommands === true || Boolean(process.env['VOLTER_ALLOW_DEBUG_COMMANDS']);
 
     // Handle client messages
     this.onMessage('position', (client, position: { x: number; y: number; z: number }) => {
@@ -170,10 +170,10 @@ export class GameRoom extends Room {
     });
 
     this.onMessage(
-      '__vgai:debugCommand',
+      '__volter:debugCommand',
       (client, message: { name: string; args?: unknown[]; requestId: string }) => {
         if (!debugCommandsAllowed) {
-          client.send('__vgai:debugCommandResult', {
+          client.send('__volter:debugCommandResult', {
             requestId: message.requestId,
             ok: false,
             error: 'debug commands disabled',
@@ -182,7 +182,7 @@ export class GameRoom extends Room {
         }
         const handler = DEBUG_COMMANDS[message.name];
         if (!handler) {
-          client.send('__vgai:debugCommandResult', {
+          client.send('__volter:debugCommandResult', {
             requestId: message.requestId,
             ok: false,
             error: `debug: no server command registered under "${message.name}"`,
@@ -191,13 +191,13 @@ export class GameRoom extends Room {
         }
         try {
           const result = handler(this, client, message.args ?? []);
-          client.send('__vgai:debugCommandResult', {
+          client.send('__volter:debugCommandResult', {
             requestId: message.requestId,
             ok: true,
             result,
           });
         } catch (err) {
-          client.send('__vgai:debugCommandResult', {
+          client.send('__volter:debugCommandResult', {
             requestId: message.requestId,
             ok: false,
             error: err instanceof Error ? err.message : String(err),

package/template/server/rooms.ts

@@ -10,6 +10,6 @@ import { ArenaRoom } from './rooms/arena-room.js';
 import { GameRoom } from './rooms/game-room.js';
 
 export const rooms = [
-  { name: 'game_room', handler: GameRoom, matchBy: ['vgaiPlaytest'] },
-  { name: 'arena_room', handler: ArenaRoom, matchBy: ['vgaiPlaytest'] },
+  { name: 'game_room', handler: GameRoom, matchBy: ['volterPlaytest'] },
+  { name: 'arena_room', handler: ArenaRoom, matchBy: ['volterPlaytest'] },
 ];

package/template/src/bot/QaTester.tsx

@@ -4,7 +4,7 @@
  * tick IS frame work. Everything else about the tester (its doors, its run
  * state, its repertoire) is plain application code in
  * `src/bot/tester-station.ts`, reached directly as a running module by the
- * Tester contribution and `vgai eval`.
+ * Tester contribution and `volter-game-editor eval`.
  *
  * The tester's hands run in the INPUT phase — before everything. Fiber sorts
  * `useFrame` callbacks ascending, and this world's own behavior hooks sit at

package/template/src/bot/bot-station.ts

@@ -3,10 +3,10 @@
  *
  * The resident QA tester (`src/bot/tester-station.ts`) plays this game from
  * INSIDE the page, directed live from the REPL through `hireTester`. This module
- * holds what it is doing so the game's Tester surface and `vgai eval`
+ * holds what it is doing so the game's Tester surface and `volter-game-editor eval`
  * both watch one run, and it implements the operator controls the tester
  * honors between steps. This module is plain application state and imports no
- * vgai API; its exports are the whole control surface.
+ * volter API; its exports are the whole control surface.
  *
  * `getBotStatus()` reads `{active, seat, goal, step, phase, progress,
  * waitingOn, note, seed, directive}`. `pauseBot()`, `resumeBot()`,

package/template/src/bot/tester-station.ts

@@ -23,7 +23,7 @@
  * (`seatTester`) and gives it back (`releaseTester`); it never reasons about
  * the rule itself.
  *
- * No vgai import anywhere: the tester's hands are the project's own input
+ * No volter import anywhere: the tester's hands are the project's own input
  * store (`src/input.ts`), typed through `tester-run.ts`'s narrow
  * `TesterInputTarget`.
  */

package/template/src/contributions/README.md

@@ -87,7 +87,7 @@ project inherits may error, and these three THROW until they are rewritten
   answers this game's development questions. A raw event listing does not
   fulfill the contribution; never import live simulation state into Analytics.
 
-All three stubs emit `VGAI_STUB_UNIMPLEMENTED`. That warning keeps the live
+All three stubs emit `VOLTER_STUB_UNIMPLEMENTED`. That warning keeps the live
 console red, and `npm run check-idioms` reports it as unfinished work. Remove
 the sentinel only by replacing the stub with the game's real surface (or by
 honestly deleting the optional Data surface), not by silencing the warning.

package/template/src/contributions/analytics.analytics.tsx

@@ -16,7 +16,7 @@ export const point = 'workspace.analytics';
 export const title = 'Analytics';
 
 const unfinished =
-  'VGAI_STUB_UNIMPLEMENTED: src/contributions/analytics.analytics.tsx — replace this stub with game-specific analysis of recorded Gameplay Sessions; playback is provided by the editor.';
+  'VOLTER_STUB_UNIMPLEMENTED: src/contributions/analytics.analytics.tsx — replace this stub with game-specific analysis of recorded Gameplay Sessions; playback is provided by the editor.';
 
 // biome-ignore lint/suspicious/noConsole: unopened starter obligations remain visible in the editor console
 console.error(unfinished);

package/template/src/contributions/data.document.tsx

@@ -4,7 +4,7 @@
  * An OBLIGATION, not an implementation: the game's numbers and content
  * tables (`src/data/` — plain typed TS literals) must be viewable, with
  * their derived picture, by the humans collaborating on this game. How is
- * yours. REWRITE THIS FILE WHOLE; the error below holds `vgai console`
+ * yours. REWRITE THIS FILE WHOLE; the error below holds `volter-game-editor console`
  * red until you do.
  *
  * The method: render the data modules as tables (a plain `<table>` until a
@@ -25,7 +25,7 @@ export const title = 'Data';
 
 // Module-scope on purpose — the demand is visible from editor boot.
 const unfinished =
-  "VGAI_STUB_UNIMPLEMENTED: src/contributions/data.document.tsx — render this game's data (src/data/) with its derived columns, or delete this file if the game truly has no content tables (its header says how).";
+  "VOLTER_STUB_UNIMPLEMENTED: src/contributions/data.document.tsx — render this game's data (src/data/) with its derived columns, or delete this file if the game truly has no content tables (its header says how).";
 
 // biome-ignore lint/suspicious/noConsole: unopened starter obligations remain visible in the editor console
 console.error(unfinished);

package/template/src/contributions/pages.finder.ts

@@ -3,7 +3,7 @@
  * "Documents, not scenes"): every project module under the selection's
  * `include` globs that exports a React component is a `page` document —
  * what a website is made of, the way a game is made of scenes. Select it
- * in `vgai.adapter.ts`:
+ * in `volter.adapter.ts`:
  *
  *   documents: { find: [{ finder: 'pagesFromUiModules', include: ['src/ui/**\/*page.tsx'] }] }
  *

package/template/src/contributions/tester.inspector.tsx

@@ -7,7 +7,7 @@
  * difficult situations, and judge the mechanic under test. It says nothing
  * about HOW. REWRITE THIS FILE WHOLE in the game's own vocabulary: rename it,
  * split it into several faces, and structure it the way THIS game's studio
- * would. The error below holds `vgai console` red until you do; delete it
+ * would. The error below holds `volter-game-editor console` red until you do; delete it
  * with the stub.
  *
  * Make the controller's current owner and the tester's repertoire legible.
@@ -54,7 +54,7 @@ export function match(
 // Module-scope on purpose: fires the moment the editor loads this game's
 // contributions, so the demand is visible before anyone opens the panel.
 const unfinished =
-  "VGAI_STUB_UNIMPLEMENTED: src/contributions/tester.inspector.tsx — imagine this game's tester helper surface and rewrite the file whole (its header says how).";
+  "VOLTER_STUB_UNIMPLEMENTED: src/contributions/tester.inspector.tsx — imagine this game's tester helper surface and rewrite the file whole (its header says how).";
 
 // biome-ignore lint/suspicious/noConsole: unopened starter obligations remain visible in the editor console
 console.error(unfinished);

package/template/src/contributions/use-game-modules.ts

@@ -9,7 +9,7 @@
  * `*.utility.tsx`, `*.document.tsx`), in the game's own vocabulary, added
  * when there is something to show. A contribution is ordinary React
  * reading the game's own exported modules through this hook; agents reach
- * the same modules through `vgai eval`'s
+ * the same modules through `volter-game-editor eval`'s
  * `game.run(async ({ modules }) => await modules('src/sim/host.ts'))` — `modules` is an
  * ASYNC RESOLVER taking a served path, never a table: the `await` is not
  * optional, and reading a member off the unawaited promise throws a message

package/template/src/input.ts

@@ -3,7 +3,7 @@
  * held. Mechanics read it directly ({@link actionPressed}); the QA tester
  * actuates it ({@link setVirtualAction}); the session input door
  * reaches the SAME store by importing this running module through
- * `game.run(({ modules }) => ...)`. No vgai import anywhere — input is
+ * `game.run(({ modules }) => ...)`. No volter import anywhere — input is
  * application state, and the host merely gives the developer access to the
  * module instance the game already uses.
  *

package/template/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/template/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/template/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/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/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];