@atolljs/core 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,18 +1,20 @@
 import { msgpackrCodec as e } from "./index2.js";
-import { listSchema as t } from "./index4.js";
-import { getLogLevel as n, log as r, scoped as i, setLogLevel as a, setLogSink as o } from "./index5.js";
-import { bindSharedMemories as s, defineSharedMemory as c, field as l, getDefinedSharedMemoryCount as u, jsonCodec as d, registerConnectorFactory as f } from "./index6.js";
-import { reef as p } from "./index7.js";
-import { MemoryManager as m } from "./index8.js";
-import { PoolQueueFullError as h, TaskAbortedError as g, TaskTimeoutError as _, WorkerCrashedError as v } from "./index9.js";
-import { WorkerPool as y } from "./index10.js";
-import { connectWorker as b, workerClient as x } from "./index11.js";
-import { connectSharedWorker as S } from "./index12.js";
-import { TaskRegistry as C } from "./index13.js";
-import { sharedWorkerHost as w } from "./index14.js";
-import { createClient as T, defineService as E, implementService as D, rpc as O, serviceMethod as k } from "./index15.js";
-import { RESERVED_CLIENT_KEYS as A, defineWorker as j } from "./index17.js";
-import { reactive as M, shallowEqual as N, watch as P } from "./index18.js";
-import { observe as F } from "./index19.js";
-import { defineTask as I, isAsyncTask as L, toTask as R } from "./index20.js";
-export { m as MemoryManager, h as PoolQueueFullError, A as RESERVED_CLIENT_KEYS, g as TaskAbortedError, C as TaskRegistry, _ as TaskTimeoutError, v as WorkerCrashedError, y as WorkerPool, s as bindSharedMemories, S as connectSharedWorker, b as connectWorker, T as createClient, E as defineService, c as defineSharedMemory, I as defineTask, j as defineWorker, l as field, u as getDefinedSharedMemoryCount, n as getLogLevel, D as implementService, L as isAsyncTask, d as jsonCodec, t as listSchema, r as log, e as msgpackrCodec, F as observe, M as reactive, p as reef, f as registerConnectorFactory, O as rpc, i as scoped, k as serviceMethod, a as setLogLevel, o as setLogSink, N as shallowEqual, w as sharedWorkerHost, R as toTask, P as watch, x as workerClient };
+import { SchemaError as t, z as n } from "./index3.js";
+import { listSchema as r } from "./index4.js";
+import { devtoolsEnabled as i, emitDevtools as a, installFetchProbe as o, installMemoryProbe as s, setDevtoolsSink as c } from "./index5.js";
+import { getLogLevel as l, log as u, scoped as d, setLogLevel as f, setLogSink as p } from "./index6.js";
+import { bindSharedMemories as m, defineSharedMemory as h, field as g, getDefinedSharedMemoryCount as _, jsonCodec as v, registerConnectorFactory as y } from "./index7.js";
+import { reef as b } from "./index8.js";
+import { MemoryManager as x } from "./index9.js";
+import { PoolQueueFullError as S, TaskAbortedError as C, TaskTimeoutError as w, WorkerCrashedError as T } from "./index10.js";
+import { WorkerPool as E } from "./index11.js";
+import { connectWorker as D, workerClient as O } from "./index12.js";
+import { connectSharedWorker as k } from "./index13.js";
+import { TaskRegistry as A } from "./index14.js";
+import { sharedWorkerHost as j } from "./index15.js";
+import { createClient as M, defineService as N, implementService as P, rpc as F, serviceMethod as I } from "./index16.js";
+import { RESERVED_CLIENT_KEYS as L, defineWorker as R } from "./index18.js";
+import { reactive as z, shallowEqual as B, watch as V } from "./index19.js";
+import { observe as H } from "./index20.js";
+import { defineTask as U, isAsyncTask as W, toTask as G } from "./index21.js";
+export { x as MemoryManager, S as PoolQueueFullError, L as RESERVED_CLIENT_KEYS, t as SchemaError, C as TaskAbortedError, A as TaskRegistry, w as TaskTimeoutError, T as WorkerCrashedError, E as WorkerPool, m as bindSharedMemories, k as connectSharedWorker, D as connectWorker, M as createClient, N as defineService, h as defineSharedMemory, U as defineTask, R as defineWorker, i as devtoolsEnabled, a as emitDevtools, g as field, _ as getDefinedSharedMemoryCount, l as getLogLevel, P as implementService, o as installFetchProbe, s as installMemoryProbe, W as isAsyncTask, v as jsonCodec, r as listSchema, u as log, e as msgpackrCodec, H as observe, z as reactive, b as reef, y as registerConnectorFactory, F as rpc, d as scoped, I as serviceMethod, c as setDevtoolsSink, f as setLogLevel, p as setLogSink, B as shallowEqual, j as sharedWorkerHost, G as toTask, V as watch, O as workerClient, n as z };

package/dist/index10.js

@@ -1,191 +1,20 @@
-import { fmtBytes as e, scoped as t } from "./index5.js";
-import { MemoryManager as n } from "./index8.js";
-import { PoolQueueFullError as r, TaskAbortedError as i, TaskTimeoutError as a, WorkerCrashedError as o } from "./index9.js";
-//#region src/pool/workerPool.ts
-var s = t("pool"), c = t("task"), l = () => ({
-	count: 0,
-	mean: 0,
-	max: 0,
-	add(e) {
-		this.count++, this.mean += (e - this.mean) / this.count, e > this.max && (this.max = e);
+//#region src/pool/errors.ts
+var e = class extends Error {
+	constructor(e = "WorkerPool task queue is full") {
+		super(e), this.name = "PoolQueueFullError";
 	}
-}), u = class {
-	slots = [];
-	pending = /* @__PURE__ */ new Map();
-	nextMessageId = 0;
-	queue = [];
-	memoryManager;
-	workerUrl;
-	spawn;
-	concurrency;
-	maxQueue;
-	respawn;
-	taskTimeout;
-	closed = !1;
-	drainWaiters = [];
-	statsAgg = {
-		completed: 0,
-		failed: 0,
-		aborted: 0,
-		waitMs: l(),
-		runMs: l()
-	};
-	sharedMemory;
-	persistence;
-	constructor(t) {
-		if (t.sharedMemory && (typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated)) throw Error("WorkerPool requires SharedArrayBuffer in a cross-origin isolated context — serve the page with COOP/COEP headers.");
-		if (!t.workerUrl && !t.createWorker) throw Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
-		this.workerUrl = t.workerUrl, this.spawn = t.createWorker ?? (() => new Worker(this.workerUrl, { type: "module" })), this.concurrency = t.concurrency ?? 1, this.maxQueue = t.maxQueue ?? Infinity, this.respawn = t.respawn ?? !0, this.taskTimeout = t.taskTimeout, t.sharedMemory && (this.sharedMemory = t.sharedMemory, this.memoryManager = new n(t.memory), this.memoryManager.ensureCapacity(this.sharedMemory.totalBytes), this.sharedMemory.bind(this.memoryManager.getBuffer()), this.persistence = t.persistence?.(t.sharedMemory));
-		let r = t.poolSize ?? "auto", i = r === "auto" ? navigator.hardwareConcurrency ?? 4 : r;
-		s.info(this.sharedMemory ? `spawning ${i} worker(s) with ${e(this.sharedMemory.totalBytes)} shared buffer` : `spawning ${i} worker(s), message-only`, { workerUrl: t.workerUrl ? String(t.workerUrl) : "createWorker()" }), s.debug("tip: setLogLevel('trace') for per-task detail");
-		for (let e = 0; e < i; e++) this.addWorker(this.spawn());
-		let a = t.tasks ?? {};
-		for (let [e, t] of Object.entries(a)) {
-			if (e in this) {
-				s.warn(`task "${e}" collides with a WorkerPool member — not installed`);
-				continue;
-			}
-			this[e] = (...e) => this.runTask(t, ...e);
-		}
-		Object.keys(a).length > 0 && s.info(`task methods: ${Object.keys(a).join(", ")}`);
+}, t = class extends Error {
+	constructor(e = "task aborted") {
+		super(e), this.name = "AbortError";
 	}
-	addWorker(e) {
-		let t = {
-			worker: e,
-			inFlight: 0
-		};
-		return e.addEventListener("message", (e) => {
-			this.handleReply(t, e.data);
-		}), e.addEventListener("error", (e) => {
-			this.handleWorkerError(t, e);
-		}), this.memoryManager ? e.postMessage({
-			type: "INIT_MEMORY",
-			memory: this.memoryManager.memory
-		}) : e.postMessage({ type: "INIT" }), this.slots.push(t), s.debug(`worker spawned, ${this.memoryManager ? "INIT_MEMORY" : "INIT"} sent`), t;
+}, n = class extends Error {
+	constructor(e = "task timed out") {
+		super(e), this.name = "TaskTimeoutError";
 	}
-	handleReply(e, t) {
-		let n = t.messageId === void 0 ? void 0 : this.pending.get(t.messageId);
-		n && (this.pending.delete(t.messageId), e.inFlight--, this.detach(n), n.done || (n.done = !0, this.statsAgg.runMs.add(performance.now() - (n.sentAt ?? n.enqueuedAt)), t.success ? (this.statsAgg.completed++, c.debug(`← ${n.contract.taskId} ok`), n.resolve(t.result)) : (this.statsAgg.failed++, c.warn(`← ${n.contract.taskId} failed: ${t.error}`), n.reject(Error(t.error)))), this.drainQueue(), this.checkDrained());
-	}
-	handleWorkerError(e, t) {
-		if (this.closed) return;
-		let n = t, r = n?.message ?? (n?.error ? String(n.error) : "worker error");
-		s.warn(`worker error: ${r}`);
-		for (let [t, n] of [...this.pending]) if (n.slot === e) {
-			if (this.pending.delete(t), this.detach(n), n.done) continue;
-			n.done = !0, this.statsAgg.failed++, n.reject(new o(r));
-		}
-		let i = this.slots.indexOf(e);
-		if (i >= 0 && this.slots.splice(i, 1), e.worker.terminate(), this.respawn) s.info("respawning crashed worker"), this.addWorker(this.spawn());
-		else if (this.slots.length === 0) for (let e of this.queue.splice(0)) e.done = !0, this.detach(e), this.statsAgg.failed++, e.reject(new o(r));
-		this.drainQueue(), this.checkDrained();
-	}
-	pickWorker() {
-		let e;
-		for (let t of this.slots) t.inFlight >= this.concurrency || (!e || t.inFlight < e.inFlight) && (e = t);
-		return e;
-	}
-	drainQueue() {
-		let e;
-		for (; this.queue.length > 0 && (e = this.pickWorker());) {
-			let t = this.queue.shift();
-			t.done || this.send(e, t);
-		}
-	}
-	send(e, t) {
-		let n = this.nextMessageId++;
-		t.messageId = n, t.slot = e, t.sentAt = performance.now(), this.statsAgg.waitMs.add(performance.now() - t.enqueuedAt), e.inFlight++, this.pending.set(n, t), c.debug(`→ ${t.contract.taskId}`, {
-			worker: this.slots.indexOf(e),
-			args: t.args
-		}), e.worker.postMessage({
-			type: "EXECUTE_TASK",
-			messageId: n,
-			taskId: t.contract.taskId,
-			args: t.args
-		});
-	}
-	detach(e) {
-		e.timer && clearTimeout(e.timer), e.signal && e.onSignalAbort && e.signal.removeEventListener("abort", e.onSignalAbort);
-	}
-	cancel(e, t) {
-		if (e.done) return;
-		let n = this.queue.indexOf(e);
-		n >= 0 && this.queue.splice(n, 1), e.done = !0, this.detach(e), this.statsAgg.aborted++, e.reject(t), this.drainQueue(), this.checkDrained();
-	}
-	checkDrained() {
-		if (this.queue.length === 0 && this.pending.size === 0) {
-			let e = this.drainWaiters.splice(0);
-			for (let t of e) t();
-		}
-	}
-	dispatch(e, t, n) {
-		return this.closed || this.slots.length === 0 ? Promise.reject(new o("WorkerPool has been terminated — no workers available.")) : n?.signal?.aborted ? Promise.reject(new i()) : new Promise((o, s) => {
-			let c = {
-				contract: e,
-				args: t,
-				enqueuedAt: performance.now(),
-				resolve: o,
-				reject: s,
-				done: !1,
-				signal: n?.signal
-			};
-			n?.signal && (c.onSignalAbort = () => this.cancel(c, new i()), n.signal.addEventListener("abort", c.onSignalAbort, { once: !0 }));
-			let l = n?.timeout ?? this.taskTimeout;
-			l !== void 0 && (c.timer = setTimeout(() => this.cancel(c, new a()), l));
-			let u = this.pickWorker();
-			if (u) this.send(u, c);
-			else if (this.queue.length >= this.maxQueue) {
-				c.done = !0, this.detach(c), s(new r());
-				return;
-			} else this.queue.push(c);
-		});
-	}
-	runTask(e, ...t) {
-		return this.dispatch(e, t);
-	}
-	get sharedBuffer() {
-		return this.memoryManager?.getBuffer();
-	}
-	get workers() {
-		return this.slots.map((e) => e.worker);
-	}
-	stats() {
-		return {
-			workers: this.slots.length,
-			idle: this.slots.filter((e) => e.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
-			}
-		};
-	}
-	close() {
-		return this.queue.length === 0 && this.pending.size === 0 ? (this.terminate(), Promise.resolve()) : new Promise((e) => {
-			this.drainWaiters.push(() => {
-				this.terminate(), e();
-			});
-		});
-	}
-	terminate() {
-		this.closed = !0, this.persistence?.stop()?.catch?.((e) => s.warn("memory persistence stop failed", e)), s.info(`terminating ${this.slots.length} worker(s)`);
-		let e = new o("pool terminated");
-		for (let [, t] of this.pending) this.detach(t), !t.done && (t.done = !0, this.statsAgg.failed++, t.reject(e));
-		this.pending.clear();
-		for (let t of this.queue.splice(0)) t.done = !0, this.detach(t), this.statsAgg.failed++, t.reject(e);
-		for (let e of this.slots) e.worker.terminate();
-		this.slots = [], this.checkDrained();
+}, r = class extends Error {
+	constructor(e = "worker crashed") {
+		super(e), this.name = "WorkerCrashedError";
 	}
 };
 //#endregion
-export { u as WorkerPool };
+export { e as PoolQueueFullError, t as TaskAbortedError, n as TaskTimeoutError, r as WorkerCrashedError };

package/dist/index11.js

@@ -1,50 +1,313 @@
-import { WorkerPool as e } from "./index10.js";
-//#region src/pool/workerClient.ts
-var t = (e, n, r, i) => {
-	let a = /* @__PURE__ */ new Map();
-	return new Proxy(() => {}, {
-		get(o, s) {
-			if (s === "then" || typeof s == "symbol") return;
-			if (s === "with") return (i) => t(e, n, r, i);
-			if (e.length === 0 && r && s in r) return Reflect.get(r, s);
-			let c = a.get(s);
-			return c || (c = t([...e, s], n, r, i), a.set(s, c)), c;
-		},
-		apply(t, r, a) {
-			let o = n(), s = { taskId: e.join(".") };
-			return o.dispatch ? o.dispatch(s, a, i) : o.runTask(s, ...a);
+import { devtoolsEnabled as e, emitDevtools as t, forwardDevtools as n, nextDevtoolsId as r } from "./index5.js";
+import { fmtBytes as i, scoped as a } from "./index6.js";
+import { MemoryManager as o } from "./index9.js";
+import { PoolQueueFullError as s, TaskAbortedError as c, TaskTimeoutError as l, WorkerCrashedError as u } from "./index10.js";
+//#region src/pool/workerPool.ts
+var d = a("pool"), f = a("task"), p = () => ({
+	count: 0,
+	mean: 0,
+	max: 0,
+	add(e) {
+		this.count++, this.mean += (e - this.mean) / this.count, e > this.max && (this.max = e);
+	}
+}), m = class {
+	slots = [];
+	pending = /* @__PURE__ */ new Map();
+	nextMessageId = 0;
+	queue = [];
+	memoryManager;
+	workerUrl;
+	spawn;
+	concurrency;
+	maxQueue;
+	respawn;
+	taskTimeout;
+	closed = !1;
+	drainWaiters = [];
+	statsAgg = {
+		completed: 0,
+		failed: 0,
+		aborted: 0,
+		waitMs: p(),
+		runMs: p()
+	};
+	poolId = r("pool");
+	label;
+	nextCallId = 0;
+	sharedMemory;
+	persistence;
+	constructor(e) {
+		if (e.sharedMemory && (typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated)) throw Error("WorkerPool requires SharedArrayBuffer in a cross-origin isolated context — serve the page with COOP/COEP headers.");
+		if (!e.workerUrl && !e.createWorker) throw Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
+		this.workerUrl = e.workerUrl, this.spawn = e.createWorker ?? (() => new Worker(this.workerUrl, { type: "module" })), this.concurrency = e.concurrency ?? 1, this.maxQueue = e.maxQueue ?? Infinity, this.respawn = e.respawn ?? !0, this.taskTimeout = e.taskTimeout, this.label = e.name, e.sharedMemory && (this.sharedMemory = e.sharedMemory, this.memoryManager = new o(e.memory), this.memoryManager.ensureCapacity(this.sharedMemory.totalBytes), this.sharedMemory.bind(this.memoryManager.getBuffer()), this.persistence = e.persistence?.(e.sharedMemory));
+		let n = e.poolSize ?? "auto", r = n === "auto" ? navigator.hardwareConcurrency ?? 4 : n;
+		d.info(this.sharedMemory ? `spawning ${r} worker(s) with ${i(this.sharedMemory.totalBytes)} shared buffer` : `spawning ${r} worker(s), message-only`, { workerUrl: e.workerUrl ? String(e.workerUrl) : "createWorker()" }), d.debug("tip: setLogLevel('trace') for per-task detail"), t({
+			type: "pool:init",
+			poolId: this.poolId,
+			label: this.label,
+			poolSize: r,
+			concurrency: this.concurrency,
+			memoryBytes: this.sharedMemory?.totalBytes
+		});
+		for (let e = 0; e < r; e++) this.addWorker(this.spawn());
+		let a = e.tasks ?? {};
+		for (let [e, t] of Object.entries(a)) {
+			if (e in this) {
+				d.warn(`task "${e}" collides with a WorkerPool member — not installed`);
+				continue;
+			}
+			this[e] = (...e) => this.runTask(t, ...e);
 		}
-	});
-};
-function n(e) {
-	let n;
-	return t([], typeof e == "function" ? () => n ??= e() : () => e);
-}
-function r(n) {
-	let r = null, i = () => r ??= new e({
-		sharedMemory: n.sharedMemory,
-		createWorker: typeof n.worker == "function" ? n.worker : () => new Worker(n.worker, { type: "module" }),
-		poolSize: n.poolSize,
-		memory: n.memory,
-		concurrency: n.concurrency,
-		maxQueue: n.maxQueue,
-		respawn: n.respawn,
-		taskTimeout: n.taskTimeout
-	});
-	return n.lazy === !1 && i(), t([], i, {
-		start: () => {
-			i();
-		},
-		terminate: () => {
-			r?.terminate(), r = null;
-		},
-		get pool() {
-			return r;
-		},
-		get sharedMemory() {
-			return n.sharedMemory;
+		Object.keys(a).length > 0 && d.info(`task methods: ${Object.keys(a).join(", ")}`);
+	}
+	addWorker(r) {
+		let i = {
+			worker: r,
+			inFlight: 0
+		};
+		return r.addEventListener("message", (e) => {
+			let t = e.data;
+			if (t.type === "ATOLL_DEVTOOLS" && t.event) {
+				n({
+					...t.event,
+					worker: {
+						poolId: this.poolId,
+						slot: this.slots.indexOf(i)
+					}
+				});
+				return;
+			}
+			this.handleReply(i, t);
+		}), r.addEventListener("error", (e) => {
+			this.handleWorkerError(i, e);
+		}), this.memoryManager ? r.postMessage({
+			type: "INIT_MEMORY",
+			memory: this.memoryManager.memory,
+			devtools: e()
+		}) : r.postMessage({
+			type: "INIT",
+			devtools: e()
+		}), this.slots.push(i), d.debug(`worker spawned, ${this.memoryManager ? "INIT_MEMORY" : "INIT"} sent`), t({
+			type: "worker:spawn",
+			poolId: this.poolId,
+			slot: this.slots.indexOf(i)
+		}), i;
+	}
+	handleReply(e, n) {
+		let r = n.messageId === void 0 ? void 0 : this.pending.get(n.messageId);
+		if (r) {
+			if (this.pending.delete(n.messageId), e.inFlight--, this.detach(r), !r.done) {
+				r.done = !0;
+				let e = performance.now() - (r.sentAt ?? r.enqueuedAt);
+				this.statsAgg.runMs.add(e), n.success ? (this.statsAgg.completed++, f.debug(`← ${r.contract.taskId} ok`), t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: r.callId,
+					taskId: r.contract.taskId,
+					outcome: "ok",
+					runMs: e
+				}), r.resolve(n.result)) : (this.statsAgg.failed++, f.warn(`← ${r.contract.taskId} failed: ${n.error}`), t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: r.callId,
+					taskId: r.contract.taskId,
+					outcome: "error",
+					runMs: e,
+					error: n.error
+				}), r.reject(Error(n.error)));
+			}
+			this.drainQueue(), this.checkDrained();
+		}
+	}
+	handleWorkerError(e, n) {
+		if (this.closed) return;
+		let r = n, i = r?.message ?? (r?.error ? String(r.error) : "worker error");
+		d.warn(`worker error: ${i}`);
+		let a = this.slots.indexOf(e);
+		t({
+			type: "worker:error",
+			poolId: this.poolId,
+			slot: a,
+			message: i
+		});
+		for (let [n, r] of [...this.pending]) if (r.slot === e) {
+			if (this.pending.delete(n), this.detach(r), r.done) continue;
+			r.done = !0, this.statsAgg.failed++, t({
+				type: "task:settle",
+				poolId: this.poolId,
+				callId: r.callId,
+				taskId: r.contract.taskId,
+				outcome: "crashed",
+				error: i
+			}), r.reject(new u(i));
+		}
+		if (a >= 0 && this.slots.splice(a, 1), e.worker.terminate(), this.respawn) d.info("respawning crashed worker"), this.addWorker(this.spawn()), t({
+			type: "worker:respawn",
+			poolId: this.poolId,
+			slot: this.slots.length - 1
+		});
+		else if (this.slots.length === 0) for (let e of this.queue.splice(0)) e.done = !0, this.detach(e), this.statsAgg.failed++, t({
+			type: "task:settle",
+			poolId: this.poolId,
+			callId: e.callId,
+			taskId: e.contract.taskId,
+			outcome: "crashed",
+			error: i
+		}), e.reject(new u(i));
+		this.drainQueue(), this.checkDrained();
+	}
+	pickWorker() {
+		let e;
+		for (let t of this.slots) t.inFlight >= this.concurrency || (!e || t.inFlight < e.inFlight) && (e = t);
+		return e;
+	}
+	drainQueue() {
+		let e;
+		for (; this.queue.length > 0 && (e = this.pickWorker());) {
+			let t = this.queue.shift();
+			t.done || this.send(e, t);
 		}
-	});
-}
+	}
+	send(e, n) {
+		let r = this.nextMessageId++;
+		n.messageId = r, n.slot = e, n.sentAt = performance.now();
+		let i = n.sentAt - n.enqueuedAt;
+		this.statsAgg.waitMs.add(i), e.inFlight++, this.pending.set(r, n);
+		let a = this.slots.indexOf(e);
+		f.debug(`→ ${n.contract.taskId}`, {
+			worker: a,
+			args: n.args
+		}), t({
+			type: "task:dispatch",
+			poolId: this.poolId,
+			callId: n.callId,
+			taskId: n.contract.taskId,
+			slot: a,
+			waitMs: i
+		}), e.worker.postMessage({
+			type: "EXECUTE_TASK",
+			messageId: r,
+			taskId: n.contract.taskId,
+			args: n.args
+		});
+	}
+	detach(e) {
+		e.timer && clearTimeout(e.timer), e.signal && e.onSignalAbort && e.signal.removeEventListener("abort", e.onSignalAbort);
+	}
+	cancel(e, n) {
+		if (e.done) return;
+		let r = this.queue.indexOf(e);
+		r >= 0 && this.queue.splice(r, 1), e.done = !0, this.detach(e), this.statsAgg.aborted++, t({
+			type: "task:settle",
+			poolId: this.poolId,
+			callId: e.callId,
+			taskId: e.contract.taskId,
+			outcome: n instanceof l ? "timeout" : "aborted"
+		}), e.reject(n), this.drainQueue(), this.checkDrained();
+	}
+	checkDrained() {
+		if (this.queue.length === 0 && this.pending.size === 0) {
+			let e = this.drainWaiters.splice(0);
+			for (let t of e) t();
+		}
+	}
+	dispatch(e, n, r) {
+		return this.closed || this.slots.length === 0 ? Promise.reject(new u("WorkerPool has been terminated — no workers available.")) : r?.signal?.aborted ? Promise.reject(new c()) : new Promise((i, a) => {
+			let o = {
+				contract: e,
+				args: n,
+				callId: ++this.nextCallId,
+				enqueuedAt: performance.now(),
+				resolve: i,
+				reject: a,
+				done: !1,
+				signal: r?.signal
+			};
+			r?.signal && (o.onSignalAbort = () => this.cancel(o, new c()), r.signal.addEventListener("abort", o.onSignalAbort, { once: !0 }));
+			let u = r?.timeout ?? this.taskTimeout;
+			u !== void 0 && (o.timer = setTimeout(() => this.cancel(o, new l()), u)), t({
+				type: "task:enqueue",
+				poolId: this.poolId,
+				callId: o.callId,
+				taskId: e.taskId
+			});
+			let d = this.pickWorker();
+			if (d) this.send(d, o);
+			else if (this.queue.length >= this.maxQueue) {
+				o.done = !0, this.detach(o), t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: o.callId,
+					taskId: e.taskId,
+					outcome: "queue-full"
+				}), a(new s());
+				return;
+			} else this.queue.push(o);
+		});
+	}
+	runTask(e, ...t) {
+		return this.dispatch(e, t);
+	}
+	get sharedBuffer() {
+		return this.memoryManager?.getBuffer();
+	}
+	get workers() {
+		return this.slots.map((e) => e.worker);
+	}
+	stats() {
+		return {
+			workers: this.slots.length,
+			idle: this.slots.filter((e) => e.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
+			}
+		};
+	}
+	close() {
+		return this.queue.length === 0 && this.pending.size === 0 ? (this.terminate(), Promise.resolve()) : new Promise((e) => {
+			this.drainWaiters.push(() => {
+				this.terminate(), e();
+			});
+		});
+	}
+	terminate() {
+		this.closed = !0, this.persistence?.stop()?.catch?.((e) => d.warn("memory persistence stop failed", e)), d.info(`terminating ${this.slots.length} worker(s)`), t({
+			type: "pool:terminate",
+			poolId: this.poolId
+		});
+		let e = new u("pool terminated");
+		for (let [, n] of this.pending) this.detach(n), !n.done && (n.done = !0, this.statsAgg.failed++, t({
+			type: "task:settle",
+			poolId: this.poolId,
+			callId: n.callId,
+			taskId: n.contract.taskId,
+			outcome: "crashed",
+			error: "pool terminated"
+		}), n.reject(e));
+		this.pending.clear();
+		for (let n of this.queue.splice(0)) n.done = !0, this.detach(n), this.statsAgg.failed++, t({
+			type: "task:settle",
+			poolId: this.poolId,
+			callId: n.callId,
+			taskId: n.contract.taskId,
+			outcome: "crashed",
+			error: "pool terminated"
+		}), n.reject(e);
+		for (let e of this.slots) e.worker.terminate();
+		this.slots = [], this.checkDrained();
+	}
+};
 //#endregion
-export { r as connectWorker, n as workerClient };
+export { m as WorkerPool };