@atolljs/node 0.1.7 → 0.1.9

package/dist/{chunk-SHWEILEH.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 {
@@ -24,20 +126,6 @@ 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();
@@ -366,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");
@@ -384,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;
@@ -392,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,
@@ -401,21 +666,18 @@ var WorkerPoolImpl = class {
     waitMs: agg(),
     runMs: agg()
   };
-  /** Devtools correlation id ('pool-N') — stamped on every event this pool emits. */
-  poolId = nextDevtoolsId("pool");
+  /**
+   * 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.");
     }
@@ -426,17 +688,16 @@ var WorkerPoolImpl = class {
     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);
-      this.memoryManager.ensureCapacity(this.sharedMemory.totalBytes);
-      this.sharedMemory.bind(this.memoryManager.getBuffer());
-      this.persistence = config.persistence?.(config.sharedMemory);
-    }
+    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`);
@@ -446,11 +707,29 @@ var WorkerPoolImpl = class {
       label: this.label,
       poolSize,
       concurrency: this.concurrency,
-      memoryBytes: this.sharedMemory?.totalBytes
+      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) {
@@ -469,10 +748,7 @@ var WorkerPoolImpl = class {
     worker.addEventListener("message", (event) => {
       const data = event.data;
       if (data.type === "ATOLL_DEVTOOLS" && data.event) {
-        forwardDevtools({
-          ...data.event,
-          worker: { poolId: this.poolId, slot: this.slots.indexOf(slot) }
-        });
+        forwardWorkerDevtools(this.poolId, this.slots.indexOf(slot), data.event);
         return;
       }
       this.handleReply(slot, data);
@@ -480,13 +756,9 @@ var WorkerPoolImpl = class {
     worker.addEventListener("error", (event) => {
       this.handleWorkerError(slot, event);
     });
-    if (this.memoryManager) {
-      worker.postMessage({ type: "INIT_MEMORY", memory: this.memoryManager.memory, devtools: devtoolsEnabled() });
-    } else {
-      worker.postMessage({ type: "INIT", devtools: devtoolsEnabled() });
-    }
+    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;
   }
@@ -498,17 +770,24 @@ var WorkerPoolImpl = class {
     this.detach(entry);
     if (!entry.done) {
       entry.done = true;
-      const runMs = 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`);
-        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "ok", runMs });
+        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}`);
-        emitDevtools({ type: "task:settle", poolId: this.poolId, callId: entry.callId, taskId: entry.contract.taskId, outcome: "error", runMs, error: 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));
       }
     }
@@ -579,13 +858,20 @@ var WorkerPoolImpl = class {
     this.pending.set(messageId, entry);
     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,
-      taskId: entry.contract.taskId,
-      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) {
@@ -675,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
@@ -715,6 +1001,7 @@ var WorkerPoolImpl = class {
   }
   terminate() {
     this.closed = true;
+    this.devtoolsOff?.();
     void this.persistence?.stop()?.catch?.(
       (e) => poolLog.warn("memory persistence stop failed", e)
     );

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   WorkerPool,
   bindSharedMemories
-} from "./chunk-SHWEILEH.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-SHWEILEH.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.7",
+  "version": "0.1.9",
   "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.7"
+    "@atolljs/core": "0.1.9"
   },
   "repository": {
     "type": "git",