@atolljs/node 0.1.6 → 0.1.8

package/dist/{chunk-QD4C3PWH.js → chunk-VEJT6OVD.js}

@@ -1,6 +1,93 @@
+// ../../src/devtools.ts
+var THREAD = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope ? "worker" : "main";
+var sink = null;
+var emitDevtools = (event) => {
+  if (sink) sink({ ...event, at: performance.now(), thread: THREAD });
+};
+var forwardDevtools = (event) => {
+  if (sink) sink(event);
+};
+var devtoolsEnabled = () => sink !== null;
+var previewValue = (value, max = 2048) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let out;
+  try {
+    out = JSON.stringify(value, (_k, v) => {
+      if (typeof v === "function") return "[fn]";
+      if (typeof v === "bigint") return `${v}n`;
+      if (v instanceof ArrayBuffer) return `[ArrayBuffer ${v.byteLength}B]`;
+      if (ArrayBuffer.isView(v)) return `[${v.constructor.name} ${v.byteLength}B]`;
+      if (v instanceof Map) return { "[Map]": [...v.entries()].slice(0, 50) };
+      if (v instanceof Set) return { "[Set]": [...v].slice(0, 50) };
+      if (v && typeof v === "object") {
+        if (seen.has(v)) return "[cycle]";
+        seen.add(v);
+      }
+      return v;
+    }) ?? String(value);
+  } catch {
+    out = String(value);
+  }
+  return out.length > max ? `${out.slice(0, max)}\u2026` : out;
+};
+var estimateCloneBytes = (value, budget = 5e3) => {
+  let nodes = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (v) => {
+    if (++nodes > budget) return 0;
+    switch (typeof v) {
+      case "string":
+        return 4 + v.length * 2;
+      case "number":
+        return 8;
+      case "boolean":
+        return 4;
+      case "bigint":
+        return 16;
+      case "undefined":
+        return 1;
+      case "object": {
+        if (v === null) return 1;
+        if (v instanceof ArrayBuffer) return v.byteLength;
+        if (ArrayBuffer.isView(v)) return v.byteLength;
+        if (typeof SharedArrayBuffer !== "undefined" && v instanceof SharedArrayBuffer) return 8;
+        if (seen.has(v)) return 4;
+        seen.add(v);
+        let n = 8;
+        if (v instanceof Map) for (const [k, x] of v) n += walk(k) + walk(x);
+        else if (v instanceof Set) for (const x of v) n += walk(x);
+        else if (Array.isArray(v)) for (const x of v) n += walk(x);
+        else for (const k of Object.keys(v)) n += 4 + k.length * 2 + walk(v[k]);
+        return n;
+      }
+      default:
+        return 0;
+    }
+  };
+  return walk(value);
+};
+var commands = /* @__PURE__ */ new Map();
+var registerDevtoolsCommand = (name, handler) => {
+  commands.set(name, handler);
+  return () => {
+    if (commands.get(name) === handler) commands.delete(name);
+  };
+};
+var BODY_PREVIEW = 8 * 1024;
+var seq = 0;
+var named = /* @__PURE__ */ new Map();
+var nextDevtoolsId = (prefix, name) => {
+  const slug = name?.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!slug) return `${prefix}-${++seq}`;
+  const base = `${slug}-${prefix === "pool" ? "p" : prefix === "worker" ? "w" : prefix}`;
+  const n = (named.get(base) ?? 0) + 1;
+  named.set(base, n);
+  return n === 1 ? base : `${base}${n}`;
+};
+
 // ../../src/log.ts
 var LEVELS = { trace: 0, debug: 1, info: 2, warn: 3, error: 4, off: 5 };
-var THREAD = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope ? "worker" : "main";
+var THREAD2 = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope ? "worker" : "main";
 var consoleSink = ({ level, scope, message, data, thread, at }) => {
   const prefix = `[${(at / 1e3).toFixed(2)}s ${thread}:${scope}]`;
   const fn = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.info : console.debug;
@@ -8,10 +95,25 @@ var consoleSink = ({ level, scope, message, data, thread, at }) => {
   else fn(`${prefix} ${message}`);
 };
 var minLevel = "info";
-var sink = consoleSink;
+var sink2 = consoleSink;
+var teeing = false;
 function log(level, scope, message, data) {
   if (LEVELS[level] < LEVELS[minLevel]) return;
-  sink({ level, scope, message, data, thread: THREAD, at: performance.now() });
+  sink2({ level, scope, message, data, thread: THREAD2, at: performance.now() });
+  if (!teeing && devtoolsEnabled()) {
+    teeing = true;
+    try {
+      emitDevtools({
+        type: "log",
+        level,
+        scope,
+        message,
+        ...data !== void 0 ? { data: previewValue(data, 1024) } : {}
+      });
+    } finally {
+      teeing = false;
+    }
+  }
 }
 function scoped(scope) {
   return {
@@ -246,8 +348,11 @@ function listFactory(d, ctx, byteOffset) {
     writeAt,
     commit: () => {
       if (ctx.version) {
-        Atomics.add(ctx.version.view, ctx.version.index, 1);
+        const prev = Atomics.add(ctx.version.view, ctx.version.index, 1);
         Atomics.notify(ctx.version.view, ctx.version.index);
+        if (ctx.path && devtoolsEnabled()) {
+          emitDevtools({ type: "memory:write", path: ctx.path, version: prev + 1 });
+        }
       }
     },
     read: () => Array.from({ length: count }, (_, i) => readAt(i)),
@@ -349,6 +454,177 @@ var WorkerCrashedError = class extends Error {
   }
 };
 
+// ../../src/userTiming.ts
+var measureAtoll = (name, start, end, t) => {
+  const perf = globalThis.performance;
+  if (typeof perf?.measure !== "function") return;
+  try {
+    perf.measure(name, {
+      start,
+      end: Math.max(end, start),
+      detail: {
+        devtools: {
+          dataType: "track-entry",
+          track: t.track,
+          trackGroup: "atoll",
+          color: t.color ?? "primary",
+          properties: t.properties,
+          tooltipText: t.tooltipText
+        }
+      }
+    });
+    perf.clearMeasures?.(name);
+  } catch {
+  }
+};
+var measureTaskCall = (runnerId, taskId, callId, slot, start, end, ok) => measureAtoll(`atoll task ${taskId}`, start, end, {
+  track: runnerId,
+  color: ok ? "primary" : "error",
+  properties: [["runner", runnerId], ["slot", slot], ["call", callId], ["outcome", ok ? "ok" : "error"]],
+  tooltipText: `${taskId} on ${runnerId}#${slot}: ${(end - start).toFixed(1)}ms`
+});
+
+// ../../src/pool/workerChannel.ts
+function setupChannelMemory(config, owner) {
+  if (config.sharedMemory || config.sharedBuffer !== void 0) {
+    if (typeof SharedArrayBuffer === "undefined" || typeof crossOriginIsolated !== "undefined" && !crossOriginIsolated) {
+      throw new Error(
+        `${owner} requires SharedArrayBuffer in a cross-origin isolated context \u2014 serve the page with COOP/COEP headers.`
+      );
+    }
+  }
+  let injectedBuffer;
+  if (config.sharedBuffer !== void 0) {
+    injectedBuffer = typeof config.sharedBuffer === "function" ? config.sharedBuffer() : config.sharedBuffer;
+    if (!injectedBuffer) {
+      throw new Error(
+        `${owner}: \`sharedBuffer\` resolved to an empty buffer \u2014 the producing pool or contract has no bound memory yet.`
+      );
+    }
+  }
+  if (!config.sharedMemory) return { sharedMemory: void 0, injectedBuffer, persistence: void 0 };
+  const sharedMemory = config.sharedMemory;
+  let memoryManager;
+  if (injectedBuffer) {
+    sharedMemory.bind(injectedBuffer);
+  } else {
+    memoryManager = new MemoryManager(config.memory);
+    memoryManager.ensureCapacity(sharedMemory.totalBytes);
+    sharedMemory.bind(memoryManager.getBuffer());
+  }
+  return { sharedMemory, memoryManager, injectedBuffer, persistence: config.persistence?.(sharedMemory) };
+}
+function sendInit(worker, mem) {
+  if (mem.memoryManager) {
+    worker.postMessage({ type: "INIT_MEMORY", memory: mem.memoryManager.memory, devtools: devtoolsEnabled() });
+    return "INIT_MEMORY";
+  }
+  if (mem.injectedBuffer) {
+    worker.postMessage({ type: "INIT_MEMORY", buffer: mem.injectedBuffer, devtools: devtoolsEnabled() });
+    return "INIT_MEMORY";
+  }
+  worker.postMessage({ type: "INIT", devtools: devtoolsEnabled() });
+  return "INIT";
+}
+function forwardWorkerDevtools(runnerId, slot, ev) {
+  const qualify = (id) => `${runnerId}#${slot}~${id}`;
+  forwardDevtools({
+    ...ev,
+    ...ev.poolId !== void 0 ? { poolId: qualify(ev.poolId) } : {},
+    worker: ev.worker === void 0 ? { poolId: runnerId, slot } : { poolId: qualify(ev.worker.poolId), slot: ev.worker.slot }
+  });
+}
+
+// ../../src/pool/devtoolsCommands.ts
+var CHAOS_FAILURE = "chaos: injected failure";
+var KILL_MESSAGE = "killed from devtools";
+var runners = /* @__PURE__ */ new Map();
+var uninstall = null;
+var runnerOf = (args) => {
+  const id = args.poolId;
+  if (typeof id !== "string") throw new Error("poolId (string) is required");
+  const r = runners.get(id);
+  if (!r) {
+    throw new Error(
+      id.includes("~") ? `runner '${id}' lives inside a worker: nested pools are not controllable from the dashboard` : `no live runner '${id}' on this thread`
+    );
+  }
+  return r;
+};
+var rate = (v, name) => {
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 1) {
+    throw new Error(`${name} must be a number in 0..1`);
+  }
+  return v || void 0;
+};
+var parseChaos = (args) => {
+  const { delayMs } = args;
+  if (delayMs !== void 0 && delayMs !== null && (typeof delayMs !== "number" || !Number.isFinite(delayMs) || delayMs < 0)) {
+    throw new Error("delayMs must be a non-negative number");
+  }
+  const failRate = rate(args.failRate, "failRate");
+  const timeoutRate = rate(args.timeoutRate, "timeoutRate");
+  if ((failRate ?? 0) + (timeoutRate ?? 0) > 1) throw new Error("failRate + timeoutRate must not exceed 1");
+  const chaos = {};
+  if (delayMs) chaos.delayMs = delayMs;
+  if (failRate) chaos.failRate = failRate;
+  if (timeoutRate) chaos.timeoutRate = timeoutRate;
+  return Object.keys(chaos).length ? chaos : null;
+};
+var listRunners = () => [...runners.values()].map((r) => ({
+  poolId: r.poolId,
+  label: r.label ?? r.poolId,
+  size: r.size(),
+  dedicated: r.dedicated,
+  chaos: r.getChaos()
+}));
+var install = () => {
+  const offs = [
+    registerDevtoolsCommand("pool.list", () => listRunners()),
+    registerDevtoolsCommand("pool.stats", (args) => runnerOf(args).stats()),
+    registerDevtoolsCommand("worker.kill", (args) => {
+      const r = runnerOf(args);
+      const slot = args.slot ?? 0;
+      if (typeof slot !== "number" || !Number.isInteger(slot) || slot < 0) {
+        throw new Error("slot must be a non-negative integer");
+      }
+      r.kill(slot);
+      return { poolId: r.poolId, slot, killed: true };
+    }),
+    registerDevtoolsCommand("pool.chaos", (args) => {
+      const r = runnerOf(args);
+      r.setChaos(parseChaos(args));
+      return r.getChaos();
+    })
+  ];
+  return () => offs.forEach((off) => off());
+};
+var registerDevtoolsRunner = (handle) => {
+  runners.set(handle.poolId, handle);
+  uninstall ??= install();
+  return () => {
+    if (runners.get(handle.poolId) !== handle) return;
+    runners.delete(handle.poolId);
+    if (runners.size === 0 && uninstall) {
+      uninstall();
+      uninstall = null;
+    }
+  };
+};
+var applyChaos = (chaos, call) => {
+  const r = Math.random();
+  const fail = r < (chaos.failRate ?? 0);
+  const timeout = !fail && r < (chaos.failRate ?? 0) + (chaos.timeoutRate ?? 0);
+  if (!chaos.delayMs && !fail && !timeout) return call.post();
+  setTimeout(() => {
+    if (!call.live()) return;
+    if (fail) return call.fail();
+    if (timeout) call.timeout();
+    call.post();
+  }, chaos.delayMs ?? 0);
+};
+
 // ../../src/pool/workerPool.ts
 var poolLog = scoped("pool");
 var taskLog = scoped("task");
@@ -367,7 +643,10 @@ var WorkerPoolImpl = class {
   pending = /* @__PURE__ */ new Map();
   nextMessageId = 0;
   queue = [];
+  mem;
   memoryManager;
+  /** A caller-supplied buffer shipped via INIT_MEMORY (sub-worker / second-pool sharing). */
+  injectedBuffer;
   workerUrl;
   spawn;
   concurrency;
@@ -375,6 +654,9 @@ var WorkerPoolImpl = class {
   respawn;
   taskTimeout;
   closed = false;
+  /** Dashboard fault injection (`pool.chaos`); null unless devtools set it. */
+  chaos = null;
+  devtoolsOff;
   drainWaiters = [];
   statsAgg = {
     completed: 0,
@@ -384,17 +666,18 @@ var WorkerPoolImpl = class {
     waitMs: agg(),
     runMs: agg()
   };
+  /**
+   * Devtools correlation id, stamped on every event this pool emits:
+   * '<name>-p' when the config has a `name`, else 'pool-N'.
+   */
+  poolId;
+  label;
+  nextCallId = 0;
   sharedMemory;
   /** The attached memory-persistence adapter, if the config supplied one. */
   persistence;
   constructor(config) {
-    if (config.sharedMemory) {
-      if (typeof SharedArrayBuffer === "undefined" || typeof crossOriginIsolated !== "undefined" && !crossOriginIsolated) {
-        throw new Error(
-          "WorkerPool requires SharedArrayBuffer in a cross-origin isolated context \u2014 serve the page with COOP/COEP headers."
-        );
-      }
-    }
+    const mem = setupChannelMemory(config, "WorkerPool");
     if (!config.workerUrl && !config.createWorker) {
       throw new Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
     }
@@ -404,23 +687,49 @@ var WorkerPoolImpl = class {
     this.maxQueue = config.maxQueue ?? Infinity;
     this.respawn = config.respawn ?? true;
     this.taskTimeout = config.taskTimeout;
-    if (config.sharedMemory) {
-      this.sharedMemory = config.sharedMemory;
-      this.memoryManager = new MemoryManager(config.memory);
-      this.memoryManager.ensureCapacity(this.sharedMemory.totalBytes);
-      this.sharedMemory.bind(this.memoryManager.getBuffer());
-      this.persistence = config.persistence?.(config.sharedMemory);
-    }
+    this.label = config.name;
+    this.poolId = nextDevtoolsId("pool", config.name);
+    this.mem = mem;
+    this.sharedMemory = mem.sharedMemory;
+    this.memoryManager = mem.memoryManager;
+    this.injectedBuffer = mem.injectedBuffer;
+    this.persistence = mem.persistence;
     const requestedSize = config.poolSize ?? "auto";
-    const poolSize = requestedSize === "auto" ? navigator.hardwareConcurrency ?? 4 : requestedSize;
+    const poolSize = requestedSize === "auto" ? typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 4 : 4 : requestedSize;
     poolLog.info(
-      this.sharedMemory ? `spawning ${poolSize} worker(s) with ${fmtBytes(this.sharedMemory.totalBytes)} shared buffer` : `spawning ${poolSize} worker(s), message-only`,
+      this.sharedMemory ? `spawning ${poolSize} worker(s) with ${fmtBytes(this.sharedMemory.totalBytes)} shared buffer` : this.injectedBuffer ? `spawning ${poolSize} worker(s) with ${fmtBytes(this.injectedBuffer.byteLength)} inherited buffer` : `spawning ${poolSize} worker(s), message-only`,
       { workerUrl: config.workerUrl ? String(config.workerUrl) : "createWorker()" }
     );
     poolLog.debug(`tip: setLogLevel('trace') for per-task detail`);
+    emitDevtools({
+      type: "pool:init",
+      poolId: this.poolId,
+      label: this.label,
+      poolSize,
+      concurrency: this.concurrency,
+      memoryBytes: this.sharedMemory?.totalBytes ?? this.injectedBuffer?.byteLength
+    });
     for (let i = 0; i < poolSize; i++) {
       this.addWorker(this.spawn());
     }
+    if (devtoolsEnabled()) {
+      this.devtoolsOff = registerDevtoolsRunner({
+        poolId: this.poolId,
+        label: this.label,
+        dedicated: false,
+        size: () => this.slots.length,
+        stats: () => this.stats(),
+        kill: (slot) => {
+          const s = this.slots[slot];
+          if (!s) throw new Error(`${this.poolId} has no worker slot ${slot}`);
+          this.handleWorkerError(s, { message: KILL_MESSAGE });
+        },
+        getChaos: () => this.chaos,
+        setChaos: (chaos) => {
+          this.chaos = chaos;
+        }
+      });
+    }
     const tasks = config.tasks ?? {};
     for (const [name, contract] of Object.entries(tasks)) {
       if (name in this) {
@@ -437,18 +746,20 @@ var WorkerPoolImpl = class {
   addWorker(worker) {
     const slot = { worker, inFlight: 0 };
     worker.addEventListener("message", (event) => {
-      this.handleReply(slot, event.data);
+      const data = event.data;
+      if (data.type === "ATOLL_DEVTOOLS" && data.event) {
+        forwardWorkerDevtools(this.poolId, this.slots.indexOf(slot), data.event);
+        return;
+      }
+      this.handleReply(slot, data);
     });
     worker.addEventListener("error", (event) => {
       this.handleWorkerError(slot, event);
     });
-    if (this.memoryManager) {
-      worker.postMessage({ type: "INIT_MEMORY", memory: this.memoryManager.memory });
-    } else {
-      worker.postMessage({ type: "INIT" });
-    }
+    const init = sendInit(worker, this.mem);
     this.slots.push(slot);
-    poolLog.debug(`worker spawned, ${this.memoryManager ? "INIT_MEMORY" : "INIT"} sent`);
+    poolLog.debug(`worker spawned, ${init} sent`);
+    emitDevtools({ type: "worker:spawn", poolId: this.poolId, slot: this.slots.indexOf(slot) });
     return slot;
   }
   handleReply(slot, data) {
@@ -459,14 +770,24 @@ var WorkerPoolImpl = class {
     this.detach(entry);
     if (!entry.done) {
       entry.done = true;
-      this.statsAgg.runMs.add(performance.now() - (entry.sentAt ?? entry.enqueuedAt));
+      const start = entry.sentAt ?? entry.enqueuedAt;
+      const runMs = performance.now() - start;
+      this.statsAgg.runMs.add(runMs);
       if (data.success) {
         this.statsAgg.completed++;
         taskLog.debug(`\u2190 ${entry.contract.taskId} ok`);
+        if (devtoolsEnabled()) {
+          emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "ok", runMs, resultBytes: estimateCloneBytes(data.result) });
+          measureTaskCall(this.poolId, entry.contract.taskId, entry.callId, this.slots.indexOf(slot), start, start + runMs, true);
+        }
         entry.resolve(data.result);
       } else {
         this.statsAgg.failed++;
         taskLog.warn(`\u2190 ${entry.contract.taskId} failed: ${data.error}`);
+        if (devtoolsEnabled()) {
+          emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "error", runMs, error: data.error });
+          measureTaskCall(this.poolId, entry.contract.taskId, entry.callId, this.slots.indexOf(slot), start, start + runMs, false);
+        }
         entry.reject(new Error(data.error));
       }
     }
@@ -478,6 +799,8 @@ var WorkerPoolImpl = class {
     const e = event;
     const message = e?.message ?? (e?.error ? String(e.error) : "worker error");
     poolLog.warn(`worker error: ${message}`);
+    const idx = this.slots.indexOf(slot);
+    emitDevtools({ type: "worker:error", poolId: this.poolId, slot: idx, message });
     for (const [id, entry] of [...this.pending]) {
       if (entry.slot === slot) {
         this.pending.delete(id);
@@ -485,20 +808,22 @@ var WorkerPoolImpl = class {
         if (entry.done) continue;
         entry.done = true;
         this.statsAgg.failed++;
+        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "crashed", error: message });
         entry.reject(new WorkerCrashedError(message));
       }
     }
-    const idx = this.slots.indexOf(slot);
     if (idx >= 0) this.slots.splice(idx, 1);
     slot.worker.terminate();
     if (this.respawn) {
       poolLog.info("respawning crashed worker");
       this.addWorker(this.spawn());
+      emitDevtools({ type: "worker:respawn", poolId: this.poolId, slot: this.slots.length - 1 });
     } else if (this.slots.length === 0) {
       for (const entry of this.queue.splice(0)) {
         entry.done = true;
         this.detach(entry);
         this.statsAgg.failed++;
+        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "crashed", error: message });
         entry.reject(new WorkerCrashedError(message));
       }
     }
@@ -527,16 +852,26 @@ var WorkerPoolImpl = class {
     entry.messageId = messageId;
     entry.slot = slot;
     entry.sentAt = performance.now();
-    this.statsAgg.waitMs.add(performance.now() - entry.enqueuedAt);
+    const waitMs = entry.sentAt - entry.enqueuedAt;
+    this.statsAgg.waitMs.add(waitMs);
     slot.inFlight++;
     this.pending.set(messageId, entry);
-    taskLog.debug(`\u2192 ${entry.contract.taskId}`, { worker: this.slots.indexOf(slot), args: entry.args });
-    slot.worker.postMessage({
-      type: "EXECUTE_TASK",
-      messageId,
-      taskId: entry.contract.taskId,
-      args: entry.args
-    });
+    const slotIndex = this.slots.indexOf(slot);
+    taskLog.debug(`\u2192 ${entry.contract.taskId}`, { worker: slotIndex, args: entry.args });
+    if (devtoolsEnabled()) {
+      emitDevtools({ type: "task:dispatch", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, slot: slotIndex, waitMs, argBytes: estimateCloneBytes(entry.args) });
+    }
+    const msg = { type: "EXECUTE_TASK", messageId, taskId: entry.contract.taskId, args: entry.args };
+    if (this.chaos) {
+      applyChaos(this.chaos, {
+        live: () => this.pending.get(messageId) === entry,
+        fail: () => this.handleReply(slot, { messageId, taskId: msg.taskId, success: false, error: CHAOS_FAILURE }),
+        timeout: () => this.cancel(entry, new TaskTimeoutError()),
+        post: () => slot.worker.postMessage(msg)
+      });
+    } else {
+      slot.worker.postMessage(msg);
+    }
   }
   /** Detaches signal/timeout listeners from a finalized entry. */
   detach(entry) {
@@ -557,6 +892,7 @@ var WorkerPoolImpl = class {
     entry.done = true;
     this.detach(entry);
     this.statsAgg.aborted++;
+    emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: err instanceof TaskTimeoutError ? "timeout" : "aborted" });
     entry.reject(err);
     this.drainQueue();
     this.checkDrained();
@@ -582,6 +918,7 @@ var WorkerPoolImpl = class {
       const entry = {
         contract,
         args,
+        callId: ++this.nextCallId,
         enqueuedAt: performance.now(),
         resolve,
         reject,
@@ -596,12 +933,14 @@ var WorkerPoolImpl = class {
       if (timeout !== void 0) {
         entry.timer = setTimeout(() => this.cancel(entry, new TaskTimeoutError()), timeout);
       }
+      emitDevtools({ type: "task:enqueue", poolId: this.poolId, callId: entry.callId, taskId: contract.taskId });
       const slot = this.pickWorker();
       if (slot) {
         this.send(slot, entry);
       } else if (this.queue.length >= this.maxQueue) {
         entry.done = true;
         this.detach(entry);
+        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: contract.taskId, outcome: "queue-full" });
         reject(new PoolQueueFullError());
         return;
       } else {
@@ -622,7 +961,7 @@ var WorkerPoolImpl = class {
    * (e.g. a second pool of HTTP workers via withSharedBuffer).
    */
   get sharedBuffer() {
-    return this.memoryManager?.getBuffer();
+    return this.memoryManager?.getBuffer() ?? this.injectedBuffer;
   }
   /**
    * Live snapshot of the pool's worker slots — for auxiliary messaging that
@@ -662,16 +1001,19 @@ var WorkerPoolImpl = class {
   }
   terminate() {
     this.closed = true;
+    this.devtoolsOff?.();
     void this.persistence?.stop()?.catch?.(
       (e) => poolLog.warn("memory persistence stop failed", e)
     );
     poolLog.info(`terminating ${this.slots.length} worker(s)`);
+    emitDevtools({ type: "pool:terminate", poolId: this.poolId });
     const crashed = new WorkerCrashedError("pool terminated");
     for (const [, entry] of this.pending) {
       this.detach(entry);
       if (entry.done) continue;
       entry.done = true;
       this.statsAgg.failed++;
+      emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "crashed", error: "pool terminated" });
       entry.reject(crashed);
     }
     this.pending.clear();
@@ -679,6 +1021,7 @@ var WorkerPoolImpl = class {
       entry.done = true;
       this.detach(entry);
       this.statsAgg.failed++;
+      emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "crashed", error: "pool terminated" });
       entry.reject(crashed);
     }
     for (const slot of this.slots) {

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   WorkerPool,
   bindSharedMemories
-} from "./chunk-QD4C3PWH.js";
+} from "./chunk-VEJT6OVD.js";
 
 // src/worker.ts
 import { Worker as NodeWorker } from "node:worker_threads";

package/dist/redis.js

@@ -1,6 +1,6 @@
 import {
   scoped
-} from "./chunk-QD4C3PWH.js";
+} from "./chunk-VEJT6OVD.js";
 
 // src/redis.ts
 var log = scoped("redis-mem");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolljs/node",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Node runtime adapter — node:worker_threads pools, no framework",
   "homepage": "https://jwhenry3.github.io/atolljs/consumer/quickstart/",
   "type": "module",
@@ -34,7 +34,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {
-    "@atolljs/core": "0.1.6"
+    "@atolljs/core": "0.1.8"
   },
   "repository": {
     "type": "git",