@atolljs/core 0.1.6 → 0.1.8

package/dist/index10.js

@@ -1,191 +1,35 @@
-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);
-	}
-}), 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(", ")}`);
-	}
-	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;
-	}
-	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
+//#region src/pool/memory.ts
+var e = class {
+	memory;
+	maxPages;
+	constructor(e = {}) {
+		let t = e.initialPages ?? 16;
+		this.maxPages = e.maximumPages ?? 16384, this.memory = new WebAssembly.Memory({
+			initial: t,
+			maximum: this.maxPages,
+			shared: !0
 		});
 	}
-	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();
+	ensureCapacity(e) {
+		let t = this.memory.buffer.byteLength;
+		if (t >= e) return;
+		let n = e - t, r = Math.ceil(n / 65536);
+		if (this.memory.buffer.byteLength / 65536 + r > this.maxPages) throw Error(`Cannot grow memory: exceeds maximum page limit of ${this.maxPages}`);
+		this.memory.grow(r);
+	}
+	getView(e, t = 0, n) {
+		let r = this.memory.buffer;
+		switch (e) {
+			case "Int32": return new Int32Array(r, t, n);
+			case "Float64": return new Float64Array(r, t, n);
+			case "BigInt64": return new BigInt64Array(r, t, n);
+			case "Uint8": return new Uint8Array(r, t, n);
+			default: throw Error(`Unsupported view type: ${e}`);
 		}
 	}
-	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();
+	getBuffer() {
+		return this.memory.buffer;
 	}
 };
 //#endregion
-export { u as WorkerPool };
+export { e as MemoryManager };

package/dist/index11.js

@@ -1,50 +1,20 @@
-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);
-		}
-	});
+//#region src/pool/errors.ts
+var e = class extends Error {
+	constructor(e = "WorkerPool task queue is full") {
+		super(e), this.name = "PoolQueueFullError";
+	}
+}, t = class extends Error {
+	constructor(e = "task aborted") {
+		super(e), this.name = "AbortError";
+	}
+}, n = class extends Error {
+	constructor(e = "task timed out") {
+		super(e), this.name = "TaskTimeoutError";
+	}
+}, r = class extends Error {
+	constructor(e = "worker crashed") {
+		super(e), this.name = "WorkerCrashedError";
+	}
 };
-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;
-		}
-	});
-}
 //#endregion
-export { r as connectWorker, n as workerClient };
+export { e as PoolQueueFullError, t as TaskAbortedError, n as TaskTimeoutError, r as WorkerCrashedError };

package/dist/index12.js

@@ -1,64 +1,30 @@
-import { scoped as e } from "./index5.js";
-//#region src/shared/sharedWorkerClient.ts
-var t = e("shared-client"), n = e("task"), r = class {
-	clientIndex;
-	sharedMemory;
-	port;
-	constructor(e, n, r) {
-		this.clientIndex = n, this.port = e, this.sharedMemory = r.sharedMemory;
-		let i = r.tasks ?? {};
-		for (let [e, n] of Object.entries(i)) {
-			if (e in this) {
-				t.warn(`task "${e}" collides with a SharedWorkerClient member — not installed`);
-				continue;
-			}
-			this[e] = (...e) => this.runTask(n, ...e);
-		}
-		Object.keys(i).length > 0 && t.info(`task methods: ${Object.keys(i).join(", ")}`);
-	}
-	runTask(e, ...t) {
-		return new Promise((r, i) => {
-			let a = Math.random().toString(36).substring(2), o = performance.now();
-			n.debug(`→ ${e.taskId}`, { args: t });
-			let s = (t) => {
-				let c = t.data;
-				if (c.messageId === a) {
-					this.port.removeEventListener("message", s);
-					let t = (performance.now() - o).toFixed(1);
-					c.success ? (n.debug(`← ${e.taskId} ok`, { ms: +t }), r(c.result)) : (n.warn(`← ${e.taskId} failed: ${c.error}`, { ms: +t }), i(Error(c.error)));
-				}
-			};
-			this.port.addEventListener("message", s), this.port.postMessage({
-				type: "EXECUTE_TASK",
-				messageId: a,
-				taskId: e.taskId,
-				args: t
-			});
-		});
-	}
-	disconnect() {
-		try {
-			this.port.postMessage({ type: "SHARED_DISCONNECT" });
-		} finally {
-			this.port.close();
-		}
-	}
-};
-async function i(e) {
-	if (typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated) throw Error("connectSharedWorker requires SharedArrayBuffer in a cross-origin isolated context — serve the page with COOP/COEP headers.");
-	if (!e.port && !e.workerUrl && !e.createWorker) throw Error("connectSharedWorker requires `workerUrl`, `createWorker`, or `port` in its config.");
-	let n = e.port ?? (e.createWorker ? e.createWorker().port : new SharedWorker(e.workerUrl, { type: "module" }).port);
-	return n.start(), await new Promise((i, a) => {
-		let o = setTimeout(() => a(/* @__PURE__ */ Error("connectSharedWorker: timed out waiting for the shared worker — is the host module calling sharedWorkerHost()?")), e.connectTimeoutMs ?? 1e4), s = (a) => {
-			let c = a.data;
-			c?.type === "SHARED_MEMORY" && (n.removeEventListener("message", s), clearTimeout(o), e.sharedMemory.bind(c.buffer), t.info(`connected as client #${c.clientIndex}`, { bytes: c.buffer.byteLength }), i(new r(n, c.clientIndex, e)));
-		};
-		n.addEventListener("message", s), n.postMessage({
-			type: "SHARED_CONNECT",
-			memoryBytes: e.sharedMemory.totalBytes,
-			memory: e.memory
-		});
-	});
-}
+//#region src/userTiming.ts
+var e = (e, t, n, r) => {
+	let i = globalThis.performance;
+	if (typeof i?.measure == "function") try {
+		i.measure(e, {
+			start: t,
+			end: Math.max(n, t),
+			detail: { devtools: {
+				dataType: "track-entry",
+				track: r.track,
+				trackGroup: "atoll",
+				color: r.color ?? "primary",
+				properties: r.properties,
+				tooltipText: r.tooltipText
+			} }
+		}), i.clearMeasures?.(e);
+	} catch {}
+}, t = (t, n, r, i, a, o, s) => e(`atoll task ${n}`, a, o, {
+	track: t,
+	color: s ? "primary" : "error",
+	properties: [
+		["runner", t],
+		["slot", i],
+		["call", r],
+		["outcome", s ? "ok" : "error"]
+	],
+	tooltipText: `${n} on ${t}#${i}: ${(o - a).toFixed(1)}ms`
+});
 //#endregion
-export { i as connectSharedWorker };
+export { e as measureAtoll, t as measureTaskCall };

package/dist/index13.js

@@ -1,25 +1,50 @@
-import { scoped as e } from "./index5.js";
-//#region src/worker/registry.ts
-var t = e("registry"), n = class {
-	static tasks = /* @__PURE__ */ new Map();
-	static register(e, n) {
-		this.tasks.set(e.taskId, {
-			contract: e,
-			handler: n
-		}), t.debug(`registered "${e.taskId}"`, {
-			args: e.argsSchema ? "validated" : "unvalidated",
-			result: e.resultSchema ? "validated" : "unvalidated"
-		});
-	}
-	static getContract(e) {
-		return this.tasks.get(e)?.contract;
-	}
-	static async execute(e, ...t) {
-		let n = this.tasks.get(e);
-		if (!n) throw Error(`Task handler not found for id: ${e}`);
-		let { contract: r, handler: i } = n, a = await i(...r.argsSchema ? r.argsSchema.parse(t) : t);
-		return r.resultSchema ? r.resultSchema.parse(a) : a;
-	}
-};
+import { devtoolsEnabled as e, forwardDevtools as t } from "./index5.js";
+import { MemoryManager as n } from "./index10.js";
+//#region src/pool/workerChannel.ts
+function r(e, t) {
+	if ((e.sharedMemory || e.sharedBuffer !== void 0) && (typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated)) throw Error(`${t} requires SharedArrayBuffer in a cross-origin isolated context — serve the page with COOP/COEP headers.`);
+	let r;
+	if (e.sharedBuffer !== void 0 && (r = typeof e.sharedBuffer == "function" ? e.sharedBuffer() : e.sharedBuffer, !r)) throw Error(`${t}: \`sharedBuffer\` resolved to an empty buffer — the producing pool or contract has no bound memory yet.`);
+	if (!e.sharedMemory) return {
+		sharedMemory: void 0,
+		injectedBuffer: r,
+		persistence: void 0
+	};
+	let i = e.sharedMemory, a;
+	return r ? i.bind(r) : (a = new n(e.memory), a.ensureCapacity(i.totalBytes), i.bind(a.getBuffer())), {
+		sharedMemory: i,
+		memoryManager: a,
+		injectedBuffer: r,
+		persistence: e.persistence?.(i)
+	};
+}
+function i(t, n) {
+	return n.memoryManager ? (t.postMessage({
+		type: "INIT_MEMORY",
+		memory: n.memoryManager.memory,
+		devtools: e()
+	}), "INIT_MEMORY") : n.injectedBuffer ? (t.postMessage({
+		type: "INIT_MEMORY",
+		buffer: n.injectedBuffer,
+		devtools: e()
+	}), "INIT_MEMORY") : (t.postMessage({
+		type: "INIT",
+		devtools: e()
+	}), "INIT");
+}
+function a(e, n, r) {
+	let i = (t) => `${e}#${n}~${t}`;
+	t({
+		...r,
+		...r.poolId === void 0 ? {} : { poolId: i(r.poolId) },
+		worker: r.worker === void 0 ? {
+			poolId: e,
+			slot: n
+		} : {
+			poolId: i(r.worker.poolId),
+			slot: r.worker.slot
+		}
+	});
+}
 //#endregion
-export { n as TaskRegistry };
+export { a as forwardWorkerDevtools, i as sendInit, r as setupChannelMemory };

package/dist/index14.js

@@ -1,61 +1,59 @@
-import { fmtBytes as e, scoped as t } from "./index5.js";
-import { bindSharedMemories as n } from "./index6.js";
-import { MemoryManager as r } from "./index8.js";
-import { TaskRegistry as i } from "./index13.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 { registerDevtoolsCommand as e } from "./index5.js";
+//#region src/pool/devtoolsCommands.ts
+var t = "chaos: injected failure", n = "killed from devtools", r = /* @__PURE__ */ new Map(), i = null, a = (e) => {
+	let t = e.poolId;
+	if (typeof t != "string") throw Error("poolId (string) is required");
+	let n = r.get(t);
+	if (!n) throw Error(t.includes("~") ? `runner '${t}' lives inside a worker: nested pools are not controllable from the dashboard` : `no live runner '${t}' on this thread`);
+	return n;
+}, o = (e, t) => {
+	if (e != null) {
+		if (typeof e != "number" || !Number.isFinite(e) || e < 0 || e > 1) throw Error(`${t} must be a number in 0..1`);
+		return e || void 0;
+	}
+}, s = (e) => {
+	let { delayMs: t } = e;
+	if (t != null && (typeof t != "number" || !Number.isFinite(t) || t < 0)) throw Error("delayMs must be a non-negative number");
+	let n = o(e.failRate, "failRate"), r = o(e.timeoutRate, "timeoutRate");
+	if ((n ?? 0) + (r ?? 0) > 1) throw Error("failRate + timeoutRate must not exceed 1");
+	let i = {};
+	return t && (i.delayMs = t), n && (i.failRate = n), r && (i.timeoutRate = r), Object.keys(i).length ? i : null;
+}, c = () => [...r.values()].map((e) => ({
+	poolId: e.poolId,
+	label: e.label ?? e.poolId,
+	size: e.size(),
+	dedicated: e.dedicated,
+	chaos: e.getChaos()
+})), l = () => {
+	let t = [
+		e("pool.list", () => c()),
+		e("pool.stats", (e) => a(e).stats()),
+		e("worker.kill", (e) => {
+			let t = a(e), n = e.slot ?? 0;
+			if (typeof n != "number" || !Number.isInteger(n) || n < 0) throw Error("slot must be a non-negative integer");
+			return t.kill(n), {
+				poolId: t.poolId,
+				slot: n,
+				killed: !0
+			};
+		}),
+		e("pool.chaos", (e) => {
+			let t = a(e);
+			return t.setChaos(s(e)), t.getChaos();
+		})
+	];
+	return () => t.forEach((e) => e());
+}, u = (e) => (r.set(e.poolId, e), i ??= l(), () => {
+	r.get(e.poolId) === e && (r.delete(e.poolId), r.size === 0 && i && (i(), i = null));
+}), d = (e, t) => {
+	let n = Math.random(), r = n < (e.failRate ?? 0), i = !r && n < (e.failRate ?? 0) + (e.timeoutRate ?? 0);
+	if (!e.delayMs && !r && !i) return t.post();
+	setTimeout(() => {
+		if (t.live()) {
+			if (r) return t.fail();
+			i && t.timeout(), t.post();
 		}
-		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."
-				});
-				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)
-				});
-			}
-			return;
-		}
-		r?.type === "SHARED_DISCONNECT" && (e.close(), a.info(`client #${t} disconnected`));
-	}, e.start();
-}
-function u() {
-	self.onconnect = (e) => {
-		l(e.ports[0]);
-	};
-}
+	}, e.delayMs ?? 0);
+};
 //#endregion
-export { l as attachSharedPort, u as sharedWorkerHost };
+export { t as CHAOS_FAILURE, n as KILL_MESSAGE, d as applyChaos, s as parseChaos, u as registerDevtoolsRunner };