@volter/editor-blender 0.1.131 → 0.1.132

package/contributions/blender.command.ts

@@ -57,6 +57,7 @@ export const commands: CommandContribution['commands'] = {
   // Stop drains accepted modeling work and persists it before teardown.
   'blender-stop': verb('none', 30 * 60_000),
   'blender-execute': verb('always', 30 * 60_000),
+  'blender-native-preview': verb('none', 120_000),
   'blender-scene-info': verb('none', 60_000),
   'blender-object-info': verb('none', 60_000),
   'blender-screenshot-view': verb('always', 60_000),

package/dist-node/serving.mjs

@@ -117,9 +117,13 @@ async function blenderWasmStatus(env = process.env) {
         `${dir} holds neither ${BLENDER_WASM_FILES.join(", ")} (the standalone skew) nor ${BLENDER_WALI_ARTIFACT} (the substrate skew)`
       ]
     };
-  return skew === "wali" ? waliStatus(dir) : emscriptenStatus(dir);
+  return skew === "wali" ? waliStatus(dir) : emscriptenStatus(dir, env);
 }
-async function emscriptenStatus(dir) {
+var BROWSER_SUBSTRATE_VARIABLE = "BROWSER_SUBSTRATE_URL";
+function servedFromTab(env = process.env) {
+  return (env[BROWSER_SUBSTRATE_VARIABLE] ?? "").trim() !== "";
+}
+async function emscriptenStatus(dir, env) {
   const sizes = {};
   const encoded = {};
   const missing = [];
@@ -132,7 +136,7 @@ async function emscriptenStatus(dir) {
     sizes[file] = found.size;
     if (found.encoding) encoded[file] = found.encoding;
   }
-  return { available: missing.length === 0, skew: "emscripten", dir, sizes, encoded, missing, digests: await emscriptenDigests(dir) };
+  return { available: missing.length === 0, skew: "emscripten", dir, sizes, encoded, missing, digests: await emscriptenDigests(dir), inTab: servedFromTab(env) };
 }
 async function emscriptenDigests(dir) {
   const digests = {};

package/host/blender-runtime-host.ts

@@ -20,12 +20,9 @@
  * through `capture-active-document`, after `blender-screenshot-view` has
  * presented the model with the viewport's own camera.
  *
- * A RENDER photographs a detached revision through its own camera. three.js is
- * the renderer (ARCHITECTURE-CORE, "No second implementation of a substrate
- * capability ships"), so `bpy.ops.render.render()` arrives here as a present
- * whose capture carries the SCENE camera and `scene.render`'s resolution, and
- * the PNG goes straight back to the operator that asked — the one case where
- * presenting answers with pixels instead of remembering a view.
+ * VOLTER_THREE photographs a detached revision through its own camera.
+ * Native CYCLES renders inside the Blender worker. A native preview is a
+ * read of that document through Cycles, separate from its Three presentation.
  */
 
 import {
@@ -56,8 +53,7 @@ import {
   resolveSceneLinearDisplay,
   type LinearCaptureFrame,
 } from '@volter/editor-threejs/capture/scene';
-import { fitClipPlanes } from '@volter/editor-threejs/viewport/clip-planes';
-import { contentWorldBounds } from '@volter/editor-threejs/viewport/content-bounds';
+import {blenderRenderCamera} from '@volter/blender-engine/browser/three/blender-render-camera';
 import * as THREE from 'three';
 import { blenderEngineSelection, refreshBlenderOutliner } from '../contributions/blender-outliner-model';
 import {
@@ -513,9 +509,8 @@ export async function blenderViewShading(shading: 'WIREFRAME' | 'SOLID' | 'MATER
  * a first version read `answer.executed`/`answer.error` off the string, where
  * both are `undefined` — every operator RAN and every caller was told it had
  * failed, which is how an added sphere reached `bpy.data.objects` and the
- * Outliner and was never selected. `sessionDocumentPath` below parses the same
- * two prefixes and records the same lesson from its own bug; this is the
- * second time, so the parse lives at the door now and both read it.
+ * Outliner and was never selected. Read-only metadata uses dedicated native
+ * reads rather than this execute path, which always presents a mutation.
  */
 export async function blenderExecute(code: string, history = true, label = 'Blender Python'): Promise<BlenderExecuteAnswer> {
   const text = await blenderRuntime().execute(code, history, label);
@@ -1033,35 +1028,10 @@ export function blenderRuntime(): BlenderRuntime {
         );
         const focus = new THREE.Vector3(target[0], target[1], target[2]).applyMatrix4(toDocument);
         const upward = new THREE.Vector3(up[0], up[1], up[2]).applyMatrix3(documentBasis);
-        const aspect =
-          Math.min(2048, Math.round(render.width)) / Math.min(2048, Math.round(render.height));
-        // Fit clipping to this snapshot and photograph's eye, independently of
-        // the user's navigation. Editor furniture never enters this scene.
-        const bounds = contentWorldBounds(snapshot.root).getBoundingSphere(new THREE.Sphere());
-        const documentView = fitClipPlanes(eye.distanceTo(bounds.center), bounds.radius);
-        let renderCamera: THREE.Camera;
-        if (render.orthographic) {
-          // An ORTHO scene camera. `fov` carries `ortho_scale` as the VERTICAL
-          // extent in Blender units (`_vertical_extent` applies `sensor_fit`), so
-          // the frustum is stated outright instead of being reverse-derived from
-          // a perspective camera's distance and angle.
-          const halfHeight = render.fov / 2;
-          renderCamera = new THREE.OrthographicCamera(
-            -halfHeight * aspect,
-            halfHeight * aspect,
-            halfHeight,
-            -halfHeight,
-            documentView.near,
-            documentView.far,
-          );
-        } else {
-          renderCamera = new THREE.PerspectiveCamera(
-            render.fov,
-            aspect,
-            documentView.near,
-            documentView.far,
-          );
-        }
+        // The native camera's near/far and lens shift describe this picture.
+        // Geometry bounds are for interactive navigation, not render framing.
+        const documentScale = eye.distanceTo(focus);
+        const renderCamera = blenderRenderCamera(render, documentScale);
         renderCamera.up.copy(upward);
         renderCamera.position.copy(eye);
         renderCamera.lookAt(focus);
@@ -1156,32 +1126,9 @@ const string = (cmd: Record<string, unknown>, key: string): string => {
  * is no file (a scene modelled from scratch has never been saved) or when the
  * path is outside the project, because a record is better absent than wrong.
  */
-async function sessionDocumentPath(session: {
-  execute(code: string, history?: boolean): Promise<string>;
-}): Promise<{ document?: string }> {
+function sessionDocumentPath(filepath: string): { document?: string } {
   const project = editorHost().projectLocalState.projectRootPath();
   if (project === null) return {};
-  let answer: string;
-  try {
-    answer = await session.execute('import bpy\nprint(bpy.data.filepath)\n', false);
-  } catch {
-    return {};
-  }
-  // PARSE WHAT `execute` ACTUALLY ANSWERS, which is the MCP door's shape and
-  // not raw stdout: `Code executed successfully: <stdout>` on ONE line, or
-  // `Error executing code: …`. A first version filtered for lines starting
-  // with `/` and therefore matched nothing, because the path sits after that
-  // prefix on the same line — and a document that cannot be read is
-  // indistinguishable from a session that has none, so the failure was silent
-  // and the nine bakes recorded no input at all.
-  if (/^Error executing code:/m.test(answer)) return {};
-  const filepath =
-    answer
-      .replace(/^Code executed successfully:/, '')
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.startsWith('/'))
-      .pop() ?? '';
   if (filepath === '') return {};
   const root = project.endsWith('/') ? project : `${project}/`;
   if (!filepath.startsWith(root)) return {};
@@ -1435,6 +1382,17 @@ export async function handleBlenderCommand(cmd: {
         const document = { kind: 'document', id: boundModel?.entryId ?? 'blender:runtime' };
         return { ok: true, data: { ...await session.screenshotView(maxSize), document } };
       }
+      case 'blender-native-preview': {
+        const camera = cmd['camera'];
+        if (camera !== undefined && typeof camera !== 'string') throw new Error('Native preview camera must be a name');
+        const preview = await session.nativePreview({
+          width: cmd['width'] as number,
+          height: cmd['height'] as number,
+          samples: cmd['samples'] as number,
+          ...(camera === undefined ? {} : { camera }),
+        });
+        return { ok: true, data: { ...preview } };
+      }
       case 'blender-read-file': {
         // The bytes go out as a BODY, not inside this command's answer -- see
         // `/__editor/blender-file` in `server/routes/relay.ts` for the
@@ -1464,13 +1422,13 @@ export async function handleBlenderCommand(cmd: {
         // what it can honestly name is this session and the model state it had
         // reached — taken here, at the instant of the listing, rather than
         // asked for afterwards when another call may have moved it.
-        const entries = await session.listFiles(string(cmd, 'path'));
-        const presented = session.presented;
+        const { entries, document } = await session.listFilesSnapshot(string(cmd, 'path'));
         return {
           ok: true,
           data: {
             entries,
-            ...(presented ? { session: presented.session, revision: presented.revision } : {}),
+            session: document.session,
+            revision: document.revision,
             // AND WHAT THE BYTES WERE MADE FROM. A session-written `.glb` is
             // exported from a `.blend`, and that path is the one fact that
             // lets a reader go DOWN by kind later — from a prefab's glTF to
@@ -1488,7 +1446,7 @@ export async function handleBlenderCommand(cmd: {
             // characters — whichever one the tab happened to show — which is
             // worse than no record, because it is a confident wrong answer.
             // `bpy.data.filepath` is what the export actually came out of.
-            ...(await sessionDocumentPath(session)),
+            ...sessionDocumentPath(document.filepath),
           },
         };
       }

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.131",
+  "version": "0.1.132",
   "publishConfig": {
     "access": "public"
   },
@@ -72,15 +72,15 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.32.1",
-    "@volter/blender-engine": "0.1.129",
-    "@volter/editor-threejs": "0.5.192",
+    "@volter/blender-engine": "0.1.130",
+    "@volter/editor-threejs": "0.5.193",
     "zod": "^4.3.6",
     "@fortawesome/free-solid-svg-icons": "^7.2.0"
   },
   "peerDependencies": {
-    "@volter/editor-live": "0.5.192",
-    "@volter/editor-project": "0.5.192",
-    "@volter/editor-sdk": "0.5.192",
+    "@volter/editor-live": "0.5.193",
+    "@volter/editor-project": "0.5.193",
+    "@volter/editor-sdk": "0.5.193",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "three": "^0.180.0",

package/serving/blender-wasm-artifact.ts

@@ -190,6 +190,10 @@ export interface BlenderWasmStatus {
   /** Emscripten: each file's SHA-256 as it decodes (`BUNDLE.json#rawFiles`,
    *  `essentials.json`), so a page can keep the bytes it fetched once. */
   digests?: Record<string, string>;
+  /** Emscripten: this server runs in the page's own tab ({@link servedFromTab}). Only then does
+   *  the page keep the files in its Cache Storage; served by a process on this machine, the
+   *  browser's HTTP cache keeps them (`blender-emscripten-engine.mts`, `cachedArtifact`). */
+  inTab?: boolean;
   /** WALI only: the `sha256-` SRI of `blender.wasm`. The program loader
    *  refuses any non-blob URL without one, so the session names the exact
    *  bytes it ran. */
@@ -236,10 +240,22 @@ export async function blenderWasmStatus(
           `${BLENDER_WALI_ARTIFACT} (the substrate skew)`,
       ],
     };
-  return skew === 'wali' ? waliStatus(dir) : emscriptenStatus(dir);
+  return skew === 'wali' ? waliStatus(dir) : emscriptenStatus(dir, env);
 }
 
-async function emscriptenStatus(dir: string): Promise<BlenderWasmStatus> {
+/**
+ * WHETHER THIS SERVER RUNS IN THE BROWSER TAB IT SERVES. browser-substrate names its page to the
+ * first process it starts (`BROWSER_SUBSTRATE_URL`, its `openProject`), the project's Procfile runs
+ * `edit` as that process, and `edit` hands its environment to the session it spawns
+ * (`launcher/launch.ts`). A session started on this machine has no such variable.
+ */
+export const BROWSER_SUBSTRATE_VARIABLE = 'BROWSER_SUBSTRATE_URL';
+
+export function servedFromTab(env: NodeJS.ProcessEnv = process.env): boolean {
+  return (env[BROWSER_SUBSTRATE_VARIABLE] ?? '').trim() !== '';
+}
+
+async function emscriptenStatus(dir: string, env: NodeJS.ProcessEnv): Promise<BlenderWasmStatus> {
   const sizes: Record<string, number> = {};
   const encoded: Record<string, 'br'> = {};
   const missing: string[] = [];
@@ -252,7 +268,7 @@ async function emscriptenStatus(dir: string): Promise<BlenderWasmStatus> {
     sizes[file] = found.size;
     if (found.encoding) encoded[file] = found.encoding;
   }
-  return { available: missing.length === 0, skew: 'emscripten', dir, sizes, encoded, missing, digests: await emscriptenDigests(dir) };
+  return { available: missing.length === 0, skew: 'emscripten', dir, sizes, encoded, missing, digests: await emscriptenDigests(dir), inTab: servedFromTab(env) };
 }
 
 /** The decoded bytes' digests the build records, for the files it records them for. */