@atolljs/node 0.1.12 → 0.1.14

package/dist/index.js

@@ -1,8 +1,3 @@
-import {
-  WorkerPool,
-  bindSharedMemories
-} from "./chunk-VEJT6OVD.js";
-
 // src/worker.ts
 import { Worker as NodeWorker } from "node:worker_threads";
 var NodeWorkerAdapter = class {
@@ -62,6 +57,9 @@ function createNodeWorker(source, options) {
 
 // src/pool.ts
 import { Worker as NodeWorker2 } from "node:worker_threads";
+import {
+  WorkerPool
+} from "@atolljs/core";
 var toWorker = (w) => w instanceof NodeWorker2 ? createNodeWorker(w) : w;
 function createNodePool(config) {
   const { workerFile, worker, createWorker, ...rest } = config;
@@ -80,6 +78,7 @@ function createNodePool(config) {
 
 // src/sharedBuffer.ts
 import { isMainThread, parentPort, workerData } from "node:worker_threads";
+import { bindSharedMemories } from "@atolljs/core";
 var SHARED_BUFFER = "SHARED_BUFFER";
 function withSharedBuffer(spawn, buffer) {
   return () => {

package/dist/redis.js

@@ -1,8 +1,5 @@
-import {
-  scoped
-} from "./chunk-VEJT6OVD.js";
-
 // src/redis.ts
+import { scoped } from "@atolljs/core";
 var log = scoped("redis-mem");
 var ioRedisSubscriber = (client) => ({
   subscribe: (channel, onMessage) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolljs/node",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "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.12"
+    "@atolljs/core": "^0.1.14"
   },
   "repository": {
     "type": "git",

package/dist/chunk-VEJT6OVD.js

@@ -1,1040 +0,0 @@
-// ../../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 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;
-  if (data !== void 0) fn(`${prefix} ${message}`, data);
-  else fn(`${prefix} ${message}`);
-};
-var minLevel = "info";
-var sink2 = consoleSink;
-var teeing = false;
-function log(level, scope, message, data) {
-  if (LEVELS[level] < LEVELS[minLevel]) return;
-  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 {
-    trace: (message, data) => log("trace", scope, message, data),
-    debug: (message, data) => log("debug", scope, message, data),
-    info: (message, data) => log("info", scope, message, data),
-    warn: (message, data) => log("warn", scope, message, data),
-    error: (message, data) => log("error", scope, message, data)
-  };
-}
-var fmtBytes = (bytes) => bytes >= 1 << 20 ? `${(bytes / (1 << 20)).toFixed(1)}MB` : bytes >= 1024 ? `${(bytes / 1024).toFixed(1)}KB` : `${bytes}B`;
-
-// ../../src/contract/sharedMemory.ts
-var memLog = scoped("memory");
-var codecTextEncoder = new TextEncoder();
-var codecTextDecoder = new TextDecoder();
-var CONNECTOR_FACTORIES = /* @__PURE__ */ new Map();
-function registerConnectorFactory(kind, factory) {
-  CONNECTOR_FACTORIES.set(kind, factory);
-}
-var TYPED_ARRAYS = {
-  Int32: Int32Array,
-  Float64: Float64Array,
-  BigInt64: BigInt64Array,
-  Uint8: Uint8Array
-};
-registerConnectorFactory("number", (d, ctx, byteOffset) => {
-  const view = new Float64Array(ctx.buffer, byteOffset, 1);
-  return { byteOffset, byteLength: d.byteLength, read: () => view[0], write: (v) => {
-    view[0] = v;
-  } };
-});
-registerConnectorFactory("boolean", (d, ctx, byteOffset) => {
-  const view = new Uint8Array(ctx.buffer, byteOffset, 1);
-  return { byteOffset, byteLength: d.byteLength, read: () => view[0] === 1, write: (v) => {
-    view[0] = v ? 1 : 0;
-  } };
-});
-for (const kind of Object.keys(TYPED_ARRAYS)) {
-  registerConnectorFactory(kind, (d, ctx, byteOffset) => {
-    const Ctor = TYPED_ARRAYS[kind];
-    const view = new Ctor(ctx.buffer, byteOffset, d.byteLength / Ctor.BYTES_PER_ELEMENT);
-    return { byteOffset, byteLength: d.byteLength, read: () => view, write: (v) => view.set(v) };
-  });
-}
-registerConnectorFactory("string", (d, ctx, byteOffset) => {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const capacity = d.byteLength - 4;
-  const lengthView = new Uint32Array(ctx.buffer, byteOffset, 1);
-  const writeBytes = (bytes) => {
-    if (bytes.byteLength > capacity) {
-      throw new Error(`Encoded value of ${bytes.byteLength} bytes exceeds field capacity of ${capacity} bytes at offset ${byteOffset}`);
-    }
-    lengthView[0] = bytes.byteLength;
-    new Uint8Array(ctx.buffer, byteOffset + 4, bytes.byteLength).set(bytes);
-  };
-  const readBytes = () => new Uint8Array(ctx.buffer, byteOffset + 4, lengthView[0]).slice();
-  return {
-    byteOffset,
-    byteLength: d.byteLength,
-    read: () => decoder.decode(readBytes()),
-    write: (v) => writeBytes(encoder.encode(d.schema ? d.schema.parse(v) : v))
-  };
-});
-function makeIO(ctx) {
-  const view = new DataView(ctx.buffer);
-  const byteView = new Uint8Array(ctx.buffer);
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  const scalarIO = {
-    i8: { get: (o) => view.getInt8(o), set: (o, v) => view.setInt8(o, v) },
-    u8: { get: (o) => view.getUint8(o), set: (o, v) => view.setUint8(o, v) },
-    i16: { get: (o) => view.getInt16(o), set: (o, v) => view.setInt16(o, v) },
-    u16: { get: (o) => view.getUint16(o), set: (o, v) => view.setUint16(o, v) },
-    i32: { get: (o) => view.getInt32(o), set: (o, v) => view.setInt32(o, v) },
-    u32: { get: (o) => view.getUint32(o), set: (o, v) => view.setUint32(o, v) },
-    f32: { get: (o) => view.getFloat32(o), set: (o, v) => view.setFloat32(o, v) },
-    f64: { get: (o) => view.getFloat64(o), set: (o, v) => view.setFloat64(o, v) },
-    i64: { get: (o) => view.getBigInt64(o), set: (o, v) => view.setBigInt64(o, v) },
-    u64: { get: (o) => view.getBigUint64(o), set: (o, v) => view.setBigUint64(o, v) }
-  };
-  const readString = (offset, max) => {
-    const zero = byteView.indexOf(0, offset);
-    const len = zero === -1 || zero - offset >= max ? max : zero - offset;
-    return decoder.decode(byteView.slice(offset, offset + len));
-  };
-  let scratch = new Uint8Array(64);
-  const writeString = (offset, max, value) => {
-    if (scratch.length < max) scratch = new Uint8Array(max);
-    const { read, written } = encoder.encodeInto(value, scratch);
-    if (read < value.length || written > max) {
-      throw new Error(`String exceeds inline field capacity of ${max} bytes`);
-    }
-    byteView.set(scratch.subarray(0, written), offset);
-    if (written < max) byteView.fill(0, offset + written, offset + max);
-  };
-  const ops = (spec) => {
-    if (typeof spec === "string") {
-      const io = scalarIO[spec];
-      return { get: (o) => io.get(o), set: (o, v) => io.set(o, v) };
-    }
-    if ("bool" in spec) {
-      return { get: (o) => !!view.getUint8(o), set: (o, v) => view.setUint8(o, v ? 1 : 0) };
-    }
-    return { get: (o) => readString(o, spec.string), set: (o, v) => writeString(o, spec.string, v) };
-  };
-  const compile = (layout, offsets) => {
-    const readers = /* @__PURE__ */ new Map();
-    const writers = /* @__PURE__ */ new Map();
-    for (const key of Object.keys(layout)) {
-      const { get, set } = ops(layout[key]);
-      const rel = offsets[key];
-      readers.set(key, (base, out) => {
-        out[key] = get(base + rel);
-      });
-      writers.set(key, (base, record) => set(base + rel, record[key]));
-    }
-    const allReaders = [...readers.values()];
-    const allWriters = [...writers.values()];
-    return {
-      read(base, out = {}, fieldNames) {
-        if (fieldNames) {
-          for (const key of fieldNames) readers.get(key)(base, out);
-        } else {
-          for (const read of allReaders) read(base, out);
-        }
-        return out;
-      },
-      write(base, record, fieldNames) {
-        if (fieldNames) {
-          for (const key of fieldNames) writers.get(key)(base, record);
-        } else {
-          for (const write of allWriters) write(base, record);
-        }
-      }
-    };
-  };
-  return { ops, compile };
-}
-var structuredFactory = (d, ctx, byteOffset) => {
-  const { schema, byteLength, kind } = d;
-  const fixed = d;
-  if (fixed.layout && fixed.offsets && fixed.recordSize !== void 0) {
-    const flag = new Uint32Array(ctx.buffer, byteOffset, 2);
-    const base = byteOffset + 8;
-    const record = makeIO(ctx).compile(fixed.layout, fixed.offsets);
-    return {
-      byteOffset,
-      byteLength,
-      read: () => flag[0] ? record.read(base, {}) : void 0,
-      // unwritten on either thread
-      write: (v) => {
-        record.write(base, schema ? schema.parse(v) : v);
-        flag[0] = 1;
-      }
-    };
-  }
-  if (fixed.element !== void 0 && fixed.elementStride !== void 0 && fixed.capacity !== void 0) {
-    const flag = new Uint32Array(ctx.buffer, byteOffset, 1);
-    const count = new Uint32Array(ctx.buffer, byteOffset + 4, 1);
-    const el = makeIO(ctx).ops(fixed.element);
-    const stride = fixed.elementStride;
-    const capacity2 = fixed.capacity;
-    const base = byteOffset + 8;
-    return {
-      byteOffset,
-      byteLength,
-      read: () => {
-        if (!flag[0]) return void 0;
-        const n = count[0];
-        return Array.from({ length: n }, (_, i) => el.get(base + i * stride));
-      },
-      write: (v) => {
-        const parsed = schema ? schema.parse(v) : v;
-        if (parsed.length > capacity2) {
-          throw new Error(`${parsed.length} elements exceeds array capacity of ${capacity2}`);
-        }
-        parsed.forEach((v2, i) => el.set(base + i * stride, v2));
-        count[0] = parsed.length;
-        flag[0] = 1;
-      }
-    };
-  }
-  const capacity = byteLength - 4;
-  const lengthView = new Uint32Array(ctx.buffer, byteOffset, 1);
-  const writeBytes = (bytes) => {
-    if (bytes.byteLength > capacity) {
-      throw new Error(`Encoded value of ${bytes.byteLength} bytes exceeds field capacity of ${capacity} bytes at offset ${byteOffset}`);
-    }
-    lengthView[0] = bytes.byteLength;
-    new Uint8Array(ctx.buffer, byteOffset + 4, bytes.byteLength).set(bytes);
-  };
-  const readBytes = () => new Uint8Array(ctx.buffer, byteOffset + 4, lengthView[0]).slice();
-  return {
-    byteOffset,
-    byteLength,
-    read: () => {
-      const bytes = readBytes();
-      if (bytes.byteLength === 0) return void 0;
-      const value = ctx.codec.decode(bytes);
-      return schema ? schema.parse(value) : value;
-    },
-    write: (v) => writeBytes(ctx.codec.encode(schema ? schema.parse(v) : v))
-  };
-};
-registerConnectorFactory("object", structuredFactory);
-registerConnectorFactory("array", structuredFactory);
-function listFactory(d, ctx, byteOffset) {
-  const info = d;
-  const { offsets, recordSize, count } = info;
-  const record = makeIO(ctx).compile(info.layout, offsets);
-  const checkIndex = (index) => {
-    if (index < 0 || index >= count) {
-      throw new RangeError(`Record index ${index} out of bounds (0..${count - 1})`);
-    }
-  };
-  const readAt = (index, out = {}, fieldNames) => {
-    checkIndex(index);
-    return record.read(byteOffset + index * recordSize, out, fieldNames);
-  };
-  const writeAt = (index, rec, fieldNames) => {
-    checkIndex(index);
-    record.write(byteOffset + index * recordSize, rec, fieldNames);
-  };
-  const connector = {
-    byteOffset,
-    byteLength: d.byteLength,
-    recordCount: count,
-    recordSize,
-    readAt,
-    writeAt,
-    commit: () => {
-      if (ctx.version) {
-        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)),
-    write: (records) => {
-      if (records.length > count) {
-        throw new Error(`${records.length} records exceeds list array capacity of ${count}`);
-      }
-      records.forEach((r, i) => writeAt(i, r));
-    }
-  };
-  return connector;
-}
-registerConnectorFactory("list", listFactory);
-var definedSharedMemories = [];
-function bindSharedMemories(buffer) {
-  for (const memory of definedSharedMemories) {
-    memory.bind(buffer);
-  }
-  memLog.info(`bound ${definedSharedMemories.length} contract(s) \u2014 ${fmtBytes(buffer.byteLength)} buffer`);
-}
-
-// ../../src/pool/memory.ts
-var MemoryManager = class {
-  memory;
-  maxPages;
-  constructor(config = {}) {
-    const initialPages = config.initialPages ?? 16;
-    this.maxPages = config.maximumPages ?? 16384;
-    this.memory = new WebAssembly.Memory({
-      initial: initialPages,
-      maximum: this.maxPages,
-      shared: true
-    });
-  }
-  /**
-   * Automatically checks if memory needs to grow to accommodate new bytes,
-   * and expands via memory.grow() if necessary. Thread-safe.
-   */
-  ensureCapacity(requiredBytes) {
-    const currentByteLength = this.memory.buffer.byteLength;
-    if (currentByteLength >= requiredBytes) return;
-    const bytesNeeded = requiredBytes - currentByteLength;
-    const pagesNeeded = Math.ceil(bytesNeeded / 65536);
-    const currentPages = this.memory.buffer.byteLength / 65536;
-    if (currentPages + pagesNeeded > this.maxPages) {
-      throw new Error(`Cannot grow memory: exceeds maximum page limit of ${this.maxPages}`);
-    }
-    this.memory.grow(pagesNeeded);
-  }
-  /**
-   * Creates a typed view over the shared memory buffer at a specific byte offset.
-   */
-  getView(type, byteOffset = 0, length) {
-    const buffer = this.memory.buffer;
-    switch (type) {
-      case "Int32":
-        return new Int32Array(buffer, byteOffset, length);
-      case "Float64":
-        return new Float64Array(buffer, byteOffset, length);
-      case "BigInt64":
-        return new BigInt64Array(buffer, byteOffset, length);
-      case "Uint8":
-        return new Uint8Array(buffer, byteOffset, length);
-      default:
-        throw new Error(`Unsupported view type: ${type}`);
-    }
-  }
-  /**
-   * Exposes the raw SharedArrayBuffer
-   */
-  getBuffer() {
-    return this.memory.buffer;
-  }
-};
-
-// ../../src/pool/errors.ts
-var PoolQueueFullError = class extends Error {
-  constructor(message = "WorkerPool task queue is full") {
-    super(message);
-    this.name = "PoolQueueFullError";
-  }
-};
-var TaskAbortedError = class extends Error {
-  constructor(message = "task aborted") {
-    super(message);
-    this.name = "AbortError";
-  }
-};
-var TaskTimeoutError = class extends Error {
-  constructor(message = "task timed out") {
-    super(message);
-    this.name = "TaskTimeoutError";
-  }
-};
-var WorkerCrashedError = class extends Error {
-  constructor(message = "worker crashed") {
-    super(message);
-    this.name = "WorkerCrashedError";
-  }
-};
-
-// ../../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");
-var agg = () => ({
-  count: 0,
-  mean: 0,
-  max: 0,
-  add(v) {
-    this.count++;
-    this.mean += (v - this.mean) / this.count;
-    if (v > this.max) this.max = v;
-  }
-});
-var WorkerPoolImpl = class {
-  slots = [];
-  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;
-  maxQueue;
-  respawn;
-  taskTimeout;
-  closed = false;
-  /** Dashboard fault injection (`pool.chaos`); null unless devtools set it. */
-  chaos = null;
-  devtoolsOff;
-  drainWaiters = [];
-  statsAgg = {
-    completed: 0,
-    failed: 0,
-    /** aborts + timeouts. */
-    aborted: 0,
-    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) {
-    const mem = setupChannelMemory(config, "WorkerPool");
-    if (!config.workerUrl && !config.createWorker) {
-      throw new Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
-    }
-    this.workerUrl = config.workerUrl;
-    this.spawn = config.createWorker ?? (() => new Worker(this.workerUrl, { type: "module" }));
-    this.concurrency = config.concurrency ?? 1;
-    this.maxQueue = config.maxQueue ?? Infinity;
-    this.respawn = config.respawn ?? true;
-    this.taskTimeout = config.taskTimeout;
-    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" ? typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 4 : 4 : requestedSize;
-    poolLog.info(
-      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) {
-        poolLog.warn(`task "${name}" collides with a WorkerPool member \u2014 not installed`);
-        continue;
-      }
-      this[name] = (...args) => this.runTask(contract, ...args);
-    }
-    if (Object.keys(tasks).length > 0) {
-      poolLog.info(`task methods: ${Object.keys(tasks).join(", ")}`);
-    }
-  }
-  /** Adds a spawned worker: one message + one error listener, then the INIT handshake. */
-  addWorker(worker) {
-    const slot = { worker, inFlight: 0 };
-    worker.addEventListener("message", (event) => {
-      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);
-    });
-    const init = sendInit(worker, this.mem);
-    this.slots.push(slot);
-    poolLog.debug(`worker spawned, ${init} sent`);
-    emitDevtools({ type: "worker:spawn", poolId: this.poolId, slot: this.slots.indexOf(slot) });
-    return slot;
-  }
-  handleReply(slot, data) {
-    const entry = data.messageId !== void 0 ? this.pending.get(data.messageId) : void 0;
-    if (!entry) return;
-    this.pending.delete(data.messageId);
-    slot.inFlight--;
-    this.detach(entry);
-    if (!entry.done) {
-      entry.done = true;
-      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));
-      }
-    }
-    this.drainQueue();
-    this.checkDrained();
-  }
-  handleWorkerError(slot, event) {
-    if (this.closed) return;
-    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);
-        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: message });
-        entry.reject(new WorkerCrashedError(message));
-      }
-    }
-    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));
-      }
-    }
-    this.drainQueue();
-    this.checkDrained();
-  }
-  /** Least-busy worker below its concurrency cap, if any. */
-  pickWorker() {
-    let best;
-    for (const slot of this.slots) {
-      if (slot.inFlight >= this.concurrency) continue;
-      if (!best || slot.inFlight < best.inFlight) best = slot;
-    }
-    return best;
-  }
-  drainQueue() {
-    let slot;
-    while (this.queue.length > 0 && (slot = this.pickWorker())) {
-      const entry = this.queue.shift();
-      if (entry.done) continue;
-      this.send(slot, entry);
-    }
-  }
-  send(slot, entry) {
-    const messageId = this.nextMessageId++;
-    entry.messageId = messageId;
-    entry.slot = slot;
-    entry.sentAt = performance.now();
-    const waitMs = entry.sentAt - entry.enqueuedAt;
-    this.statsAgg.waitMs.add(waitMs);
-    slot.inFlight++;
-    this.pending.set(messageId, entry);
-    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) {
-    if (entry.timer) clearTimeout(entry.timer);
-    if (entry.signal && entry.onSignalAbort) {
-      entry.signal.removeEventListener("abort", entry.onSignalAbort);
-    }
-  }
-  /**
-   * Abort/timeout path: a queued task is removed outright; an in-flight task
-   * stays in `pending` as an orphan — the worker is still running it, so the
-   * slot remains occupied until the reply arrives (handleReply frees it).
-   */
-  cancel(entry, err) {
-    if (entry.done) return;
-    const qi = this.queue.indexOf(entry);
-    if (qi >= 0) this.queue.splice(qi, 1);
-    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();
-  }
-  checkDrained() {
-    if (this.queue.length === 0 && this.pending.size === 0) {
-      const waiters = this.drainWaiters.splice(0);
-      for (const w of waiters) w();
-    }
-  }
-  /**
-   * Full dispatch: least-busy scheduling, `concurrency` cap per worker,
-   * FIFO queue bounded by `maxQueue`, abort/timeout, and queue→reply timing.
-   */
-  dispatch(contract, args, options) {
-    if (this.closed || this.slots.length === 0) {
-      return Promise.reject(new WorkerCrashedError("WorkerPool has been terminated \u2014 no workers available."));
-    }
-    if (options?.signal?.aborted) {
-      return Promise.reject(new TaskAbortedError());
-    }
-    return new Promise((resolve, reject) => {
-      const entry = {
-        contract,
-        args,
-        callId: ++this.nextCallId,
-        enqueuedAt: performance.now(),
-        resolve,
-        reject,
-        done: false,
-        signal: options?.signal
-      };
-      if (options?.signal) {
-        entry.onSignalAbort = () => this.cancel(entry, new TaskAbortedError());
-        options.signal.addEventListener("abort", entry.onSignalAbort, { once: true });
-      }
-      const timeout = options?.timeout ?? this.taskTimeout;
-      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 {
-        this.queue.push(entry);
-      }
-    });
-  }
-  /**
-   * Dispatches a task to the least-busy worker in the pool.
-   * The task contract guarantees the argument and result types across the thread boundary.
-   */
-  runTask(contract, ...args) {
-    return this.dispatch(contract, args);
-  }
-  /**
-   * The shared buffer handed to workers via INIT_MEMORY — undefined on
-   * message-only pools. Useful for passing the same buffer to auxiliaries
-   * (e.g. a second pool of HTTP workers via withSharedBuffer).
-   */
-  get sharedBuffer() {
-    return this.memoryManager?.getBuffer() ?? this.injectedBuffer;
-  }
-  /**
-   * Live snapshot of the pool's worker slots — for auxiliary messaging that
-   * isn't task dispatch (e.g. routing accepted sockets into workers). The
-   * array is a copy; respawned workers appear on the next read. Do NOT use
-   * this to dispatch tasks — runTask/dispatch own the scheduling protocol.
-   */
-  get workers() {
-    return this.slots.map((s) => s.worker);
-  }
-  /** Running aggregates — no histograms, just counts and means. */
-  stats() {
-    return {
-      workers: this.slots.length,
-      idle: this.slots.filter((s) => s.inFlight === 0).length,
-      inFlight: this.pending.size,
-      queued: this.queue.length,
-      completed: this.statsAgg.completed,
-      failed: this.statsAgg.failed,
-      aborted: this.statsAgg.aborted,
-      waitMs: { count: this.statsAgg.waitMs.count, mean: this.statsAgg.waitMs.mean, max: this.statsAgg.waitMs.max },
-      runMs: { count: this.statsAgg.runMs.count, mean: this.statsAgg.runMs.mean, max: this.statsAgg.runMs.max }
-    };
-  }
-  /** Resolves once the queue is empty and nothing is in flight, then terminates. */
-  close() {
-    if (this.queue.length === 0 && this.pending.size === 0) {
-      this.terminate();
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      this.drainWaiters.push(() => {
-        this.terminate();
-        resolve();
-      });
-    });
-  }
-  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();
-    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: "pool terminated" });
-      entry.reject(crashed);
-    }
-    for (const slot of this.slots) {
-      slot.worker.terminate();
-    }
-    this.slots = [];
-    this.checkDrained();
-  }
-};
-var WorkerPool = WorkerPoolImpl;
-
-export {
-  scoped,
-  bindSharedMemories,
-  WorkerPool
-};