@volter/editor-blender 0.1.128 → 0.1.130

package/dist-node/serving.mjs

@@ -815,6 +815,22 @@ function blenderRoutesPlugin(services) {
 
 // serving/index.ts
 var servingPlugins = (services) => [blenderRoutesPlugin(services)];
+var viewSnapshotRoutes = async () => {
+  const base = "/__editor/blender-wasm";
+  const status = await blenderWasmStatus();
+  if (!status.available) return [`${base}/status`];
+  if (status.skew === "wali") return [`${base}/status`, `${base}/runtime.idx`, `${base}/runtime.bin`, `${base}/${BLENDER_WALI_ARTIFACT}`];
+  return [`${base}/status`, ...BLENDER_WASM_FILES.map((file) => `${base}/${file}`)];
+};
+var viewSnapshotScrub = (route, body) => {
+  if (route !== "/__editor/blender-wasm/status") return body;
+  const status = JSON.parse(body);
+  delete status["dir"];
+  status["missing"] = status["available"] === true ? [] : ["The Blender engine was not recorded into this limited view."];
+  return JSON.stringify(status);
+};
 export {
-  servingPlugins
+  servingPlugins,
+  viewSnapshotRoutes,
+  viewSnapshotScrub
 };

package/host/blender-runtime-host.ts

@@ -45,17 +45,15 @@ import type {
   BlenderRnaWrite,
   BlenderUvLayout,
 } from '@volter/blender-engine/browser/rna';
-import { AGX_LOOK_TABLES, agxEncodeFrame } from '@volter/blender-engine/browser/three/blender-agx';
-import { displayTableUrl } from '@volter/blender-engine/browser/three/blender-display-lut';
-import { filmicEncodeFrame } from '@volter/blender-engine/browser/three/blender-filmic';
+import { createBlenderDisplayTransform, blenderDisplaySettingsForRender } from '@volter/blender-engine/browser/three/blender-display-transform';
 import type { BlenderRuntimeView } from '@volter/blender-engine/browser/three/blender-runtime-view';
-import { standardEncodeFrame } from '@volter/blender-engine/browser/three/blender-standard';
 import type { EditorCommandResult } from '@volter/editor-sdk/commands';
 import { editorHost } from '@volter/editor-sdk/host';
 import { invokeViewVerb, type ViewVerbContribution } from '@volter/editor-sdk/views';
 import {
   captureSceneImage,
   captureSceneLinear,
+  resolveSceneLinearDisplay,
   type LinearCaptureFrame,
 } from '@volter/editor-threejs/capture/scene';
 import { fitClipPlanes } from '@volter/editor-threejs/viewport/clip-planes';
@@ -70,21 +68,6 @@ import {
   setNodeViewState,
 } from '../src/node-view-state';
 
-/** Pinned OCIO display tables, loaded once. Missing data is a render failure. */
-const displayTables = new Map<string, Promise<Uint16Array>>();
-function displayTable(file: string): Promise<Uint16Array> {
-  let pending = displayTables.get(file);
-  if (!pending) {
-    pending = fetch(displayTableUrl(file)).then(async (response) => {
-      if (!response.ok)
-        throw new Error(`Blender display table ${file}: ${response.status} ${response.statusText}`);
-      return new Uint16Array(await response.arrayBuffer());
-    });
-    displayTables.set(file, pending);
-  }
-  return pending;
-}
-
 /** Raw bytes of a base64 payload, as the half-float words a linear frame is. */
 function halfFloatFrame(base64: string): Uint16Array {
   const binary = atob(base64);
@@ -105,36 +88,14 @@ async function displayPhotograph(
     width: number;
     height: number;
     exposure: number;
-    toneMapping: string;
+    toneMapping: RenderRequest['toneMapping'];
     look?: string;
+    gamma?: number;
     linear?: boolean;
     transparent?: boolean;
     linearInput?: { base64: string; width: number; height: number };
   },
 ): Promise<{ base64: string; mimeType: string }> {
-  const look = render.look ?? 'None';
-  const filmic = render.toneMapping === 'filmic';
-  const standard = render.toneMapping === 'none';
-  if (!standard && render.toneMapping !== 'agx' && !filmic)
-    // `neutral` is three's own curve and has no scene-linear implementation
-    // here — refused BY NAME rather than answered with a different transform.
-    throw new Error(
-      `Blender's Khronos PBR Neutral view transform has no scene-linear implementation in the ` +
-        `browser, so it cannot resolve a composited or scene-referred frame (implemented: ` +
-        `Standard, AgX, Filmic)`,
-    );
-  // Standard is a curve, not a table (`blender-standard.ts`); the other two are
-  // the config's own baked LUTs.
-  const file = standard
-    ? null
-    : filmic
-      ? 'filmic-srgb.lut'
-      : look === 'None'
-        ? 'agx-base-srgb.lut'
-        : AGX_LOOK_TABLES[look as keyof typeof AGX_LOOK_TABLES];
-  if (file === undefined)
-    throw new Error(`Blender display transform has no table for look ${look}`);
-  const lut = file ? await displayTable(file) : null;
   const provided = render.linearInput;
   const linear = provided
     ? {
@@ -145,14 +106,10 @@ async function displayPhotograph(
     : linearFrame;
   if (!linear) throw new Error('Blender display transform requires a linear capture');
   const { pixels, width, height } = linear;
-  const bytes = standard
-    ? standardEncodeFrame(pixels, width * height, render.exposure)
-    : filmic
-      ? filmicEncodeFrame(lut!, pixels, width * height, render.exposure)
-      : agxEncodeFrame(lut!, pixels, width * height, {
-          exposure: render.exposure,
-          composedLook: look !== 'None',
-        });
+  const transform = await createBlenderDisplayTransform(blenderDisplaySettingsForRender(render));
+  let bytes: Uint8Array;
+  try { bytes = resolveSceneLinearDisplay(linear, transform); }
+  finally { transform.dispose(); }
   const canvas = document.createElement('canvas');
   canvas.width = width;
   canvas.height = height;
@@ -202,19 +159,6 @@ export async function photographSnapshot(
   render: RenderRequest,
   assertCurrent: () => void = () => {},
 ): Promise<{ base64: string; mimeType: string }> {
-  // THE SCENE'S OWN VIEW TRANSFORM, for the duration of the photograph.
-  // Blender states one (`view_settings.view_transform`, AgX by default) and
-  // three.js has a curve of the same name, so the render is tone mapped the
-  // way the scene asks rather than the way the modeling viewport prefers —
-  // without this, every lit pixel differs by the gap between two unrelated
-  // curves and no difference in the image can be attributed to anything
-  // else. Python refuses a transform with no curve here, so the map is total.
-  const mappings: Record<string, THREE.ToneMapping> = {
-    none: THREE.NoToneMapping,
-    agx: THREE.AgXToneMapping,
-    neutral: THREE.NeutralToneMapping,
-    filmic: THREE.NoToneMapping,
-  };
   await snapshot.prepare(renderCamera);
   assertCurrent();
   const captureOptions = {
@@ -222,31 +166,20 @@ export async function photographSnapshot(
     width: render.width,
     height: render.height,
     transparent: render.transparent === true,
-    toneMapping: mappings[render.toneMapping] ?? THREE.AgXToneMapping,
-    exposure: render.exposure,
+    toneMapping: THREE.NoToneMapping,
+    exposure: 1,
   };
-  // BLENDER'S OWN VIEW TRANSFORM, off the linear frame. three's AgX is
-  // Filament's approximation and lands 23 to 48 levels of 255 away from
-  // Blender (42 at middle grey); the config's actual transform is a 57^3
-  // LUT over a log allocation, and a LOOK grades in a log space with two
-  // LUT inversions in it. Neither is reachable from resolved bytes, and
-  // both are reachable from the half-float target `captureImage` already
-  // allocates -- so an AgX render reads that and runs
-  // `blender-agx.ts`, which is verified byte-for-byte against OCIO.
-  // AND WHENEVER THE SCENE-REFERRED FRAME IS WANTED, whatever the
-  // transform: `captureImage` answers with resolved bytes and nothing
-  // else, so a Standard render asked for an EXR — or asked to be
-  // composited — has no linear frame in it at all. Reading the
-  // half-float target is the only path that has one.
-  const display =
-    render.toneMapping === 'agx' || render.toneMapping === 'filmic' || render.linear === true
-      ? await displayPhotograph(captureSceneLinear(scene, renderCamera, captureOptions), render)
-      : null;
-  assertCurrent();
-  if (display) return display;
-  const dataUrl = captureSceneImage(scene, renderCamera, captureOptions);
-  if (!dataUrl) throw new Error('Blender render could not capture its image');
-  return { base64: dataUrl.slice(dataUrl.indexOf(',') + 1), mimeType: 'image/png' };
+  if (render.linear === true) {
+    const display = await displayPhotograph(captureSceneLinear(scene, renderCamera, captureOptions), render);
+    assertCurrent();
+    return display;
+  }
+  const transform = await createBlenderDisplayTransform(blenderDisplaySettingsForRender(render));
+  try {
+    assertCurrent();
+    const dataUrl = captureSceneImage(scene, renderCamera, {...captureOptions, displayTransform: transform});
+    return {base64: dataUrl.slice(dataUrl.indexOf(',') + 1), mimeType: 'image/png'};
+  } finally { transform.dispose(); }
 }
 
 export const BLENDER_RUNTIME_DOCUMENT_ID = 'document:blender:runtime';
@@ -299,7 +232,14 @@ function modelDocumentConflict(): string | null {
     ? activeId.slice('document:model:'.length)
     : boundModel?.blend;
   if (!requested || !held || requested === held) return null;
-  return `Blender is editing ${held}; ${requested} is not open. Return to ${held} before editing.`;
+  // Say how to get Blender onto the document the editor shows, not only how to go back: an agent told
+  // just "return to <held>" took it as the Blender door being unusable and built its level by
+  // another route (2026-10-06, the WSL obby run).
+  // Plain words: people see this in error notices too. Re-opening the document already showing does not
+  // remount a failed open (blender-runtime.document.tsx), so the steps that do are named instead.
+  return `Blender is editing ${held}, but the editor is showing ${requested}, which Blender has not loaded. ` +
+    `Wait for ${requested} to finish opening and retry. If it stays, switch to another document and back, ` +
+    `or reload the page; or return to ${held}.`;
 }
 
 /** The document id a present must reach: the open Model document's, or the
@@ -437,7 +377,7 @@ async function openBoundModelDocument(
  * (`../contributions/blender-properties-*`) call these three rather than the
  * `blender-rna*` commands: same session, same `session.py` functions, one
  * fewer hop, and no `EditorCommandResult` envelope to unwrap in a render.
- * The COMMANDS remain the wire's door onto the same calls, so a `volter-model-editor eval`
+ * The COMMANDS remain the wire's door onto the same calls, so a `cyclotron eval`
  * and the panel read one thing.
  *
  * THEY NEVER START THE ENGINE. A panel asking what the engine holds must not
@@ -468,7 +408,7 @@ export function blenderSessionStarted(): boolean {
  * So the version is minted HERE, at the door every RNA write goes through,
  * and it is bumped by the write rather than by the picture. Both halves of
  * each door bump it once: the in-page function is what the wire's
- * `blender-rna-set` / `blender-outliner-set` case calls, so a `volter-model-editor eval` and
+ * `blender-rna-set` / `blender-outliner-set` case calls, so a `cyclotron eval` and
  * a panel click are one path. `blender-execute` bumps it too — arbitrary bpy
  * can change anything RNA answers, and a view that went stale under a probe's
  * own script would be the same defect one layer out.
@@ -679,7 +619,7 @@ export async function blenderOutlinerSet(
 /**
  * THE NODE EDITOR'S VERBS, published ONCE and reached two ways (U8's ruling 1,
  * 2026-09-19). Under the Code-OSS frame each is a `volter.blender-node-view.<verb>`
- * command the bridge dispatches into the view; standalone `volter-model-editor edit`, which has
+ * command the bridge dispatches into the view; standalone `cyclotron edit`, which has
  * no command service, reaches the SAME table through the session's
  * `blender-node-view` verb below. One table, two doors — the shape
  * `key-actions.ts`'s action table already has, and the reason the next
@@ -1173,7 +1113,7 @@ export function blenderRuntime(): BlenderRuntime {
   // how long it has been stuck — the loop that would send the number is the loop
   // that is stuck — so this side keeps the clock and the host carries it out on
   // the heartbeat, the one channel that still beats through a blocked main
-  // thread. `volter-model-editor status` prints the block. Published as a READ of the live
+  // thread. `cyclotron status` prints the block. Published as a READ of the live
   // meter rather than a snapshot, so the host always asks the running session:
   // an in-flight call's age has to be computed at the moment it is reported.
   // The page's own long-task half is the HOST's, behind this same door.
@@ -1344,7 +1284,7 @@ export async function handleBlenderCommand(cmd: {
         // RNA version is minted at the door (ruling 3, 2026-09-19), and
         // ARBITRARY bpy can change anything RNA answers, so a script that
         // reached the engine around it would leave every view drawing the tree
-        // it had. One path for a `volter-model-editor eval`, an MCP call and a panel's own
+        // it had. One path for a `cyclotron eval`, an MCP call and a panel's own
         // operator.
         // THE DOOR'S TEXT, verbatim — `execute_blender_code`'s MCP contract is
         // that one string, so the wire keeps answering it while the in-page
@@ -1391,7 +1331,7 @@ export async function handleBlenderCommand(cmd: {
       }
       // THE TREE DOOR on the wire, beside the RNA one: `blender-outliner`
       // answers Blender's View Layer tree and `blender-outliner-set` writes one
-      // restriction column, so a `volter-model-editor eval` reads exactly what the hierarchy
+      // restriction column, so a `cyclotron eval` reads exactly what the hierarchy
       // panel draws.
       case 'blender-outliner': {
         const selected = Array.isArray(cmd['selected'])
@@ -1402,7 +1342,7 @@ export async function handleBlenderCommand(cmd: {
         return { ok: true, data: { result: await session.outliner(selected) } };
       }
       // THE NODE-TREE DOOR on the wire, beside the other two: one material's
-      // shader node tree, whole, so a `volter-model-editor eval` reads exactly what the node
+      // shader node tree, whole, so a `cyclotron eval` reads exactly what the node
       // view draws.
       case 'blender-node-tree':
         return {
@@ -1415,7 +1355,7 @@ export async function handleBlenderCommand(cmd: {
           },
         };
       // THE UV DOOR on the wire, beside the node one: one mesh's UV layout,
-      // so a `volter-model-editor eval` reads exactly what the UV view draws.
+      // so a `cyclotron eval` reads exactly what the UV view draws.
       case 'blender-uv-layout':
         return {
           ok: true,
@@ -1427,7 +1367,7 @@ export async function handleBlenderCommand(cmd: {
           },
         };
       // THE RIG AND CLIP DOORS on the wire, beside the UV one: the skin
-      // binding and the action as three.js tracks, so a `volter-model-editor eval` reads
+      // binding and the action as three.js tracks, so a `cyclotron eval` reads
       // exactly what the presenter bound and what the Timeline plays.
       case 'blender-rig':
         return {
@@ -1454,7 +1394,7 @@ export async function handleBlenderCommand(cmd: {
       //
       // THE SESSION IS THE STANDALONE DOOR ONTO `NODE_VIEW_VERBS`, not a second
       // implementation (U8's ruling 1). Under the Code-OSS frame each verb is a
-      // `volter.blender-node-view.<verb>` command; standalone `volter-model-editor edit` has no
+      // `volter.blender-node-view.<verb>` command; standalone `cyclotron edit` has no
       // command service, so this verb routes the SAME table. `invokeViewVerb`
       // throws the view's own refusal, which is the sentence this door already
       // answered with.

package/node/blender-mcp.ts

@@ -13,7 +13,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative, sep } from 'node:path';
+import { delimiter, dirname, isAbsolute, relative, sep } from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
@@ -105,11 +105,31 @@ function projectRelative(project: string, absolute: string): string | null {
   return rel;
 }
 
+/**
+ * BLENDER'S FILESYSTEM IS POSIX, the host's may not be. The worker mounts a Windows root
+ * (`C:\Users\me\p`) at its URI path (`/C:/Users/me/p`) — `projectMount` in
+ * `@volter/blender-engine/browser/worker.ts`, which this mirrors because that module is the
+ * worker's and cannot load here. Every path crossing the transport goes through these two:
+ * the engine's spelling on the wire, the host's on disk. Until 2026-10-06 the Mirror sent the
+ * host's spelling, the worker listed nothing at a path it did not have, and on Windows no
+ * script output ever reached disk while every call reported success.
+ */
+export function engineSpelling(host: string): string {
+  return /^[A-Za-z]:[\\/]/.test(host) ? `/${host.replaceAll('\\', '/')}` : host;
+}
+
+/** {@link engineSpelling} backwards: `/C:/Users/me/p/x.glb` → `C:\Users\me\p\x.glb` on
+ *  Windows; a POSIX host's paths are the engine's own. */
+export function hostSpelling(engine: string, platform: NodeJS.Platform = process.platform): string {
+  return platform === 'win32' && /^\/[A-Za-z]:\//.test(engine) ? engine.slice(1).replaceAll('/', '\\') : engine;
+}
+
 /**
  * The worker's filesystem is the only place a script's outputs exist; this
  * mirrors them to disk. Roots: the project (a script's `public/models/x.glb`
- * lands in the project) plus any `VOLTER_BLENDER_MIRROR_ROOTS` (colon-separated
- * absolute paths — the replay harness names its run directory). Only files
+ * lands in the project) plus any `VOLTER_BLENDER_MIRROR_ROOTS` (absolute paths separated by
+ * the platform's own `path.delimiter` — `:` on POSIX, `;` on Windows, where a drive letter's
+ * colon is part of the path — the replay harness names its run directory). Only files
  * whose size or mtime changed since the last mirror are read back, and only
  * files the SESSION owns are listed at all — a project file it merely read
  * belongs to the host and is never written back over it.
@@ -153,11 +173,14 @@ class Mirror {
         session?: string;
         revision?: number;
         document?: string;
-      }>('blender-list-files', { path: root });
+      }>('blender-list-files', { path: engineSpelling(root) });
       for (const entry of listing.entries) {
         const stamp = `${entry.size}:${entry.mtime}`;
         if (this.#seen.get(entry.path) === stamp) continue;
-        const projectPath = projectRelative(this.project, entry.path);
+        // `entry.path` is the engine's spelling (what `blender-read-file` takes); `onDisk` is
+        // where the same file lives on this machine.
+        const onDisk = hostSpelling(entry.path);
+        const projectPath = projectRelative(this.project, onDisk);
         const shipped =
           projectPath !== null && projectOutputRootOf(projectPath) === 'public'
             ? projectPath
@@ -184,15 +207,15 @@ class Mirror {
           // adapter triggers project reload during this very MCP request.
           // Only changed bytes should reach the filesystem watcher.
           try {
-            if (readFileSync(entry.path).equals(bytes)) {
+            if (readFileSync(onDisk).equals(bytes)) {
               this.#seen.set(entry.path, stamp);
               continue;
             }
           } catch (error) {
             if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
           }
-          mkdirSync(dirname(entry.path), { recursive: true });
-          writeFileSync(entry.path, bytes);
+          mkdirSync(dirname(onDisk), { recursive: true });
+          writeFileSync(onDisk, bytes);
         } else {
           const query = new URLSearchParams({
             path: shipped,
@@ -294,6 +317,25 @@ class TabSession {
 
 const text = (value: string) => ({ content: [{ type: 'text' as const, text: value }] });
 
+/** `VOLTER_BLENDER_MIRROR_ROOTS`, split on the platform's delimiter. A root Blender cannot mount
+ *  is REFUSED by name rather than dropped: dropping it was how a Windows root (`C:\…`, split on
+ *  its own colon) silently mirrored nothing. Blender's filesystem has a mount for a POSIX root
+ *  (`/runs/x`) and a drive root (`C:\runs\x`, as `/C:/runs/x`) only, so a relative path, a UNC
+ *  share (`\\server\share`) and a drive-less rooted path (`\runs\x`) — all of which Node calls
+ *  absolute or nearly — are refused too (#147 review). */
+function mirrorRoots(raw: string | undefined): string[] {
+  const roots = (raw ?? '').split(delimiter).filter((root) => root !== '');
+  const mountable = (root: string) => /^[A-Za-z]:[\\/]/.test(root) || (root.startsWith('/') && !root.startsWith('//'));
+  const refused = roots.filter((root) => !mountable(root) || !isAbsolute(root));
+  if (refused.length > 0)
+    throw new Error(
+      `VOLTER_BLENDER_MIRROR_ROOTS names ${refused.map((root) => JSON.stringify(root)).join(', ')}, ` +
+        `which Blender cannot mount: a root must be an absolute POSIX path (/runs/x) or a drive path (C:\\runs\\x), ` +
+        `not a relative path, a UNC share or a path without its drive. Separate roots with "${delimiter}".`,
+    );
+  return roots;
+}
+
 export async function serveBlenderMcp(
   project: string,
   ensureEditor: () => Promise<void>,
@@ -304,7 +346,13 @@ export async function serveBlenderMcp(
   // it goes rendered one, wrote it into the project and ran the OS `open` on it: Preview started
   // outside the editor. The editor already shows a picture as one of its documents.
   const photographs = `A photograph is shown to the person in the editor, never in another app: get_viewport_screenshot returns one, and an image file written inside the project opens as an editor document with \`npx ${command} eval 'editor.openAsset("<project-relative path>")'\`. Do not run the OS \`open\` on it.`;
-  const filesystem = `Project files are mounted in Blender at the project's actual absolute path: ${project}. Use that root for image loads, saves and exports; /project is not an alias.`;
+  // Blender's own spelling of the root: on Windows the project's `C:\…` is `/C:/…` inside it, and
+  // a script told the host spelling writes to a path that is not the project's.
+  const mounted = engineSpelling(project);
+  // Files the agent wrote a moment ago are copied in before each call (blender-engine worker,
+  // stageProjectFiles), so a project script runs from its file; an agent unsure of that built its level
+  // through the eval CLI instead of this door (2026-10-06, the WSL obby run).
+  const filesystem = `Project files are mounted in Blender at the project's actual absolute path: ${mounted}${mounted !== project ? ` (this machine's ${project})` : ''}. Use that root for image loads, saves and exports; /project is not an alias. The project's source files written before a call, including ones written just now, are in place when that call runs (dotfiles and dot-directories, node_modules, dist, coverage and logs are not copied in), so run a project script from its file: exec(open(${JSON.stringify(`${mounted}/src/models/<name>.py`)}).read()).`;
   const instructions = `${runtimeIdentity}\n${filesystem}\n${photographs}`;
   const tools = (blenderTools as ToolShape[]).map((tool) =>
     tool.name === 'execute_blender_code'
@@ -314,9 +362,7 @@ export async function serveBlenderMcp(
   const defaults = blenderDefaults as Record<string, string>;
   const mirror = new Mirror(project, [
     project,
-    ...(process.env['VOLTER_BLENDER_MIRROR_ROOTS'] ?? '')
-      .split(':')
-      .filter((root) => root.startsWith('/')),
+    ...mirrorRoots(process.env['VOLTER_BLENDER_MIRROR_ROOTS']),
   ], `${command} blender-mcp`);
   const tab = new TabSession(project, ensureEditor);
   const server = new Server(

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/editor-blender",
   "author": "Volter AI, Inc.",
   "license": "AGPL-3.0-only AND GPL-3.0-or-later",
-  "version": "0.1.128",
+  "version": "0.1.130",
   "publishConfig": {
     "access": "public"
   },
@@ -21,6 +21,7 @@
     "LICENSE",
     "LICENSE-MCP",
     "serving",
+    "view",
     "dist-node"
   ],
   "exports": {
@@ -66,18 +67,20 @@
       "./contributions/uv-editing.layout.ts",
       "./contributions/texture.layout.ts"
     ],
-    "serving": "./dist-node/serving.mjs"
+    "serving": "./dist-node/serving.mjs",
+    "viewServing": "./view/blender-view-routes.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.32.1",
-    "@volter/blender-engine": "0.1.126",
-    "@volter/editor-threejs": "0.5.189",
-    "zod": "^4.3.6"
+    "@volter/blender-engine": "0.1.128",
+    "@volter/editor-threejs": "0.5.191",
+    "zod": "^4.3.6",
+    "@fortawesome/free-solid-svg-icons": "^7.2.0"
   },
   "peerDependencies": {
-    "@volter/editor-live": "0.5.189",
-    "@volter/editor-project": "0.5.189",
-    "@volter/editor-sdk": "0.5.189",
+    "@volter/editor-live": "0.5.191",
+    "@volter/editor-project": "0.5.191",
+    "@volter/editor-sdk": "0.5.191",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "three": "^0.180.0",

package/serving/index.ts

@@ -6,5 +6,34 @@
 
 import type { ProjectServingModule } from '@volter/editor-sdk/session/project-serving';
 import { blenderRoutesPlugin } from './blender-routes';
+import { BLENDER_WALI_ARTIFACT, BLENDER_WASM_FILES, blenderWasmStatus } from './blender-wasm-artifact';
 
 export const servingPlugins: ProjectServingModule['servingPlugins'] = (services) => [blenderRoutesPlugin(services)];
+
+/**
+ * The engine's bytes a LIMITED VIEW ships (docs/LIMITED-VIEW.md): fixed for a build, so the view
+ * records what the session answers here and serves it at the same URL. The routes that touch the
+ * project are the page's (`view/blender-view-routes.ts`). The substrate skew's browser modules
+ * (`/__editor/blender-wasm/wali/…`) are not listed: they are named only at run time.
+ */
+export const viewSnapshotRoutes: NonNullable<ProjectServingModule['viewSnapshotRoutes']> = async () => {
+  const base = '/__editor/blender-wasm';
+  const status = await blenderWasmStatus();
+  if (!status.available) return [`${base}/status`];
+  if (status.skew === 'wali') return [`${base}/status`, `${base}/runtime.idx`, `${base}/runtime.bin`, `${base}/${BLENDER_WALI_ARTIFACT}`];
+  return [`${base}/status`, ...BLENDER_WASM_FILES.map((file) => `${base}/${file}`)];
+};
+
+/**
+ * The recorded status, as a view may publish it: what the page reads (whether the engine is there,
+ * which skew, sizes, encodings, digests, integrity, workers) and never `dir` — the engine's folder on
+ * the machine that built the view, `VOLTER_BLENDER_WASM_DIR` or the installed package — nor the
+ * `missing` sentences, which quote paths.
+ */
+export const viewSnapshotScrub: NonNullable<ProjectServingModule['viewSnapshotScrub']> = (route, body) => {
+  if (route !== '/__editor/blender-wasm/status') return body;
+  const status = JSON.parse(body) as Record<string, unknown>;
+  delete status['dir'];
+  status['missing'] = status['available'] === true ? [] : ['The Blender engine was not recorded into this limited view.'];
+  return JSON.stringify(status);
+};

package/src/node-view-state.ts

@@ -6,7 +6,7 @@
  * own header says so: "a selector resolving outside that document's container
  * is refused by a message naming the scope". The node editor is a DRAWER
  * utility, so nothing in the product could read or drive it: the sighted door
- * (`editor.captureEditorChrome`, `volter-model-editor screenshot editor`) photographs it, and
+ * (`editor.captureEditorChrome`, `cyclotron screenshot editor`) photographs it, and
  * a photograph cannot click.
  *
  * So the view's actions are SESSION VERBS, which is the pattern the keyboard