@volter/blender-engine 0.1.148 → 0.1.149

package/browser/three/attach-presenter.ts

@@ -1,25 +1,11 @@
 /**
- * ONE PRESENTER, ATTACHED TO ONE BLENDER (WS-AC, cut 3).
- *
- * `volter_three.py` ships inside our Blender and turns every
- * `bpy.ops.render.render` into an ASK on a directory it owns; this is the
- * other half, for a host that holds that directory as a filesystem in its own
- * realm. It is the whole of what a host must do: hand it the filesystem, the
- * root the program was told to ask at, and a presenter
- * (`./presenter`'s `createPresenter()`, or the editor's own document wrapped
- * around the same translation).
- *
- * ONE WRITER PER DIRECTORY, which is the channel's single structural rule:
- * the guest writes and unlinks `ask/<n>.*`, this file writes and unlinks
- * `reply/<n>.*`, and neither ever touches the other's. Under a snapshot-backed
- * skew (WALI) a crossing edit is not a race but a terminated program -- the
- * host refuses a patch whose base moved under it.
- *
- * THE TRIGGER IS THE GUEST'S OWN `.done` FILE, never a timer: the filesystem
- * announces the write, this serves the ask, and the guest's removal of its
- * `ask/<n>.json` is the acknowledgement that lets the reply be retired.
+ * Attach a presenter to the filesystem channel used by volter_three.py’s render override. The guest
+ * owns ask/<n>.*, the host owns reply/<n>.*, and each creates, writes and removes only its own
+ * files. A guest .done write triggers an answer; removal of the ask JSON acknowledges it and
+ * permits reply cleanup. Snapshot-backed filesystems require this single-writer ownership.
  */
 import { columnsToTypedArrays, describeFrame } from '../session-frame.mts';
+import type { PresentAnswer } from '../runtime';
 
 /** The host filesystem seam, in exactly the shape this file uses. */
 export interface PresenterFileSystem {
@@ -34,7 +20,7 @@ export interface PresenterFileSystem {
 
 /** What `createPresenter()` returns, in the part this file uses. */
 export interface AttachablePresenter {
-  present(frame: unknown, description: unknown, capture?: unknown): Promise<unknown>;
+  present(frame: unknown, description: unknown, capture?: unknown): Promise<PresentAnswer>;
 }
 
 export function attachPresenter(
@@ -44,21 +30,7 @@ export function attachPresenter(
 ): () => void {
   const askDirectory = `${root}/ask`;
   const decoder = new TextDecoder();
-  /**
-   * Asks answered and not yet acknowledged -- this is also the "already
-   * served" test, and it may not be replaced by a highest-id watermark or a
-   * set that outlives an ask.
-   *
-   * ONE PRESENTER SERVES MANY PROCESSES, and every process starts its ask
-   * sequence at 0 again: the numbers are a conversation's, not a page's.
-   * MEASURED 2026-09-20 in the substrate tab with a page-lifetime `served`
-   * set: the first `blender -b … -a` photographed twelve frames at ~0.30 s,
-   * and every later one had its `ask/0` ("hello") skipped as already served,
-   * printed the no-presenter line and path traced with Cycles at ~1.40 s a
-   * frame -- a fallback that looked like a slow success. The ack is what
-   * closes an ask: the guest removes `ask/<n>.*` once it has read the reply,
-   * and this set is emptied by that.
-   */
+  /** Track answered asks until acknowledgement. Each process restarts its ask sequence, so ids cannot be deduplicated across processes or retained after their ask files disappear. */
   const replied = new Set<string>();
   let attached = true;
   let pumping: Promise<void> = Promise.resolve();
@@ -72,19 +44,19 @@ export function attachPresenter(
     };
     if (payload.op === 'hello') return { ok: true };
     const arena = await filesystem.readFile(payload.arena ?? `${root}/arena.bin`);
-    const answered = (await presenter.present(
+    const answered = await presenter.present(
       columnsToTypedArrays(arena, payload.frame),
       await describeFrame(arena, payload.frame),
       payload.capture,
-    )) as { capture?: unknown; held?: unknown };
+    );
     // THE CAPTURE IS THE ANSWER'S BODY and `held` rides beside it, exactly as
     // the editor's worker composes it: the guest reads a photograph's own
     // fields off this object.
     const body =
-      typeof answered?.capture === 'object' && answered.capture !== null
+      typeof answered.capture === 'object' && answered.capture !== null
         ? (answered.capture as Record<string, unknown>)
         : {};
-    return { ...body, ...(answered && 'held' in answered ? { held: answered.held } : {}) };
+    return { ...body, ...('held' in answered ? { held: answered.held } : {}) };
   }
 
   async function pump(): Promise<void> {

package/browser/three/blender-base64.ts

@@ -1,42 +1,7 @@
-/**
- * Base64 → bytes, as a PLAIN LOOP.
- *
- * `Uint8Array.from(atob(text), (c) => c.charCodeAt(0))` is the obvious form and
- * it is a trap: the mapping callback is invoked ONCE PER CHARACTER, so decoding
- * scales with call overhead rather than with a memory copy. Measured against
- * the loop below, byte-identical output throughout: 1MB 63ms vs 4ms (16.9x),
- * 3MB 224ms vs 8ms (27.7x), 8MB 545ms vs 19ms (28.9x). Textures and EXR frames
- * are routinely multi-megabyte and one of these decodes runs on the page's main
- * thread, so the callback form is never the right one here.
- */
+/** Decode base64 with a plain loop to avoid one callback invocation per byte. */
 export function bytesFromBase64(text: string): Uint8Array<ArrayBuffer> {
   const binary = atob(text);
   const out = new Uint8Array(binary.length);
   for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
   return out;
 }
-
-/**
- * Bytes → base64, the way back.
- *
- * `String.fromCharCode(...bytes)` in one call overflows the argument stack on
- * anything megabyte-sized, so the string is built in 32K spreads. Extracted
- * from the Blender worker's `encode_image`, which had exactly this
- * loop; a frame's JSON channel needs the same conversion for a raster that has
- * no transferable buffer to travel in.
- */
-export function base64FromBytes(bytes: Uint8Array): string {
-  let binary = '';
-  for (let i = 0; i < bytes.length; i += 0x8000)
-    binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
-  return btoa(binary);
-}
-
-/** {@link bytesFromBase64} for callers that want an 8-bit RGBA raster's own
- *  element type (`ImageData.data`'s), rather than a plain byte array. */
-export function clampedBytesFromBase64(text: string): Uint8ClampedArray<ArrayBuffer> {
-  const binary = atob(text);
-  const out = new Uint8ClampedArray(binary.length);
-  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-  return out;
-}

package/browser/three/blender-corner-normals.ts

@@ -7,9 +7,7 @@
 export type Normal = [number, number, number];
 
 /** `normalize_v3` (`blenlib/intern/math_vector.cc`), returning the length it
- *  divided by; a zero-length vector stays zero. Inlined from the kit's
- *  `face-interpolation.ts` when this file became `@volter/editor-blender`'s — it is the
- *  one function of that module this drawing path used. Float width is part of
+ *  divided by; a zero-length vector stays zero. Float width is part of
  *  the answer: native computes it in `float`, so every step is `Math.fround`. */
 function normalize3(n: Normal): { unit: Normal; length: number } {
   const w = Math.fround;
@@ -367,26 +365,6 @@ export function setCustomNormals(
   return { customNormal, sharpEdge: Uint8Array.from(sharp, (x) => (x ? 1 : 0)) };
 }
 
-/**
- * `Mesh::corner_normals`: one normal per corner, whatever the mesh carries.
- *
- * The decoded custom normals where a `custom_normal` layer exists, and the
- * smooth fans' own auto normals where it does not — the split-normal answer,
- * with sharp edges and flat faces already respected because they are what
- * `normalFans` splits the fans on. ONE function so a reader of corner normals
- * never has to know which of the two it is looking at; both halves are the
- * same fans, computed once.
- */
-export function cornerNormals(
-  mesh: NormalMesh,
-  attribute?: Parameters<typeof customCornerNormals>[1],
-): Normal[] {
-  const custom = customCornerNormals(mesh, attribute);
-  if (custom) return custom;
-  const { corners, fanOf, fanNormals } = normalFans(mesh);
-  return corners.map((_, c) => fanNormals[fanOf[c]!]!);
-}
-
 /** Read custom attributes at the geometry boundary, preserving corner splits. */
 export function customCornerNormals(
   mesh: NormalMesh,