@volter/editor-blender 0.1.8 → 0.1.9

package/dist-node/serving.mjs

@@ -0,0 +1,624 @@
+// serving/blender-routes.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { mkdir, readFile as readFile2, rm, stat as stat2, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { createBrotliDecompress } from "node:zlib";
+
+// ../editor-sdk/src/project/output-roots.ts
+var PROJECT_OUTPUT_ROOTS = ["public", "references"];
+function normalizeSlashes(path) {
+  const slashed = path.replaceAll("\\", "/");
+  const segments = [];
+  for (const segment of slashed.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    segments.push(segment);
+  }
+  return segments.join("/");
+}
+function projectOutputRootOf(path) {
+  const normalized = normalizeSlashes(path);
+  return PROJECT_OUTPUT_ROOTS.find(
+    (root) => normalized === root || normalized.startsWith(`${root}/`)
+  );
+}
+
+// ../editor-sdk/src/session/relative-path-guard.ts
+function relativePathRejection(path) {
+  if (!path || path.trim() === "") return "empty";
+  if (path.includes("\0")) return "nul";
+  if (path.startsWith("/") || path.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(path)) {
+    return "absolute";
+  }
+  if (path.split(/[\\/]/).includes("..")) return "traversal";
+  return null;
+}
+function isContainedRelativePath(path) {
+  return relativePathRejection(path) === null;
+}
+
+// serving/blender-wasm-artifact.ts
+import { createHash } from "node:crypto";
+import { createReadStream, existsSync } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, posix, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { brotliDecompressSync } from "node:zlib";
+var BLENDER_WASM_FILES = [
+  "blender_browser.js",
+  "blender_browser.wasm",
+  "blender_browser.data",
+  "essentials.json",
+  "essentials.bin"
+];
+var BLENDER_WALI_ARTIFACT = "blender.wasm";
+var BLENDER_WALI_RUNTIME = "runtime";
+var BLENDER_WALI_WORKERS = { pool: 16, blender: 4 };
+var BLENDER_WALI_SUBSTRATE = [
+  { segment: "browser-wali", specifier: "@volter/browser-wali" },
+  { segment: "browser-runtime", specifier: "@volter/browser-runtime" }
+];
+var BLENDER_WASM_DIR_VARIABLE = "VGAI_BLENDER_WASM_DIR";
+var SHIPPED_BLENDER_WASM_DIR = (() => {
+  const candidate = fileURLToPath(new URL("../../blender-engine/wasm/", import.meta.url));
+  return existsSync(candidate) ? candidate.replace(/\/$/, "") : null;
+})();
+function blenderWasmDir(env = process.env) {
+  const named = env[BLENDER_WASM_DIR_VARIABLE];
+  if (typeof named === "string" && named.trim() !== "") {
+    const dir = named.trim();
+    return isAbsolute(dir) ? dir : null;
+  }
+  return SHIPPED_BLENDER_WASM_DIR;
+}
+async function blenderWasmOnDisk(dir, file) {
+  for (const [suffix, encoding] of [
+    [".br", "br"],
+    ["", null]
+  ]) {
+    const path = join(dir, `${file}${suffix}`);
+    try {
+      const info = await stat(path);
+      if (info.isFile()) return { path, size: info.size, encoding };
+    } catch {
+    }
+  }
+  return null;
+}
+async function skewOf(dir) {
+  if (await blenderWasmOnDisk(dir, "blender_browser.js")) return "emscripten";
+  if (existsSync(join(dir, BLENDER_WALI_ARTIFACT))) return "wali";
+  return null;
+}
+async function blenderWasmStatus(env = process.env) {
+  const dir = blenderWasmDir(env);
+  if (dir === null)
+    return {
+      available: false,
+      skew: null,
+      dir: null,
+      sizes: {},
+      encoded: {},
+      missing: [
+        `no packages/blender-engine/wasm beside this editor, and ${BLENDER_WASM_DIR_VARIABLE} is not set to an absolute directory holding either ${BLENDER_WASM_FILES.join(", ")} or ${BLENDER_WALI_ARTIFACT} beside its ${BLENDER_WALI_RUNTIME}/ tree`
+      ]
+    };
+  const skew = await skewOf(dir);
+  if (skew === null)
+    return {
+      available: false,
+      skew: null,
+      dir,
+      sizes: {},
+      encoded: {},
+      missing: [
+        `${dir} holds neither ${BLENDER_WASM_FILES.join(", ")} (the standalone skew) nor ${BLENDER_WALI_ARTIFACT} (the substrate skew)`
+      ]
+    };
+  return skew === "wali" ? waliStatus(dir) : emscriptenStatus(dir);
+}
+async function emscriptenStatus(dir) {
+  const sizes = {};
+  const encoded = {};
+  const missing = [];
+  for (const file of BLENDER_WASM_FILES) {
+    const found = await blenderWasmOnDisk(dir, file);
+    if (!found) {
+      missing.push(`${join(dir, file)} (or .br)`);
+      continue;
+    }
+    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) };
+}
+async function emscriptenDigests(dir) {
+  const digests = {};
+  const read = async (file) => {
+    try {
+      return JSON.parse(await readFile(join(dir, file), "utf8"));
+    } catch {
+      return void 0;
+    }
+  };
+  const bundle = await read("BUNDLE.json");
+  for (const [file, record] of Object.entries(bundle?.rawFiles ?? {})) {
+    if (typeof record?.sha256 === "string") digests[file] = record.sha256;
+  }
+  const essentials = await read("essentials.json");
+  if (typeof essentials?.sha256 === "string") digests["essentials.bin"] = essentials.sha256;
+  return digests;
+}
+async function waliStatus(dir) {
+  const sizes = {};
+  const missing = [];
+  const artifact = join(dir, BLENDER_WALI_ARTIFACT);
+  try {
+    sizes[BLENDER_WALI_ARTIFACT] = (await stat(artifact)).size;
+  } catch {
+    missing.push(artifact);
+  }
+  let index = null;
+  try {
+    index = await runtimeIndex(dir);
+    sizes[`${BLENDER_WALI_RUNTIME}/`] = index.files.reduce((total, file) => total + file.size, 0);
+  } catch (error) {
+    missing.push(
+      `${join(dir, BLENDER_WALI_RUNTIME)} (Blender's scripts, datafiles and python; ${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+  for (const { segment, specifier } of BLENDER_WALI_SUBSTRATE)
+    if (substrateDir(specifier) === null)
+      missing.push(
+        `${specifier} (served at wali/${segment}/; the substrate skew runs Blender through it, so a project that opts into this skew declares it)`
+      );
+  const integrity = missing.length === 0 ? `sha256-${createHash("sha256").update(await readFile(artifact)).digest("base64")}` : void 0;
+  return {
+    available: missing.length === 0,
+    skew: "wali",
+    dir,
+    sizes,
+    encoded: {},
+    missing,
+    ...integrity ? { integrity } : {},
+    workers: { ...BLENDER_WALI_WORKERS }
+  };
+}
+var patchedGlue = null;
+var CANVAS_TRANSFER = "var transferredCanvasNames=attr?(growMemViews(),HEAPU32)[attr+40>>2]:0;if(";
+function patchBlenderGlue(source) {
+  if (!source.includes(CANVAS_TRANSFER)) return source;
+  return source.replace(
+    CANVAS_TRANSFER,
+    `${CANVAS_TRANSFER}true){transferredCanvasNames=0}else if(`
+  );
+}
+async function blenderGlueText(dir) {
+  if (patchedGlue?.dir === dir) return patchedGlue.text;
+  const found = await blenderWasmOnDisk(dir, "blender_browser.js");
+  if (!found) throw new Error(`${join(dir, "blender_browser.js")} is not there`);
+  const raw = await readFile(found.path);
+  const source = found.encoding === "br" ? brotliDecompressSync(raw).toString("utf8") : raw.toString("utf8");
+  const text = patchBlenderGlue(source);
+  patchedGlue = { dir, text };
+  return text;
+}
+function blenderWasmReadStream(found) {
+  return createReadStream(found.path);
+}
+var cachedRuntimeIndex = null;
+async function runtimeIndex(dir) {
+  if (cachedRuntimeIndex?.dir === dir) return cachedRuntimeIndex.index;
+  const root = join(dir, BLENDER_WALI_RUNTIME);
+  const files = [];
+  const walk = async (where) => {
+    for (const entry of (await readdir(where, { withFileTypes: true })).sort(
+      (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
+    )) {
+      const path = join(where, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const info = await stat(path);
+      files.push({
+        path: relative(root, path).split(/[\\/]/).join(posix.sep),
+        size: info.size,
+        mode: info.mode & 4095
+      });
+    }
+  };
+  await walk(root);
+  if (files.length === 0) throw new Error(`${root} is empty`);
+  const index = { files };
+  cachedRuntimeIndex = { dir, index };
+  return index;
+}
+async function writeRuntimeBlob(dir, write) {
+  const root = join(dir, BLENDER_WALI_RUNTIME);
+  for (const file of (await runtimeIndex(dir)).files) write(await readFile(join(root, file.path)));
+}
+function substrateDir(specifier) {
+  try {
+    return dirname(fileURLToPath(import.meta.resolve(specifier)));
+  } catch {
+    return null;
+  }
+}
+var SUBSTRATE_SEGMENTS = new Map(
+  BLENDER_WALI_SUBSTRATE.map(({ segment, specifier }) => [segment, specifier])
+);
+async function substrateModule(segment, file) {
+  const specifier = SUBSTRATE_SEGMENTS.get(segment);
+  if (!specifier || !/^[\w.-]+\.(?:js|mjs|map)$/.test(file)) return null;
+  const root = substrateDir(specifier);
+  if (root === null) return null;
+  const path = join(root, file);
+  if (!existsSync(path)) return null;
+  let text = (await readFile(path)).toString("utf8");
+  for (const other of BLENDER_WALI_SUBSTRATE)
+    text = text.replaceAll(
+      `"${other.specifier}/`,
+      `"/__editor/blender-wasm/wali/${other.segment}/`
+    );
+  return { text };
+}
+
+// serving/blender-routes.ts
+function json(res, body, status = 200) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.end(JSON.stringify(body));
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const value of req) chunks.push(Buffer.isBuffer(value) ? value : Buffer.from(value));
+  return Buffer.concat(chunks);
+}
+function blenderRoutesPlugin(services) {
+  const transferRoot = join2(tmpdir(), "vgai-blender-transfer");
+  const transferPath = (id) => join2(transferRoot, id);
+  void rm(transferRoot, { recursive: true, force: true });
+  const transferId = (value) => value !== null && /^[0-9a-f-]{36}$/.test(value) ? value : null;
+  const projectRoot = () => {
+    const root = services.currentProjectRoot();
+    return root === void 0 || root === services.engineRoot ? null : root;
+  };
+  const isDocumentPath = (path) => {
+    if (!path.endsWith(".blend") || path.startsWith("/") || path.includes("\\")) return false;
+    if (!isContainedRelativePath(path)) return false;
+    return path.split("/").every((segment) => segment !== "" && !segment.startsWith("."));
+  };
+  const routes = [
+    // ---- The engine itself: headless Blender, compiled to WebAssembly. Its pthreads load
+    // `blender_browser.js` from this same URL as a classic worker, so the patched glue has to
+    // be what the URL answers with.
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-wasm\/status$/,
+      handle: async (_req, res) => {
+        services.allowCrossOriginFrameEmbedding(res);
+        json(res, await blenderWasmStatus());
+      }
+    },
+    // The substrate skew's own doors beside the standalone bundle's: Blender's runtime tree as
+    // one index and one blob (a request per file would be ~2,300 round trips), and the
+    // substrate's browser ESM with its bare specifiers rewritten.
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-wasm\/runtime\.idx$/,
+      handle: async (_req, res) => {
+        const status = await blenderWasmStatus();
+        if (status.skew !== "wali" || status.dir === null) {
+          json(res, { error: "This editor does not serve the substrate skew of Blender." }, 404);
+          return;
+        }
+        json(res, await runtimeIndex(status.dir));
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-wasm\/runtime\.bin$/,
+      handle: async (_req, res) => {
+        const status = await blenderWasmStatus();
+        if (status.skew !== "wali" || status.dir === null) {
+          json(res, { error: "This editor does not serve the substrate skew of Blender." }, 404);
+          return;
+        }
+        res.setHeader("content-type", "application/octet-stream");
+        await writeRuntimeBlob(status.dir, (chunk) => void res.write(chunk));
+        res.end();
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-wasm\/wali\/([^/]+)\/([^/]+)$/,
+      handle: async (_req, res, url) => {
+        const [, segment = "", file = ""] = /^\/__editor\/blender-wasm\/wali\/([^/]+)\/([^/]+)$/.exec(url.pathname) ?? [];
+        const served = await substrateModule(decodeURIComponent(segment), decodeURIComponent(file));
+        if (!served) {
+          json(
+            res,
+            {
+              error: `This editor does not serve ${segment}/${file}. The substrate skew runs Blender through @volter/browser-wali and @volter/browser-runtime; a project that opts into it declares them.`
+            },
+            404
+          );
+          return;
+        }
+        res.setHeader("content-type", "text/javascript");
+        res.end(served.text);
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-wasm\/([^/]+)$/,
+      handle: async (req, res, url) => {
+        const file = decodeURIComponent(url.pathname.slice("/__editor/blender-wasm/".length));
+        services.allowCrossOriginFrameEmbedding(res);
+        const bundled = BLENDER_WASM_FILES.includes(file);
+        if (!bundled && file !== BLENDER_WALI_ARTIFACT) {
+          json(res, { error: `The Blender build has no ${file}.` }, 404);
+          return;
+        }
+        const status = await blenderWasmStatus();
+        if (!status.available) {
+          json(
+            res,
+            { error: `The headless Blender WebAssembly build is not served by this editor: ${status.missing.join("; ")}` },
+            404
+          );
+          return;
+        }
+        if (file === "blender_browser.js") {
+          res.setHeader("content-type", "text/javascript");
+          res.end(await blenderGlueText(status.dir));
+          return;
+        }
+        const found = await blenderWasmOnDisk(status.dir, file);
+        if (!found) {
+          json(res, { error: `${file} vanished from ${status.dir}.` }, 404);
+          return;
+        }
+        const info = await stat2(found.path);
+        const accepted = String(req.headers["accept-encoding"] ?? "").toLowerCase();
+        const sendEncoded = found.encoding !== null && accepted.includes(found.encoding);
+        const etag = `"${sendEncoded ? found.encoding : "identity"}-${info.size}-${Math.floor(info.mtimeMs)}"`;
+        res.setHeader("cache-control", "no-cache");
+        res.setHeader("etag", etag);
+        res.setHeader("vary", "accept-encoding");
+        if (req.headers["if-none-match"] === etag) {
+          res.statusCode = 304;
+          res.end();
+          return;
+        }
+        res.setHeader("content-type", file.endsWith(".wasm") ? "application/wasm" : "application/octet-stream");
+        if (sendEncoded) {
+          res.setHeader("content-encoding", found.encoding);
+          res.setHeader("content-length", String(found.size));
+          blenderWasmReadStream(found).pipe(res);
+          return;
+        }
+        const stream = blenderWasmReadStream(found);
+        const body = found.encoding ? stream.pipe(createBrotliDecompress()).on("error", () => res.destroy()) : stream;
+        body.pipe(res);
+      }
+    },
+    {
+      method: "POST",
+      match: /^\/__editor\/blender-file$/,
+      handle: async (req, res, url) => {
+        const id = transferId(url.searchParams.get("id"));
+        if (id === null) {
+          json(res, { error: "blender-file requires a uuid `id`." }, 400);
+          return;
+        }
+        const path = transferPath(id);
+        await mkdir(dirname2(path), { recursive: true });
+        const body = await readBody(req);
+        await writeFile(path, new Uint8Array(body));
+        json(res, { bytes: body.byteLength });
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-file$/,
+      handle: async (_req, res, url) => {
+        const id = transferId(url.searchParams.get("id"));
+        if (id === null) {
+          json(res, { error: "blender-file requires a uuid `id`." }, 400);
+          return;
+        }
+        const path = transferPath(id);
+        const info = await stat2(path).catch(() => null);
+        if (info === null) {
+          json(res, { error: "No transfer is spooled under that id." }, 404);
+          return;
+        }
+        res.setHeader("content-type", "application/octet-stream");
+        res.setHeader("content-length", String(info.size));
+        const stream = createReadStream2(path);
+        stream.pipe(res);
+        stream.on("close", () => {
+          void unlink(path).catch(() => {
+          });
+        });
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-project-index$/,
+      handle: async (_req, res) => {
+        const root = projectRoot();
+        if (root === null) {
+          json(res, { error: "No project open." }, 404);
+          return;
+        }
+        json(res, { root, files: await services.projectFileIndex() });
+      }
+    },
+    {
+      method: "GET",
+      match: /^\/__editor\/blender-project-file$/,
+      handle: async (_req, res, url) => {
+        const relPath = url.searchParams.get("path") ?? "";
+        const scratchDocument = isContainedRelativePath(relPath) && relPath.startsWith(".vgai/tmp/") && relPath.endsWith(".blend");
+        if (!services.isProjectOwnedPath(relPath) && !scratchDocument) {
+          json(res, { error: "Not a project-owned path." }, 400);
+          return;
+        }
+        const root = projectRoot();
+        if (root === null) {
+          json(res, { error: "No project open." }, 404);
+          return;
+        }
+        const absolute = join2(root, relPath);
+        if (!await services.isCanonicalPathInside(root, absolute)) {
+          json(res, { error: "That path leaves the project root." }, 403);
+          return;
+        }
+        try {
+          const bytes = await readFile2(absolute);
+          res.setHeader("content-type", "application/octet-stream");
+          res.end(bytes);
+        } catch {
+          json(res, { error: "Not found." }, 404);
+        }
+      }
+    },
+    // ---- A SHIPPED OUTPUT: bytes Blender produced for the game to ship (`public/`), recorded
+    // with the session and revision that re-derive them.
+    {
+      method: "POST",
+      match: /^\/__editor\/blender-output$/,
+      handle: async (req, res, url) => {
+        const path = url.searchParams.get("path") ?? "";
+        const session = url.searchParams.get("session") ?? "";
+        const source = url.searchParams.get("source") ?? "";
+        const revision = Number(url.searchParams.get("revision"));
+        const callId = url.searchParams.get("callId") ?? "";
+        if (!isContainedRelativePath(path) || projectOutputRootOf(path) !== "public") {
+          json(
+            res,
+            {
+              error: `A shipped output is a project-relative path under public/ with no traversal (public/models/model.glb); got ${JSON.stringify(path)}.`
+            },
+            400
+          );
+          return;
+        }
+        if (session === "" || !Number.isInteger(revision) || revision < 0) {
+          json(
+            res,
+            {
+              error: "A shipped output must name the session that produced it \u2014 `session` and a non-negative integer `revision` \u2014 so the record can say what re-derives the file."
+            },
+            400
+          );
+          return;
+        }
+        if (source === "" || source.length > 64) {
+          json(res, { error: "`source` names the transport that wrote the file, in 1-64 characters." }, 400);
+          return;
+        }
+        const inputs = url.searchParams.getAll("inputs");
+        const badInput = inputs.find((value) => !isContainedRelativePath(value));
+        if (badInput !== void 0) {
+          json(
+            res,
+            {
+              error: `Each \`inputs\` value is a project-relative path with no traversal (the source file these bytes were produced from); got ${JSON.stringify(badInput)}.`
+            },
+            400
+          );
+          return;
+        }
+        if (projectRoot() === null) {
+          json(res, { error: "No project open, so there is nowhere to record the output." }, 404);
+          return;
+        }
+        const body = await readBody(req);
+        if (body.byteLength === 0) {
+          json(res, { error: "The output body was empty; nothing was written." }, 400);
+          return;
+        }
+        try {
+          const written = await services.writeProjectOutput({
+            path,
+            content: body,
+            source,
+            session: {
+              id: session,
+              port: req.socket.localPort ?? 0,
+              revision,
+              ...callId === "" ? {} : { callId }
+            },
+            ...inputs.length > 0 ? { inputs } : {}
+          });
+          json(res, { ok: true, bytes: body.byteLength, provenanceOperationId: written.provenanceOperationId });
+        } catch (error) {
+          json(res, { error: error instanceof Error ? error.message : String(error) }, 500);
+        }
+      }
+    },
+    // ---- The session's DOCUMENT, written back OUT into the project. A Blender session holds one
+    // `.blend`; its `save_as_mainfile` writes it into the engine's filesystem, and this is how
+    // those bytes reach the disk the project lives on. Unlike the spool, the destination shape is
+    // pinned BY THIS SERVER, and the write is the project's one attributed, conflict-checked
+    // transaction: a `.blend` is the project's file like any other.
+    {
+      method: "POST",
+      match: /^\/__editor\/blender-document$/,
+      handle: async (req, res, url) => {
+        const path = url.searchParams.get("path") ?? "";
+        if (!isDocumentPath(path)) {
+          json(
+            res,
+            {
+              error: `A Blender document is a project-relative .blend path with no traversal (models/model.blend); got ${JSON.stringify(path)}.`
+            },
+            400
+          );
+          return;
+        }
+        if (projectRoot() === null) {
+          json(res, { error: "No project open, so there is nowhere to save the document." }, 404);
+          return;
+        }
+        const body = await readBody(req);
+        if (body.byteLength === 0) {
+          json(res, { error: "The Blender document body was empty; nothing was written." }, 400);
+          return;
+        }
+        try {
+          const revision = await services.commitProjectMutation(req, [{ path, content: body }]);
+          json(res, { ok: true, bytes: body.byteLength, revision: revision?.revision ?? null });
+        } catch (error) {
+          services.answerProjectMutationError(res, error);
+        }
+      }
+    }
+  ];
+  return {
+    name: "vgai-blender-routes",
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const url = new URL(req.url ?? "/", "http://local");
+        if (!url.pathname.startsWith("/__editor/blender-")) return next();
+        const route = routes.find((candidate) => candidate.method === req.method && candidate.match.test(url.pathname));
+        if (!route) return next();
+        route.handle(req, res, url).catch((error) => {
+          if (!res.headersSent) json(res, { error: error instanceof Error ? error.message : String(error) }, 500);
+          else res.destroy();
+        });
+      });
+    }
+  };
+}
+
+// serving/index.ts
+var servingPlugins = (services) => [blenderRoutesPlugin(services)];
+export {
+  servingPlugins
+};

package/host/blender-runtime-host.ts

@@ -801,6 +801,16 @@ export function blenderRuntime(): BlenderRuntime {
     present: async (frame, description, capture) => {
       const conflict = modelDocumentConflict();
       if (conflict) throw new Error(conflict);
+      // THE ENGINE DOES NOT NEED A VIEW. With no Model document bound, no presenter is coming:
+      // the frame is presented to nobody and the session keeps running (a headless agent, a save
+      // on close). The Model document presents the session's current state when it binds. Only a
+      // photograph needs a view, so only a capture is refused.
+      if (boundModel === null) {
+        if (capture?.render) {
+          throw new Error('Rendering a Blender frame needs the Model document open; nothing is presenting.');
+        }
+        return {};
+      }
       const documentId = presentationDocumentId();
       const endWait = beginBlenderWork('waiting for Model presenter');
       let view: RuntimeView;
@@ -1024,7 +1034,7 @@ export function blenderRuntime(): BlenderRuntime {
   // 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.
-  editorHost().session.reportWorkerCallMeter(() => session.metrics());
+  editorHost().session.reportWorkerCallMeter('Blender', () => session.metrics());
   return runtime;
 }
 

package/node/blender-mcp.ts

@@ -296,8 +296,8 @@ const text = (value: string) => ({ content: [{ type: 'text' as const, text: valu
 
 export async function serveBlenderMcp(
   project: string,
-  ensureEditor: () => Promise<void> = async () => {},
-  command = 'volter-editor',
+  ensureEditor: () => Promise<void>,
+  command: string,
 ): Promise<void> {
   const runtimeIdentity = `Blender ${blenderBundle.blender} (source ${blenderBundle.source}), compiled to WebAssembly and running headless in the editor tab; three.js takes its photographs. Factory bpy.context.scene.render.engine: '${blenderBundle.factoryEngine}'. Documents are .blend. save_as_mainfile records the actual saved path in bpy.data.filepath; open_mainfile reopens it.`;
   const tools = (blenderTools as ToolShape[]).map((tool) =>