@downdraft/engine 0.1.0 → 0.1.2-alpha.5

package/core/src/worker/rpc.ts

@@ -154,6 +154,7 @@ type AnyWorker = {
   on?: (type: string, handler: (e: any) => void) => void;
   off?: (type: string, handler: (e: any) => void) => void;
   terminate?: () => void;
+  unref?: () => void;
 };
 
 export interface WorkerProxy<T extends WorkerApi> {
@@ -171,6 +172,9 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 
 export function wrap<T extends WorkerApi>(worker: AnyWorker, options?: WrapOptions): WorkerProxy<T> {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  // A worker nobody terminates must not pin the runtime after the host's
+  // window closes — in-flight RPCs still hold the loop via their timeout.
+  worker.unref?.();
   let reqId = 0;
   const pending = new Map<number, {
     resolve: (v: unknown) => void;
@@ -195,16 +199,34 @@ export function wrap<T extends WorkerApi>(worker: AnyWorker, options?: WrapOptio
     if (isEventMessage(msg)) {
       for (const cb of eventListeners.values()) {
         try { cb(msg.kind, msg.data); } catch (err) {
-          log.error("WorkerProxy", `Event listener error: ${err}`);
+          log.error("worker-proxy", `Event listener error: ${err}`);
         }
       }
     }
   };
 
+  // A worker that dies without terminate() (crash, or a teardown path that
+  // kills the raw Worker handle) must still settle in-flight calls — a
+  // stranded {resolve,reject} keeps its awaiting frame alive forever.
+  let terminated = false;
+  const failAll = (why: string) => {
+    if (terminated) return;
+    terminated = true;
+    for (const p of pending.values()) {
+      if (p.timer) clearTimeout(p.timer);
+      p.reject(new Error(why));
+    }
+    pending.clear();
+  };
+  const onDead = () => failAll("Worker exited");
+  const onErr = (e: any) => failAll(`Worker error: ${e?.message ?? e}`);
   if (worker.addEventListener) {
     worker.addEventListener("message", onMsg);
+    worker.addEventListener("error", onErr);
   } else if (worker.on) {
     worker.on("message", onMsg);
+    worker.on("error", onErr);
+    worker.on("exit", onDead);
   }
 
   const proxy = new Proxy({} as T, {
@@ -214,8 +236,15 @@ export function wrap<T extends WorkerApi>(worker: AnyWorker, options?: WrapOptio
       // Promise.resolve(proxy)) reads `proxy.then`, and a callable `then`
       // would fire a bogus "then" RPC instead of resolving cleanly.
       if (method === "then" || method === "catch" || method === "finally") return undefined;
-      return (...args: any[]) =>
-        new Promise((resolve, reject) => {
+      return (...args: any[]) => {
+        // A call made after the worker died must reject immediately — a
+        // deferred registered past failAll() has nothing left to settle it
+        // (the dead session's timeouts are swept, the worker's error/exit
+        // already fired), so it would strand its awaiting frame forever.
+        if (terminated) {
+          return Promise.reject(new Error(`RPC '${method}' on terminated worker`));
+        }
+        return new Promise((resolve, reject) => {
           const id = ++reqId;
           const entry: { resolve: (v: unknown) => void; reject: (e: Error) => void; timer?: ReturnType<typeof setTimeout> } = { resolve, reject };
           if (timeoutMs > 0) {
@@ -227,8 +256,17 @@ export function wrap<T extends WorkerApi>(worker: AnyWorker, options?: WrapOptio
           }
           pending.set(id, entry);
           const req: RpcRequest = { __rpc: true, id, method, args };
-          worker.postMessage(req);
+          try {
+            worker.postMessage(req);
+          } catch (err) {
+            // postMessage on a terminated worker can throw — settle the entry
+            // rather than stranding it.
+            pending.delete(id);
+            if (entry.timer) clearTimeout(entry.timer);
+            reject(err instanceof Error ? err : new Error(String(err)));
+          }
         });
+      };
     },
   });
 
@@ -239,15 +277,28 @@ export function wrap<T extends WorkerApi>(worker: AnyWorker, options?: WrapOptio
       return () => { eventListeners.delete(cb); };
     },
     terminate: () => {
-      for (const p of pending.values()) {
-        if (p.timer) clearTimeout(p.timer);
-        p.reject(new Error("Worker terminated"));
-      }
-      pending.clear();
+      failAll("Worker terminated");
       eventListeners.clear();
-      if (worker.removeEventListener) worker.removeEventListener("message", onMsg);
-      else if (worker.off) worker.off("message", onMsg);
+      if (worker.removeEventListener) {
+        worker.removeEventListener("message", onMsg);
+        worker.removeEventListener("error", onErr);
+      }
+      if (worker.off) {
+        worker.off("message", onMsg);
+        worker.off("error", onErr);
+        worker.off("exit", onDead);
+      }
       worker.terminate?.();
+      // Bun natively retains terminated Worker wrappers — any JS surface left
+      // on the wrapper (property handlers, the __ddWorkerProxy tag, stray
+      // listener maps) keeps its dead-generation closures reachable forever.
+      // Scrub so the retained wrapper pins only itself, not the module graph.
+      const w = worker as any;
+      try { w.onmessage = null; } catch { /* read-only */ }
+      try { w.onerror = null; } catch { /* read-only */ }
+      try { w.onmessageerror = null; } catch { /* read-only */ }
+      try { delete w.__ddWorkerProxy; } catch { /* non-configurable */ }
+      try { w.removeAllListeners?.(); } catch { /* not an emitter */ }
     },
   };
 }

package/core/src/worker/sim-worker-base.ts

@@ -51,7 +51,7 @@ import type {
 import type {
     GCController
 } from "../telemetry/gc-controller";
-import { createLogger, setThreadTag } from "../util/logger";
+import { createLogger } from "../util/logger";
 import { expose, exposeEvents, type WorkerApi } from "./rpc";
 
 const log = createLogger();
@@ -95,7 +95,7 @@ function installDeterministicMathGuard(rng: RngFn): void {
       warned.add(stack);
       const line = stack.split("\n")[1]?.trim() ?? "unknown callsite";
       log.warn(
-        "createSimWorker",
+        "create-sim-worker",
         `Math.random() called in deterministic sim — use ctx.rng (from ${line})`,
       );
     }
@@ -397,11 +397,6 @@ export interface CreateSimWorkerOptions {
  *   ...extraApi — any additional methods
  */
 export function createSimWorker(opts: CreateSimWorkerOptions): SimWorkerControl {
-  // Thread tag for log prefixes — this file runs in the sim worker realm.
-  // Games that run multiple sims (e.g. falling-sand's per-layer workers)
-  // set their own tag (S0/S1/...) after this default.
-  if (!(globalThis as any).__ddThreadTag) setThreadTag("S0");
-
   const tickMs = opts.fixedDt * 1000;
   const maxStepsPerFrame = opts.maxStepsPerFrame ?? 5;
 
@@ -690,7 +685,7 @@ export function createSimWorker(opts: CreateSimWorkerOptions): SimWorkerControl
       scheduleLoop(delay);
     } catch (e) {
       const err = e as Error;
-      log.error("createSimWorker", `Loop error: ${err.message}\n${err.stack}`);
+      log.error("create-sim-worker", `Loop error: ${err.message}\n${err.stack}`);
       opts.onError?.(err);
       scheduleLoop(100);
     }

package/core/src/worker/task-pool.ts

@@ -122,7 +122,7 @@ export class TaskPool {
         const worker = this.createWorker();
         worker.onerror = (e: ErrorEvent) => {
           if (this.onWorkerError) this.onWorkerError(i, e);
-          else log.error("TaskPool", `Worker ${i} error: ${e.message}`);
+          else log.error("task-pool", `Worker ${i} error: ${e.message}`);
         };
         worker.addEventListener("message", (e: MessageEvent) => {
           const msg = e.data as JobResultMessage;
@@ -139,7 +139,7 @@ export class TaskPool {
         this.workers.push(worker);
       }
     } catch (err) {
-      log.warn("TaskPool", `Failed to spawn workers, falling back to synchronous: ${err}`);
+      log.warn("task-pool", `Failed to spawn workers, falling back to synchronous: ${err}`);
       this.fallback = true;
     }
   }