@volter/blender-engine 0.1.137 → 0.1.139

package/browser/pull-job.mts

@@ -10,8 +10,23 @@ export class PullJob<T> {
   private expected: string | null = null;
   private resume: (() => void) | null = null;
   private waiter: { resolve: (value: PullResult<T>) => void; reject: (error: unknown) => void } | null = null;
+  /**
+   * How the work ended, when it ended while nobody was waiting on a step. Work normally ends only
+   * while a step waits, but work that races something against a checkpoint (an engine compiling
+   * beside an import) can fail in the gap after a `continue` was handed out. The outcome is kept
+   * for the step that comes next, so the caller is told what actually happened. Before this, the
+   * failure was thrown at nobody and the next step answered "Invalid or replayed load
+   * continuation", which named the protocol instead of the fault (measured 2026-10-08: a Blender
+   * start refused by a content security policy showed only that message, on every retry).
+   */
+  private ended: { readonly value: T } | { readonly error: unknown } | null = null;
   constructor(private readonly work: (checkpoint: (phase: string) => Promise<void>) => Promise<T>) {}
   step(token?: string): Promise<PullResult<T>> {
+    if (this.ended && !this.waiter && token === this.expected) {
+      const ended = this.ended;
+      this.ended = null; this.expected = null; this.resume = null;
+      return 'error' in ended ? Promise.reject(ended.error) : Promise.resolve({ load: 'done', value: ended.value });
+    }
     if (this.finished || this.waiter || (this.started ? token !== this.expected || !this.resume : token !== undefined))
       return Promise.reject(new Error('Invalid or replayed load continuation'));
     const answer = new Promise<PullResult<T>>((resolve, reject) => { this.waiter = { resolve, reject }; });
@@ -24,12 +39,18 @@ export class PullJob<T> {
         waiter.resolve({ load: 'continue', token: this.expected, phase });
       }))).then(value => {
         this.finished = true;
-        const waiter = this.waiter!; this.waiter = null;
-        waiter.resolve({ load: 'done', value });
+        const waiter = this.waiter; this.waiter = null;
+        if (waiter) waiter.resolve({ load: 'done', value });
+        else this.ended = { value };
       }, error => {
         this.finished = true;
-        const waiter = this.waiter!; this.waiter = null;
-        waiter.reject(error);
+        const waiter = this.waiter; this.waiter = null;
+        if (waiter) waiter.reject(error);
+        else {
+          this.ended = { error };
+          // Said now as well: if the owner never asks for the next step, nobody would collect it.
+          console.warn('A Blender load failed between steps; the next step reports it:', error);
+        }
       });
     } else {
       const resume = this.resume!; this.resume = null; this.expected = null; resume();

package/browser/runtime.ts

@@ -273,14 +273,26 @@ export class BlenderRuntime {
       );
     this.#project = project;
     this.#document ??= document ?? 'models/model.blend';
-    this.#started ??= this.#request({
+    this.#started ??= (this.#request({
       op: 'start',
       project,
       ...(document === undefined ? {} : { document }),
-    }) as Promise<RuntimeStart>;
+    }) as Promise<RuntimeStart>).catch((error: unknown) => {
+      this.#startFailed = true;
+      throw error;
+    });
     return this.#started;
   }
 
+  /**
+   * True once THIS session's own start has failed (not a refusal to start, such as a file another
+   * document holds). A start is asked for once and its outcome kept, and the worker that failed may
+   * hold a half-started engine, so such a session never starts: its owner discards it and makes a
+   * new one, with a new worker, for the next attempt.
+   */
+  get startFailed(): boolean { return this.#startFailed; }
+  #startFailed = false;
+
   #ready(): Promise<RuntimeStart> {
     if (this.#project === null)
       return Promise.reject(

package/package.json

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