@atolljs/core 0.1.7 → 0.1.9

package/dist/index15.js

@@ -1,61 +1,338 @@
-import { fmtBytes as e, scoped as t } from "./index6.js";
-import { bindSharedMemories as n } from "./index7.js";
-import { MemoryManager as r } from "./index9.js";
-import { TaskRegistry as i } from "./index14.js";
-//#region src/shared/sharedWorkerHost.ts
-var a = t("shared-worker"), o = null, s = 0;
-function c(t, i) {
-	if (o) return o.buffer.byteLength < t && a.warn(`client requested ${e(t)} but buffer is ${e(o.buffer.byteLength)} — first client's capacity wins`), o;
-	let s = new r(i);
-	return s.ensureCapacity(t), o = s.memory, n(s.getBuffer()), a.info(`shared buffer allocated (${e(o.buffer.byteLength)})`), o;
-}
-function l(e) {
-	let t = ++s;
-	a.info(`client #${t} connected`), e.onmessage = async (n) => {
-		let r = n.data;
-		if (r?.type === "SHARED_CONNECT") {
-			let n = c(r.memoryBytes ?? 0, r.memory);
-			e.postMessage({
-				type: "SHARED_MEMORY",
-				buffer: n.buffer,
-				clientIndex: t
-			});
-			return;
+import { devtoolsEnabled as e, emitDevtools as t, estimateCloneBytes as n, nextDevtoolsId as r } from "./index5.js";
+import { fmtBytes as i, scoped as a } from "./index7.js";
+import { PoolQueueFullError as o, TaskAbortedError as s, TaskTimeoutError as c, WorkerCrashedError as l } from "./index11.js";
+import { measureTaskCall as u } from "./index12.js";
+import { forwardWorkerDevtools as d, sendInit as f, setupChannelMemory as p } from "./index13.js";
+import { CHAOS_FAILURE as m, KILL_MESSAGE as h, applyChaos as g, registerDevtoolsRunner as _ } from "./index14.js";
+//#region src/pool/workerPool.ts
+var v = a("pool"), y = a("task"), b = () => ({
+	count: 0,
+	mean: 0,
+	max: 0,
+	add(e) {
+		this.count++, this.mean += (e - this.mean) / this.count, e > this.max && (this.max = e);
+	}
+}), x = class {
+	slots = [];
+	pending = /* @__PURE__ */ new Map();
+	nextMessageId = 0;
+	queue = [];
+	mem;
+	memoryManager;
+	injectedBuffer;
+	workerUrl;
+	spawn;
+	concurrency;
+	maxQueue;
+	respawn;
+	taskTimeout;
+	closed = !1;
+	chaos = null;
+	devtoolsOff;
+	drainWaiters = [];
+	statsAgg = {
+		completed: 0,
+		failed: 0,
+		aborted: 0,
+		waitMs: b(),
+		runMs: b()
+	};
+	poolId;
+	label;
+	nextCallId = 0;
+	sharedMemory;
+	persistence;
+	constructor(n) {
+		let a = p(n, "WorkerPool");
+		if (!n.workerUrl && !n.createWorker) throw Error("WorkerPool requires either `workerUrl` or `createWorker` in its config.");
+		this.workerUrl = n.workerUrl, this.spawn = n.createWorker ?? (() => new Worker(this.workerUrl, { type: "module" })), this.concurrency = n.concurrency ?? 1, this.maxQueue = n.maxQueue ?? Infinity, this.respawn = n.respawn ?? !0, this.taskTimeout = n.taskTimeout, this.label = n.name, this.poolId = r("pool", n.name), this.mem = a, this.sharedMemory = a.sharedMemory, this.memoryManager = a.memoryManager, this.injectedBuffer = a.injectedBuffer, this.persistence = a.persistence;
+		let o = n.poolSize ?? "auto", s = o === "auto" ? typeof navigator < "u" ? navigator.hardwareConcurrency ?? 4 : 4 : o;
+		v.info(this.sharedMemory ? `spawning ${s} worker(s) with ${i(this.sharedMemory.totalBytes)} shared buffer` : this.injectedBuffer ? `spawning ${s} worker(s) with ${i(this.injectedBuffer.byteLength)} inherited buffer` : `spawning ${s} worker(s), message-only`, { workerUrl: n.workerUrl ? String(n.workerUrl) : "createWorker()" }), v.debug("tip: setLogLevel('trace') for per-task detail"), t({
+			type: "pool:init",
+			poolId: this.poolId,
+			label: this.label,
+			poolSize: s,
+			concurrency: this.concurrency,
+			memoryBytes: this.sharedMemory?.totalBytes ?? this.injectedBuffer?.byteLength
+		});
+		for (let e = 0; e < s; e++) this.addWorker(this.spawn());
+		e() && (this.devtoolsOff = _({
+			poolId: this.poolId,
+			label: this.label,
+			dedicated: !1,
+			size: () => this.slots.length,
+			stats: () => this.stats(),
+			kill: (e) => {
+				let t = this.slots[e];
+				if (!t) throw Error(`${this.poolId} has no worker slot ${e}`);
+				this.handleWorkerError(t, { message: h });
+			},
+			getChaos: () => this.chaos,
+			setChaos: (e) => {
+				this.chaos = e;
+			}
+		}));
+		let c = n.tasks ?? {};
+		for (let [e, t] of Object.entries(c)) {
+			if (e in this) {
+				v.warn(`task "${e}" collides with a WorkerPool member — not installed`);
+				continue;
+			}
+			this[e] = (...e) => this.runTask(t, ...e);
 		}
-		if (r?.type === "EXECUTE_TASK") {
-			let { messageId: n, taskId: s, args: c } = r;
-			if (!o) {
-				e.postMessage({
-					messageId: n,
-					success: !1,
-					error: "Shared memory not initialized in worker."
-				});
+		Object.keys(c).length > 0 && v.info(`task methods: ${Object.keys(c).join(", ")}`);
+	}
+	addWorker(e) {
+		let n = {
+			worker: e,
+			inFlight: 0
+		};
+		e.addEventListener("message", (e) => {
+			let t = e.data;
+			if (t.type === "ATOLL_DEVTOOLS" && t.event) {
+				d(this.poolId, this.slots.indexOf(n), t.event);
 				return;
 			}
-			let l = performance.now();
-			try {
-				let r = await i.execute(s, ...c || []);
-				a.debug(`task ${s} → ${(performance.now() - l).toFixed(1)}ms (client #${t})`), e.postMessage({
-					messageId: n,
-					success: !0,
-					result: r
-				});
-			} catch (t) {
-				a.warn(`task ${s} failed: ${t.message || String(t)}`), e.postMessage({
-					messageId: n,
-					success: !1,
-					error: t.message || String(t)
-				});
+			this.handleReply(n, t);
+		}), e.addEventListener("error", (e) => {
+			this.handleWorkerError(n, e);
+		});
+		let r = f(e, this.mem);
+		return this.slots.push(n), v.debug(`worker spawned, ${r} sent`), t({
+			type: "worker:spawn",
+			poolId: this.poolId,
+			slot: this.slots.indexOf(n)
+		}), n;
+	}
+	handleReply(r, i) {
+		let a = i.messageId === void 0 ? void 0 : this.pending.get(i.messageId);
+		if (a) {
+			if (this.pending.delete(i.messageId), r.inFlight--, this.detach(a), !a.done) {
+				a.done = !0;
+				let o = a.sentAt ?? a.enqueuedAt, s = performance.now() - o;
+				this.statsAgg.runMs.add(s), i.success ? (this.statsAgg.completed++, y.debug(`← ${a.contract.taskId} ok`), e() && (t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: a.callId,
+					taskId: a.contract.taskId,
+					outcome: "ok",
+					runMs: s,
+					resultBytes: n(i.result)
+				}), u(this.poolId, a.contract.taskId, a.callId, this.slots.indexOf(r), o, o + s, !0)), a.resolve(i.result)) : (this.statsAgg.failed++, y.warn(`← ${a.contract.taskId} failed: ${i.error}`), e() && (t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: a.callId,
+					taskId: a.contract.taskId,
+					outcome: "error",
+					runMs: s,
+					error: i.error
+				}), u(this.poolId, a.contract.taskId, a.callId, this.slots.indexOf(r), o, o + s, !1)), a.reject(Error(i.error)));
 			}
-			return;
+			this.drainQueue(), this.checkDrained();
 		}
-		r?.type === "SHARED_DISCONNECT" && (e.close(), a.info(`client #${t} disconnected`));
-	}, e.start();
-}
-function u() {
-	self.onconnect = (e) => {
-		l(e.ports[0]);
-	};
-}
+	}
+	handleWorkerError(e, n) {
+		if (this.closed) return;
+		let r = n, i = r?.message ?? (r?.error ? String(r.error) : "worker error");
+		v.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 l(i));
+		}
+		if (a >= 0 && this.slots.splice(a, 1), e.worker.terminate(), this.respawn) v.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 l(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(r, i) {
+		let a = this.nextMessageId++;
+		i.messageId = a, i.slot = r, i.sentAt = performance.now();
+		let o = i.sentAt - i.enqueuedAt;
+		this.statsAgg.waitMs.add(o), r.inFlight++, this.pending.set(a, i);
+		let s = this.slots.indexOf(r);
+		y.debug(`→ ${i.contract.taskId}`, {
+			worker: s,
+			args: i.args
+		}), e() && t({
+			type: "task:dispatch",
+			poolId: this.poolId,
+			callId: i.callId,
+			taskId: i.contract.taskId,
+			slot: s,
+			waitMs: o,
+			argBytes: n(i.args)
+		});
+		let l = {
+			type: "EXECUTE_TASK",
+			messageId: a,
+			taskId: i.contract.taskId,
+			args: i.args
+		};
+		this.chaos ? g(this.chaos, {
+			live: () => this.pending.get(a) === i,
+			fail: () => this.handleReply(r, {
+				messageId: a,
+				taskId: l.taskId,
+				success: !1,
+				error: m
+			}),
+			timeout: () => this.cancel(i, new c()),
+			post: () => r.worker.postMessage(l)
+		}) : r.worker.postMessage(l);
+	}
+	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 c ? "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 l("WorkerPool has been terminated — no workers available.")) : r?.signal?.aborted ? Promise.reject(new s()) : new Promise((i, a) => {
+			let l = {
+				contract: e,
+				args: n,
+				callId: ++this.nextCallId,
+				enqueuedAt: performance.now(),
+				resolve: i,
+				reject: a,
+				done: !1,
+				signal: r?.signal
+			};
+			r?.signal && (l.onSignalAbort = () => this.cancel(l, new s()), r.signal.addEventListener("abort", l.onSignalAbort, { once: !0 }));
+			let u = r?.timeout ?? this.taskTimeout;
+			u !== void 0 && (l.timer = setTimeout(() => this.cancel(l, new c()), u)), t({
+				type: "task:enqueue",
+				poolId: this.poolId,
+				callId: l.callId,
+				taskId: e.taskId
+			});
+			let d = this.pickWorker();
+			if (d) this.send(d, l);
+			else if (this.queue.length >= this.maxQueue) {
+				l.done = !0, this.detach(l), t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: l.callId,
+					taskId: e.taskId,
+					outcome: "queue-full"
+				}), a(new o());
+				return;
+			} else this.queue.push(l);
+		});
+	}
+	runTask(e, ...t) {
+		return this.dispatch(e, t);
+	}
+	get sharedBuffer() {
+		return this.memoryManager?.getBuffer() ?? this.injectedBuffer;
+	}
+	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.devtoolsOff?.(), this.persistence?.stop()?.catch?.((e) => v.warn("memory persistence stop failed", e)), v.info(`terminating ${this.slots.length} worker(s)`), t({
+			type: "pool:terminate",
+			poolId: this.poolId
+		});
+		let e = new l("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 { l as attachSharedPort, u as sharedWorkerHost };
+export { x as WorkerPool };

package/dist/index16.js

@@ -1,48 +1,249 @@
-import { scoped as e } from "./index6.js";
-import { TaskRegistry as t } from "./index14.js";
-//#region src/service.ts
-var n = e("service");
-function r(e = {}) {
-	return e;
-}
-function i(e) {
-	return e;
-}
-function a(e, t) {
-	let n = {};
-	for (let [r, i] of Object.entries(t)) {
-		let t = "def" in i ? i.def : i;
-		n[r] = {
-			taskId: t.taskId ?? `${e}.${r}`,
-			...t.dataType ? { dataType: t.dataType } : {},
-			...t.argsSchema ? { argsSchema: t.argsSchema } : {},
-			...t.resultSchema ? { resultSchema: t.resultSchema } : {}
-		};
+import { devtoolsEnabled as e, emitDevtools as t, estimateCloneBytes as n, nextDevtoolsId as r } from "./index5.js";
+import { fmtBytes as i, scoped as a } from "./index7.js";
+import { TaskAbortedError as o, TaskTimeoutError as s, WorkerCrashedError as c } from "./index11.js";
+import { measureTaskCall as l } from "./index12.js";
+import { forwardWorkerDevtools as u, sendInit as d, setupChannelMemory as f } from "./index13.js";
+import { CHAOS_FAILURE as p, KILL_MESSAGE as m, applyChaos as h, registerDevtoolsRunner as g } from "./index14.js";
+//#region src/pool/dedicatedWorker.ts
+var _ = a("worker"), v = a("task"), y = () => ({
+	count: 0,
+	mean: 0,
+	max: 0,
+	add(e) {
+		this.count++, this.mean += (e - this.mean) / this.count, e > this.max && (this.max = e);
 	}
-	return {
-		name: e,
-		tasks: n
-	};
-}
-function o(e, r) {
-	let i = Object.keys(e.tasks).filter((e) => {
-		let t = r[e];
-		return typeof t != "function" && typeof t?.run != "function";
-	});
-	if (i.length > 0) throw Error(`implementService("${e.name}"): missing handlers for ${i.join(", ")}`);
-	for (let [n, i] of Object.entries(e.tasks)) {
-		let e = r[n];
-		t.register(i, typeof e == "function" ? e.bind(r) : e.run.bind(e));
-	}
-	return n.info(`service "${e.name}" implemented — ${Object.keys(e.tasks).join(", ")}`), {
-		service: e,
-		handlers: r
+}), b = class {
+	poolId;
+	sharedMemory;
+	persistence;
+	mem;
+	spawn;
+	respawn;
+	taskTimeout;
+	label;
+	worker = null;
+	pending = /* @__PURE__ */ new Map();
+	nextMessageId = 0;
+	nextCallId = 0;
+	closed = !1;
+	chaos = null;
+	devtoolsOff;
+	drainWaiters = [];
+	statsAgg = {
+		completed: 0,
+		failed: 0,
+		aborted: 0,
+		runMs: y()
 	};
-}
-function s(e, t) {
-	let n = {};
-	for (let [r, i] of Object.entries(e.tasks)) n[r] = (...e) => t.runTask(i, ...e);
-	return n;
-}
+	constructor(n) {
+		if (this.mem = f(n, "DedicatedWorker"), !n.workerUrl && !n.createWorker) throw Error("DedicatedWorker requires either `workerUrl` or `createWorker` in its config.");
+		let a = n.workerUrl;
+		this.spawn = n.createWorker ?? (() => new Worker(a, { type: "module" })), this.respawn = n.respawn ?? !0, this.taskTimeout = n.taskTimeout, this.label = n.name, this.poolId = r("worker", n.name), this.sharedMemory = this.mem.sharedMemory, this.persistence = this.mem.persistence;
+		let o = this.mem.sharedMemory?.totalBytes ?? this.mem.injectedBuffer?.byteLength;
+		_.info(o === void 0 ? "spawning 1 dedicated worker, message-only" : `spawning 1 dedicated worker with ${i(o)} shared buffer`), t({
+			type: "pool:init",
+			poolId: this.poolId,
+			label: this.label,
+			poolSize: 1,
+			concurrency: 0,
+			memoryBytes: o,
+			dedicated: !0
+		}), this.attach(this.spawn()), e() && (this.devtoolsOff = g({
+			poolId: this.poolId,
+			label: this.label,
+			dedicated: !0,
+			size: () => +!!this.worker,
+			stats: () => this.stats(),
+			kill: (e) => {
+				if (e !== 0 || !this.worker) throw Error(`${this.poolId} has no live worker at slot ${e}`);
+				this.handleError({ message: m });
+			},
+			getChaos: () => this.chaos,
+			setChaos: (e) => {
+				this.chaos = e;
+			}
+		}));
+	}
+	attach(e) {
+		this.worker = e, e.addEventListener("message", (t) => {
+			if (this.worker !== e) return;
+			let n = t.data;
+			if (n.type === "ATOLL_DEVTOOLS" && n.event) {
+				u(this.poolId, 0, n.event);
+				return;
+			}
+			this.handleReply(n);
+		}), e.addEventListener("error", (t) => {
+			this.worker === e && this.handleError(t);
+		});
+		let n = d(e, this.mem);
+		_.debug(`dedicated worker spawned, ${n} sent`), t({
+			type: "worker:spawn",
+			poolId: this.poolId,
+			slot: 0
+		});
+	}
+	detach(e) {
+		e.timer && clearTimeout(e.timer), e.signal && e.onSignalAbort && e.signal.removeEventListener("abort", e.onSignalAbort);
+	}
+	handleReply(r) {
+		let i = r.messageId === void 0 ? void 0 : this.pending.get(r.messageId);
+		if (i) {
+			if (this.pending.delete(r.messageId), this.detach(i), !i.done) {
+				i.done = !0;
+				let a = performance.now() - i.sentAt;
+				this.statsAgg.runMs.add(a), r.success ? (this.statsAgg.completed++, v.debug(`← ${i.contract.taskId} ok`), e() && (t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: i.callId,
+					taskId: i.contract.taskId,
+					outcome: "ok",
+					runMs: a,
+					resultBytes: n(r.result)
+				}), l(this.poolId, i.contract.taskId, i.callId, 0, i.sentAt, i.sentAt + a, !0)), i.resolve(r.result)) : (this.statsAgg.failed++, v.warn(`← ${i.contract.taskId} failed: ${r.error}`), e() && (t({
+					type: "task:settle",
+					poolId: this.poolId,
+					callId: i.callId,
+					taskId: i.contract.taskId,
+					outcome: "error",
+					runMs: a,
+					error: r.error
+				}), l(this.poolId, i.contract.taskId, i.callId, 0, i.sentAt, i.sentAt + a, !1)), i.reject(Error(r.error)));
+			}
+			this.checkDrained();
+		}
+	}
+	handleError(e) {
+		if (this.closed) return;
+		let n = e, r = n?.message ?? (n?.error ? String(n.error) : "worker error");
+		_.warn(`worker error: ${r}`), t({
+			type: "worker:error",
+			poolId: this.poolId,
+			slot: 0,
+			message: r
+		}), this.rejectPending(r), this.worker?.terminate(), this.worker = null, this.respawn && (_.info("respawning crashed worker"), this.attach(this.spawn()), t({
+			type: "worker:respawn",
+			poolId: this.poolId,
+			slot: 0
+		})), this.checkDrained();
+	}
+	rejectPending(e) {
+		let n = new c(e);
+		for (let r of this.pending.values()) this.detach(r), !r.done && (r.done = !0, this.statsAgg.failed++, t({
+			type: "task:settle",
+			poolId: this.poolId,
+			callId: r.callId,
+			taskId: r.contract.taskId,
+			outcome: "crashed",
+			error: e
+		}), r.reject(n));
+		this.pending.clear();
+	}
+	cancel(e, n) {
+		e.done || (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 s ? "timeout" : "aborted"
+		}), e.reject(n));
+	}
+	checkDrained() {
+		if (!(this.pending.size > 0)) for (let e of this.drainWaiters.splice(0)) e();
+	}
+	dispatch(r, i, a) {
+		let l = this.worker;
+		return this.closed || l === null ? Promise.reject(new c("DedicatedWorker has been terminated — no worker available.")) : a?.signal?.aborted ? Promise.reject(new o()) : new Promise((c, u) => {
+			let d = {
+				contract: r,
+				callId: ++this.nextCallId,
+				sentAt: performance.now(),
+				resolve: c,
+				reject: u,
+				done: !1,
+				signal: a?.signal
+			};
+			a?.signal && (d.onSignalAbort = () => this.cancel(d, new o()), a.signal.addEventListener("abort", d.onSignalAbort, { once: !0 }));
+			let f = a?.timeout ?? this.taskTimeout;
+			f !== void 0 && (d.timer = setTimeout(() => this.cancel(d, new s()), f));
+			let m = this.nextMessageId++;
+			this.pending.set(m, d), v.debug(`→ ${r.taskId}`, { args: i }), t({
+				type: "task:enqueue",
+				poolId: this.poolId,
+				callId: d.callId,
+				taskId: r.taskId
+			}), e() && t({
+				type: "task:dispatch",
+				poolId: this.poolId,
+				callId: d.callId,
+				taskId: r.taskId,
+				slot: 0,
+				waitMs: 0,
+				argBytes: n(i)
+			});
+			let g = {
+				type: "EXECUTE_TASK",
+				messageId: m,
+				taskId: r.taskId,
+				args: i
+			};
+			this.chaos ? h(this.chaos, {
+				live: () => this.pending.get(m) === d,
+				fail: () => this.handleReply({
+					messageId: m,
+					taskId: r.taskId,
+					success: !1,
+					error: p
+				}),
+				timeout: () => this.cancel(d, new s()),
+				post: () => l.postMessage(g)
+			}) : l.postMessage(g);
+		});
+	}
+	runTask(e, ...t) {
+		return this.dispatch(e, t);
+	}
+	get sharedBuffer() {
+		return this.mem.memoryManager?.getBuffer() ?? this.mem.injectedBuffer;
+	}
+	get workers() {
+		return this.worker ? [this.worker] : [];
+	}
+	stats() {
+		let e = +!!this.worker, { runMs: t } = this.statsAgg;
+		return {
+			workers: e,
+			idle: e && this.pending.size === 0 ? 1 : 0,
+			inFlight: this.pending.size,
+			queued: 0,
+			completed: this.statsAgg.completed,
+			failed: this.statsAgg.failed,
+			aborted: this.statsAgg.aborted,
+			waitMs: {
+				count: 0,
+				mean: 0,
+				max: 0
+			},
+			runMs: {
+				count: t.count,
+				mean: t.mean,
+				max: t.max
+			}
+		};
+	}
+	close() {
+		return this.pending.size === 0 ? (this.terminate(), Promise.resolve()) : new Promise((e) => {
+			this.drainWaiters.push(() => {
+				this.terminate(), e();
+			});
+		});
+	}
+	terminate() {
+		this.closed || (this.closed = !0, this.devtoolsOff?.(), this.persistence?.stop()?.catch?.((e) => _.warn("memory persistence stop failed", e)), _.info("terminating dedicated worker"), t({
+			type: "pool:terminate",
+			poolId: this.poolId
+		}), this.rejectPending("worker terminated"), this.worker?.terminate(), this.worker = null, this.checkDrained());
+	}
+};
 //#endregion
-export { s as createClient, a as defineService, o as implementService, r as rpc, i as serviceMethod };
+export { b as DedicatedWorker };