@volter/blender-engine 0.1.49 → 0.1.50

package/browser/blender-emscripten-engine.mts

@@ -198,6 +198,21 @@ export async function startEmscriptenBlenderEngine(
     if (text.startsWith('@@VOLTER-READY ')) readyLine = text.slice('@@VOLTER-READY '.length);
     options.log(sessionLevel(text), text);
   };
+  // THE HEAP ITSELF, not a view of it. Blender runs on a pthread, so when its heap grows there
+  // this worker's `module.HEAPU8` keeps the length it had until the glue next refreshes it -- and
+  // no export the door calls does. MEASURED 2026-09-29 on the Stoneguard scene from
+  // game-benchmarks main: a mesh's columns at 1.14 GB were read through a 433 MB view, and the
+  // pull failed "outside the export arena". The glue builds its memory with `new
+  // WebAssembly.Memory` and exports no handle to it, so that constructor is observed while the
+  // factory runs; every read below takes a fresh view of `memory.buffer`.
+  const Memory = WebAssembly.Memory;
+  let memory: WebAssembly.Memory | null = null;
+  (WebAssembly as { Memory: unknown }).Memory = function (descriptor: WebAssembly.MemoryDescriptor) {
+    const made = new Memory(descriptor);
+    memory ??= made;
+    return made;
+  } as unknown as typeof WebAssembly.Memory;
+  const heap = (): Uint8Array => (memory ? new Uint8Array(memory.buffer) : module.HEAPU8);
   const module = await factory({
     arguments: ['--background', '--factory-startup', '--python', SESSION_SCRIPT],
     locateFile: (file: string) => artifactUrl(file),
@@ -253,6 +268,8 @@ export async function startEmscriptenBlenderEngine(
         );
       },
     ],
+  }).finally(() => {
+    (WebAssembly as { Memory: unknown }).Memory = Memory;
   });
   // `main()` runs on a pthread (`-sPROXY_TO_PTHREAD`), so the factory resolves
   // long before the session exists. The ready line is what says it does.
@@ -329,13 +346,15 @@ export async function startEmscriptenBlenderEngine(
     // A VIEW, NOT A COPY. The arena is wasm linear memory and under
     // `-sPROXY_TO_PTHREAD` that memory is SHARED, so `session-frame.mts`
     // slices every column it reads out of here; this call itself is free.
-    readArena: async () =>
-      module.HEAPU8.subarray(
-        module._blender_web_export_buffer(),
-        module._blender_web_export_buffer() + module._blender_web_export_buffer_size(),
-      ),
+    // A DIRECT ARENA (address 0) IS THE WHOLE HEAP, at its length now: the size the door reports
+    // is `emscripten_get_heap_size()`, which is Blender's pthread's own view of the heap and is as
+    // stale as this worker's was (measured: 431 MB while a column lay at 2.0 GB).
+    readArena: async () => {
+      const base = module._blender_web_export_buffer();
+      return base === 0 ? heap() : heap().subarray(base, base + module._blender_web_export_buffer_size());
+    },
     bootMs,
-    memoryBytes: () => module.HEAPU8.length,
+    memoryBytes: () => heap().length,
     releasedPayloadBytes,
   };
 }

package/browser/session.py

@@ -162,6 +162,8 @@ def _mark(label):
     MEMORY_MARKS.append([label] + [round(reading.get(key, 0) / 1048576)
                                    for key in ("heap", "mallocInUse", "mallocFree", "guarded", "guardedPeak")])
     del MEMORY_MARKS[:-64]
+    # Also said, so an engine that dies of memory names in its last output the stage it reached.
+    _say("@@VOLTER-MEMORY %s heap=%d inUse=%d free=%d" % tuple(MEMORY_MARKS[-1][:4]))
 _real_stderr = sys.stderr
 
 
@@ -1611,7 +1613,7 @@ class Session:
         images = [name for name, image in frame["images"].items() if image.get("deferred")]
         if not meshes and not images:
             return False
-        ask({"hold": frame})
+        _asked({"hold": frame})
         options = {"buffer_path": EXPORT_BUFFER_PATH} if EXPORT_BUFFER_PATH else {}
         for kind, keys, door in (("mesh", meshes, _blender_web.export_mesh),
                                  ("image", images, _blender_web.export_image)):
@@ -1626,7 +1628,7 @@ class Session:
                 if piece[kind] is None:
                     del frame["images"][key]
                     continue
-                ask({kind: key, "piece": piece[kind]})
+                _asked({kind: key, "piece": piece[kind]})
         return True
 
     def _send_encoded_image(self, key, deferred):
@@ -1666,7 +1668,7 @@ class Session:
         with open(path, "wb") as fh:
             fh.write(data)
         try:
-            ask({"image": key, "piece": {
+            _asked({"image": key, "piece": {
                 "revision": deferred["revision"],
                 "mime": mime,
                 "colorspace": "sRGB" if image.colorspace_settings.name == "sRGB" else "data",
@@ -2014,6 +2016,17 @@ def _pause(since):
     time.sleep(0.0002 if time.monotonic() - since < _BRISK_SECONDS else 0.002)
 
 
+def _asked(payload):
+    """`ask`, failing as the tab failed: a piece the worker could not take comes back as
+    `{"error": ...}`, and a pull that read past it presented a frame missing that piece, refused
+    later under another name ("deferred and never pulled")."""
+    answer = ask(payload)
+    if isinstance(answer, dict) and answer.get("error"):
+        raise RuntimeError("The tab refused %s: %s" % (
+            next((key for key in ("mesh", "image", "hold") if key in payload), "an ask"), answer["error"]))
+    return answer
+
+
 def ask(payload):
     """Block until the tab answers. The worker's own thread is free while this
     waits; only the Blender pthread is held, which is where the operator is.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@volter/blender-engine",
   "author": "Volter AI, Inc.",
   "license": "GPL-3.0-or-later",
-  "version": "0.1.49",
+  "version": "0.1.50",
   "publishConfig": {
     "access": "public"
   },