@atolljs/node 0.1.6 → 0.1.7

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

@@ -24,6 +24,20 @@ function scoped(scope) {
 }
 var fmtBytes = (bytes) => bytes >= 1 << 20 ? `${(bytes / (1 << 20)).toFixed(1)}MB` : bytes >= 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
 
+// ../../src/devtools.ts
+var THREAD2 = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope ? "worker" : "main";
+var sink2 = null;
+var emitDevtools = (event) => {
+  if (sink2) sink2({ ...event, at: performance.now(), thread: THREAD2 });
+};
+var forwardDevtools = (event) => {
+  if (sink2) sink2(event);
+};
+var devtoolsEnabled = () => sink2 !== null;
+var BODY_PREVIEW = 8 * 1024;
+var seq = 0;
+var nextDevtoolsId = (prefix) => `${prefix}-${++seq}`;
+
 // ../../src/contract/sharedMemory.ts
 var memLog = scoped("memory");
 var codecTextEncoder = new TextEncoder();
@@ -246,8 +260,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)),
@@ -384,6 +401,10 @@ var WorkerPoolImpl = class {
     waitMs: agg(),
     runMs: agg()
   };
+  /** Devtools correlation id ('pool-N') — stamped on every event this pool emits. */
+  poolId = nextDevtoolsId("pool");
+  label;
+  nextCallId = 0;
   sharedMemory;
   /** The attached memory-persistence adapter, if the config supplied one. */
   persistence;
@@ -404,6 +425,7 @@ var WorkerPoolImpl = class {
     this.maxQueue = config.maxQueue ?? Infinity;
     this.respawn = config.respawn ?? true;
     this.taskTimeout = config.taskTimeout;
+    this.label = config.name;
     if (config.sharedMemory) {
       this.sharedMemory = config.sharedMemory;
       this.memoryManager = new MemoryManager(config.memory);
@@ -418,6 +440,14 @@ var WorkerPoolImpl = class {
       { 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
+    });
     for (let i = 0; i < poolSize; i++) {
       this.addWorker(this.spawn());
     }
@@ -437,18 +467,27 @@ 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) {
+        forwardDevtools({
+          ...data.event,
+          worker: { poolId: this.poolId, slot: this.slots.indexOf(slot) }
+        });
+        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 });
+      worker.postMessage({ type: "INIT_MEMORY", memory: this.memoryManager.memory, devtools: devtoolsEnabled() });
     } else {
-      worker.postMessage({ type: "INIT" });
+      worker.postMessage({ type: "INIT", devtools: devtoolsEnabled() });
     }
     this.slots.push(slot);
     poolLog.debug(`worker spawned, ${this.memoryManager ? "INIT_MEMORY" : "INIT"} sent`);
+    emitDevtools({ type: "worker:spawn", poolId: this.poolId, slot: this.slots.indexOf(slot) });
     return slot;
   }
   handleReply(slot, data) {
@@ -459,14 +498,17 @@ var WorkerPoolImpl = class {
     this.detach(entry);
     if (!entry.done) {
       entry.done = true;
-      this.statsAgg.runMs.add(performance.now() - (entry.sentAt ?? entry.enqueuedAt));
+      const runMs = performance.now() - (entry.sentAt ?? entry.enqueuedAt);
+      this.statsAgg.runMs.add(runMs);
       if (data.success) {
         this.statsAgg.completed++;
         taskLog.debug(`\u2190 ${entry.contract.taskId} ok`);
+        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "ok", runMs });
         entry.resolve(data.result);
       } else {
         this.statsAgg.failed++;
         taskLog.warn(`\u2190 ${entry.contract.taskId} failed: ${data.error}`);
+        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "error", runMs, error: data.error });
         entry.reject(new Error(data.error));
       }
     }
@@ -478,6 +520,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 +529,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,10 +573,13 @@ 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 });
+    const slotIndex = this.slots.indexOf(slot);
+    taskLog.debug(`\u2192 ${entry.contract.taskId}`, { worker: slotIndex, args: entry.args });
+    emitDevtools({ type: "task:dispatch", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, slot: slotIndex, waitMs });
     slot.worker.postMessage({
       type: "EXECUTE_TASK",
       messageId,
@@ -557,6 +606,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 +632,7 @@ var WorkerPoolImpl = class {
       const entry = {
         contract,
         args,
+        callId: ++this.nextCallId,
         enqueuedAt: performance.now(),
         resolve,
         reject,
@@ -596,12 +647,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 {
@@ -666,12 +719,14 @@ var WorkerPoolImpl = class {
       (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 +734,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-SHWEILEH.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-SHWEILEH.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.7",
   "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.7"
   },
   "repository": {
     "type": "git",