@atolljs/core 0.1.13 → 0.1.15

package/dist/contract/listSchema.js

@@ -1,5 +1,5 @@
 import { fluent as e, z as t } from "./zod.js";
-//#region src/contract/listSchema.ts
+// src/contract/listSchema.ts
 var n = new TextEncoder(), r = (n, r) => e(t.number().check(t.int(), t.gte(n), t.lte(r))), i = {
 	i8: r(-128, 127),
 	u8: r(0, 255),
@@ -121,5 +121,4 @@ function _(e) {
 function v(e) {
 	return !s(e) || e._zod.def.type !== "string" ? null : _(e);
 }
-//#endregion
 export { o as listSchema, m as memberToSpec, g as zodArrayInfo, h as zodObjectShape, v as zodStringBytes };

package/dist/contract/memoryDevtools.js

@@ -1,5 +1,5 @@
 import { emitDevtools as e, previewValue as t, registerDevtoolsCommand as n } from "../devtools.js";
-//#region src/contract/memoryDevtools.ts
+// src/contract/memoryDevtools.ts
 var r = /* @__PURE__ */ new Map(), i = () => [], a = !1, o = 5, s = 16, c = (e) => {
 	let n = e;
 	if (typeof n.readAt == "function" && typeof n.recordCount == "number") {
@@ -114,7 +114,7 @@ var r = /* @__PURE__ */ new Map(), i = () => [], a = !1, o = 5, s = 16, c = (e)
 	rule: t.rule.text,
 	hits: t.hits
 })), v = (e) => {
-	i = e, !a && (a = !0, n("memory.read", () => {
+	i = e, a || (a = !0, n("memory.read", () => {
 		let e = [];
 		return i().forEach((t, n) => {
 			if (t.bound) for (let { path: r } of t.fields()) try {
@@ -159,5 +159,4 @@ var r = /* @__PURE__ */ new Map(), i = () => [], a = !1, o = 5, s = 16, c = (e)
 		return r.get(t)?.stop(), r.delete(t), _();
 	}), n("memory.watches", () => _()));
 };
-//#endregion
 export { h as checkWatchOnWrite, v as ensureMemoryCommands, c as fieldPreview, r as memoryWatches, p as parseWatchRule };

package/dist/contract/msgpackrCodec.js

@@ -1,8 +1,7 @@
 import { Packr as e } from "msgpackr";
-//#region src/contract/msgpackrCodec.ts
+// src/contract/msgpackrCodec.ts
 var t = new e({ useRecords: !0 }), n = {
 	encode: (e) => t.pack(e),
 	decode: (e) => t.unpack(e)
 };
-//#endregion
 export { n as msgpackrCodec };

package/dist/contract/reef.js

@@ -1,5 +1,5 @@
 import { fluent as e, z as t } from "./zod.js";
-//#region src/contract/reef.ts
+// src/contract/reef.ts
 var n = new TextEncoder(), r = {
 	i8: () => e(t.number().check(t.int(), t.gte(-128), t.lte(127))),
 	u8: () => e(t.number().check(t.int(), t.gte(0), t.lte(255))),
@@ -17,5 +17,4 @@ var n = new TextEncoder(), r = {
 	object: (n) => e(t.object(n)),
 	array: (n) => e(t.array(n))
 };
-//#endregion
 export { r as reef };

package/dist/contract/sharedMemory.js

@@ -1,11 +1,11 @@
-import { fluent as e, z as t } from "./zod.js";
-import { memberToSpec as n, zodArrayInfo as r, zodObjectShape as i, zodStringBytes as a } from "./listSchema.js";
-import { devtoolsEnabled as o, emitDevtools as s } from "../devtools.js";
-import { checkWatchOnWrite as c, ensureMemoryCommands as l, memoryWatches as u } from "./memoryDevtools.js";
-import { msgpackrCodec as d } from "./msgpackrCodec.js";
-import { fmtBytes as f, scoped as p } from "../log.js";
-//#region src/contract/sharedMemory.ts
-var m = p("memory"), h = 8, g = (e, t) => e + t - 1 & ~(t - 1), _ = (e) => g(e, h), v = (e) => typeof e == "object" && !!e && typeof e.kind == "string" && typeof e.byteLength == "number";
+import { msgpackrCodec as e } from "./msgpackrCodec.js";
+import { memberToSpec as t, zodArrayInfo as n, zodObjectShape as r, zodStringBytes as i } from "./listSchema.js";
+import { devtoolsEnabled as a, emitDevtools as o } from "../devtools.js";
+import { checkWatchOnWrite as s, ensureMemoryCommands as c, memoryWatches as l } from "./memoryDevtools.js";
+import { fmtBytes as u, scoped as d } from "../log.js";
+import { fluent as f, z as p } from "./zod.js";
+// src/contract/sharedMemory.ts
+var m = d("memory"), h = 8, g = (e, t) => e + t - 1 & ~(t - 1), _ = (e) => g(e, h), v = (e) => typeof e == "object" && !!e && typeof e.kind == "string" && typeof e.byteLength == "number";
 function y(e) {
 	let t = [];
 	for (let [n, r] of Object.entries(e)) if (v(r)) t.push({
@@ -41,14 +41,14 @@ var T = {
 	u64: 8
 }, E = (e) => typeof e == "string" ? T[e] : "string" in e ? e.string : 1, D = (e) => typeof e == "string" ? T[e] : 1;
 function O(e) {
-	let t = {}, r = {}, i = 0;
+	let n = {}, r = {}, i = 0;
 	for (let a of Object.keys(e)) {
-		let o = n(e[a], String(a));
-		r[a] = o, i = g(i, D(o)), t[a] = i, i += E(o);
+		let o = t(e[a], String(a));
+		r[a] = o, i = g(i, D(o)), n[a] = i, i += E(o);
 	}
 	return {
 		layout: r,
-		offsets: t,
+		offsets: n,
 		recordSize: _(i)
 	};
 }
@@ -68,7 +68,7 @@ var k = {
 			byteLength: 4 + n,
 			schema: t
 		};
-		let r = t ? a(t) : null;
+		let r = t ? i(t) : null;
 		if (r !== null) return {
 			kind: "string",
 			byteLength: 4 + r,
@@ -79,7 +79,7 @@ var k = {
 	object: (e) => {
 		let { schema: t, maxBytes: n } = e;
 		if (n === void 0 && t) {
-			let e = i(t);
+			let e = r(t);
 			if (e) {
 				let { layout: n, offsets: r, recordSize: i } = O(e);
 				return {
@@ -101,23 +101,23 @@ var k = {
 		};
 	},
 	array: (e) => {
-		let { schema: t, maxBytes: i } = e;
-		if (i === void 0 && t) {
-			let e = r(t);
+		let { schema: r, maxBytes: i } = e;
+		if (i === void 0 && r) {
+			let e = n(r);
 			if (e) {
 				if (e.capacity === null) throw TypeError("field.array: z.array() needs .max(n) or .length(n) — bounded arrays are fixed-width");
-				let r;
+				let n;
 				try {
-					r = n(e.element, "array element");
+					n = t(e.element, "array element");
 				} catch (e) {
 					throw TypeError(`field.array: element isn't a fixed-width member — use field.list for arrays of records (${e.message})`);
 				}
-				let i = g(E(r), D(r));
+				let i = g(E(n), D(n));
 				return {
 					kind: "array",
 					byteLength: 8 + e.capacity * i,
-					schema: t,
-					element: r,
+					schema: r,
+					element: n,
 					elementStride: i,
 					capacity: e.capacity
 				};
@@ -128,7 +128,7 @@ var k = {
 		return {
 			kind: "array",
 			byteLength: 4 + i,
-			schema: t
+			schema: r
 		};
 	},
 	int32Array: ({ length: e }) => ({
@@ -148,14 +148,14 @@ var k = {
 		byteLength: e
 	}),
 	list: ({ schema: e, count: t }) => {
-		let n = i(e);
+		let n = r(e);
 		if (!n) throw TypeError("field.list: schema must be a reef.object() of fixed-width members");
-		let { layout: r, offsets: a, recordSize: o } = O(n);
+		let { layout: i, offsets: a, recordSize: o } = O(n);
 		return {
 			kind: "list",
 			byteLength: o * t,
 			schema: e,
-			layout: r,
+			layout: i,
 			offsets: a,
 			recordSize: o,
 			count: t
@@ -348,22 +348,22 @@ var M = (e, t, n) => {
 };
 w("object", M), w("array", M);
 function N(e, t, n) {
-	let r = e, { offsets: i, recordSize: a, count: c } = r, l = j(t).compile(r.layout, i), u = (e) => {
+	let r = e, { offsets: i, recordSize: s, count: c } = r, l = j(t).compile(r.layout, i), u = (e) => {
 		if (e < 0 || e >= c) throw RangeError(`Record index ${e} out of bounds (0..${c - 1})`);
-	}, d = (e, t = {}, r) => (u(e), l.read(n + e * a, t, r)), f = (e, t, r) => {
-		u(e), l.write(n + e * a, t, r);
+	}, d = (e, t = {}, r) => (u(e), l.read(n + e * s, t, r)), f = (e, t, r) => {
+		u(e), l.write(n + e * s, t, r);
 	};
 	return {
 		byteOffset: n,
 		byteLength: e.byteLength,
 		recordCount: c,
-		recordSize: a,
+		recordSize: s,
 		readAt: d,
 		writeAt: f,
 		commit: () => {
 			if (t.version) {
 				let e = Atomics.add(t.version.view, t.version.index, 1);
-				Atomics.notify(t.version.view, t.version.index), t.path && o() && s({
+				Atomics.notify(t.version.view, t.version.index), t.path && a() && o({
 					type: "memory:write",
 					path: t.path,
 					version: e + 1
@@ -384,17 +384,17 @@ function F(e) {
 	for (let [n, r] of Object.entries(e)) t[n] = v(r) ? I(r) : Object.fromEntries(Object.entries(r).map(([e, t]) => [e, I(t)]));
 	return t;
 }
-function I(n) {
-	if (n.schema) return n.schema;
-	switch (n.kind) {
-		case "number": return e(t.number());
-		case "boolean": return e(t.boolean());
-		case "string": return e(t.string());
-		case "Int32": return e(t.instanceof(Int32Array));
-		case "Float64": return e(t.instanceof(Float64Array));
-		case "BigInt64": return e(t.instanceof(BigInt64Array));
-		case "Uint8": return e(t.instanceof(Uint8Array));
-		default: return e(t.unknown());
+function I(e) {
+	if (e.schema) return e.schema;
+	switch (e.kind) {
+		case "number": return f(p.number());
+		case "boolean": return f(p.boolean());
+		case "string": return f(p.string());
+		case "Int32": return f(p.instanceof(Int32Array));
+		case "Float64": return f(p.instanceof(Float64Array));
+		case "BigInt64": return f(p.instanceof(BigInt64Array));
+		case "Uint8": return f(p.instanceof(Uint8Array));
+		default: return f(p.unknown());
 	}
 }
 var L = class {
@@ -410,12 +410,12 @@ var L = class {
 	boundListeners = /* @__PURE__ */ new Set();
 	isBound = !1;
 	boundBuffer;
-	constructor(e, t = {}) {
-		this.spec = e, this.codec = t.codec ?? d, this.plugins = t.plugins, this.entries = y(e), this.schemas = F(e);
-		let n = 0;
-		for (let { path: e, descriptor: t } of this.entries) n = _(n), this.offsets.set(e, n), n += t.byteLength;
-		this.versionOffset = _(n), this.totalBytes = this.versionOffset + _(this.entries.length * 4), P.push(this), m.info(`contract defined: ${this.entries.length} field(s), ${f(this.totalBytes)}`, {
-			fields: Object.fromEntries(this.entries.map((e) => [e.path, `${e.descriptor.kind}@${this.offsets.get(e.path)?.toLocaleString()}+${f(e.descriptor.byteLength)}`])),
+	constructor(t, n = {}) {
+		this.spec = t, this.codec = n.codec ?? e, this.plugins = n.plugins, this.entries = y(t), this.schemas = F(t);
+		let r = 0;
+		for (let { path: e, descriptor: t } of this.entries) r = _(r), this.offsets.set(e, r), r += t.byteLength;
+		this.versionOffset = _(r), this.totalBytes = this.versionOffset + _(this.entries.length * 4), P.push(this), m.info(`contract defined: ${this.entries.length} field(s), ${u(this.totalBytes)}`, {
+			fields: Object.fromEntries(this.entries.map((e) => [e.path, `${e.descriptor.kind}@${this.offsets.get(e.path)?.toLocaleString()}+${u(e.descriptor.byteLength)}`])),
 			pluginOverrides: Object.keys(this.plugins ?? {})
 		});
 	}
@@ -423,10 +423,10 @@ var L = class {
 		this.connectors.clear();
 		let t = new Int32Array(e, this.versionOffset, this.entries.length);
 		this.entries.forEach(({ path: n, descriptor: r }, i) => {
-			let a = this.plugins?.[r.kind] ?? C.get(r.kind);
-			if (!a) throw Error(`Unknown shared memory field kind: ${r.kind}`);
-			m.debug(`bind "${n}" (${r.kind}, ${f(r.byteLength)}) via ${this.plugins?.[r.kind] ? "plugin" : "built-in"} factory`);
-			let l = a(r, {
+			let c = this.plugins?.[r.kind] ?? C.get(r.kind);
+			if (!c) throw Error(`Unknown shared memory field kind: ${r.kind}`);
+			m.debug(`bind "${n}" (${r.kind}, ${u(r.byteLength)}) via ${this.plugins?.[r.kind] ? "plugin" : "built-in"} factory`);
+			let d = c(r, {
 				buffer: e,
 				codec: this.codec,
 				version: {
@@ -434,20 +434,20 @@ var L = class {
 					index: i
 				},
 				path: n
-			}, this.offsets.get(n)), d = l.commit;
+			}, this.offsets.get(n)), f = d.commit;
 			this.connectors.set(n, {
-				...l,
+				...d,
 				write: (e) => {
-					l.write(e);
+					d.write(e);
 					let r = Atomics.add(t, i, 1);
-					Atomics.notify(t, i), o() && (s({
+					Atomics.notify(t, i), a() && (o({
 						type: "memory:write",
 						path: n,
 						version: r + 1
-					}), u.size && c(this, n, r + 1));
+					}), l.size && s(this, n, r + 1));
 				},
-				...d && o() ? { commit: () => {
-					d(), u.size && c(this, n, Atomics.load(t, i));
+				...f && a() ? { commit: () => {
+					f(), l.size && s(this, n, Atomics.load(t, i));
 				} } : {},
 				_version: {
 					view: t,
@@ -455,7 +455,7 @@ var L = class {
 				},
 				_path: n
 			});
-		}), o() && (l(() => P), s({
+		}), a() && (c(() => P), o({
 			type: "memory:bind",
 			fields: this.entries.map((e, t) => [t, e.path]),
 			totalBytes: this.totalBytes
@@ -506,10 +506,9 @@ function R(e, t = {}) {
 }
 function z(e) {
 	for (let t of P) t.bind(e);
-	m.info(`bound ${P.length} contract(s) — ${f(e.byteLength)} buffer`);
+	m.info(`bound ${P.length} contract(s) — ${u(e.byteLength)} buffer`);
 }
 function B() {
 	return P.length;
 }
-//#endregion
 export { L as SharedMemory, z as bindSharedMemories, R as defineSharedMemory, k as field, B as getDefinedSharedMemoryCount, S as jsonCodec, w as registerConnectorFactory };

package/dist/contract/types.d.ts

@@ -36,6 +36,23 @@ export interface MemoryPersistence {
     /** Final flush + release external resources. Invoked by pool.terminate(). */
     stop(): void | Promise<void>;
 }
+/**
+ * A worker lifecycle transition, emitted by pools and dedicated workers
+ * through `onLifecycle`/`onWorkerEvent` — the seam error boundaries build
+ * on. `'error'` fires when a worker's error event lands (before respawn);
+ * `'respawn'` when the replacement is attached; `'terminate'` when the
+ * runner tears down deliberately.
+ */
+export interface WorkerLifecycleEvent {
+    type: 'error' | 'respawn' | 'terminate';
+    /** The emitting runner's devtools correlation id ('worker-N'/'pool-N'). */
+    poolId: string;
+    /** Worker slot in a pool; always 0 for a dedicated worker. */
+    slot?: number;
+    /** The crash/error message on 'error' events. */
+    message?: string;
+}
+export type WorkerLifecycleListener = (event: WorkerLifecycleEvent) => void;
 export interface WorkerPoolConfig<S extends SharedSpec = SharedSpec, T extends TaskMap = TaskMap> {
     /** Worker entry as a URL — e.g. `new URL('./worker.ts', import.meta.url)`. */
     workerUrl?: URL;
@@ -80,6 +97,13 @@ export interface WorkerPoolConfig<S extends SharedSpec = SharedSpec, T extends T
     maxQueue?: number;
     /** Default true — a worker 'error' rejects its in-flight tasks and spawns a replacement. */
     respawn?: boolean;
+    /**
+     * Lifecycle observer — called on worker 'error' (before respawn),
+     * 'respawn', and 'terminate'. Island boundaries subscribe through
+     * `client.onWorkerEvent` to detect crashes; config-level listeners get
+     * the same events.
+     */
+    onLifecycle?: WorkerLifecycleListener;
     /**
      * Default per-task timeout in ms (per-call `options.timeout` overrides).
      * The timer starts at enqueue, so it bounds queue-wait + execution together.

package/dist/contract/zod.js

@@ -1,4 +1,4 @@
-//#region src/contract/zod.ts
+// src/contract/zod.ts
 var e = (e, t) => ({
 	_zod: { def: e },
 	evaluate: t
@@ -258,5 +258,4 @@ var te = {
 	ZodArray: w,
 	ZodString: y
 };
-//#endregion
 export { h as SchemaError, g as ZodType, $ as fluent, m as globalRegistry, te as z };

package/dist/devtools.js

@@ -1,4 +1,4 @@
-//#region src/devtools.ts
+// src/devtools.ts
 var e = typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "worker" : "main", t = null, n = null, r = /* @__PURE__ */ new Set(), i = () => {
 	if (r.size === 0) {
 		t = n;
@@ -179,52 +179,45 @@ var e = typeof WorkerGlobalScope < "u" && self instanceof WorkerGlobalScope ? "w
 	let n = e.performance;
 	if (!n) return;
 	let r = n.memory, i = typeof WorkerGlobalScope < "u" && globalThis.self instanceof WorkerGlobalScope, a = n.measureUserAgentSpecificMemory?.bind(n), o = globalThis.process?.memoryUsage;
-	if (r || a && !i || o) {
-		if (E.add(e), a && !i) {
-			setInterval(() => {
-				a().then((e) => {
-					let t = (e.breakdown ?? []).map((e) => ({
-						bytes: e.bytes,
-						scope: e.attribution?.[0]?.scope,
-						url: e.attribution?.[0]?.url
-					})).sort((e, t) => t.bytes - e.bytes).slice(0, 24);
-					s({
-						type: "runtime:memory",
-						heapBytes: e.bytes,
-						heapLimitBytes: r?.jsHeapSizeLimit,
-						contexts: t
-					});
-				}).catch(() => {
-					r && s({
-						type: "runtime:memory",
-						heapBytes: r.usedJSHeapSize,
-						heapLimitBytes: r.jsHeapSizeLimit
-					});
-				});
-			}, Math.max(t, 4e3)).unref?.();
-			return;
-		}
-		setInterval(() => {
-			if (r) s({
+	(r || a && !i || o) && (E.add(e), a && !i ? setInterval(() => {
+		a().then((e) => {
+			let t = (e.breakdown ?? []).map((e) => ({
+				bytes: e.bytes,
+				scope: e.attribution?.[0]?.scope,
+				url: e.attribution?.[0]?.url
+			})).sort((e, t) => t.bytes - e.bytes).slice(0, 24);
+			s({
+				type: "runtime:memory",
+				heapBytes: e.bytes,
+				heapLimitBytes: r?.jsHeapSizeLimit,
+				contexts: t
+			});
+		}).catch(() => {
+			r && s({
 				type: "runtime:memory",
 				heapBytes: r.usedJSHeapSize,
 				heapLimitBytes: r.jsHeapSizeLimit
 			});
-			else if (o) {
-				let e = o();
-				s({
-					type: "runtime:memory",
-					heapBytes: e.heapUsed,
-					rssBytes: e.rss
-				});
-			}
-		}, t).unref?.();
-	}
+		});
+	}, Math.max(t, 4e3)).unref?.() : setInterval(() => {
+		if (r) s({
+			type: "runtime:memory",
+			heapBytes: r.usedJSHeapSize,
+			heapLimitBytes: r.jsHeapSizeLimit
+		});
+		else if (o) {
+			let e = o();
+			s({
+				type: "runtime:memory",
+				heapBytes: e.heapUsed,
+				rssBytes: e.rss
+			});
+		}
+	}, t).unref?.());
 }, O = 0, k = /* @__PURE__ */ new Map(), A = (e, t) => {
 	let n = t?.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
 	if (!n) return `${e}-${++O}`;
 	let r = `${n}-${e === "pool" ? "p" : e === "worker" ? "w" : e}`, i = (k.get(r) ?? 0) + 1;
 	return k.set(r, i), i === 1 ? r : `${r}${i}`;
 };
-//#endregion
 export { o as addDevtoolsSink, l as devtoolsEnabled, s as emitDevtools, _ as enableWorkerDevtoolsForwarding, d as estimateCloneBytes, c as forwardDevtools, T as installFetchProbe, D as installMemoryProbe, m as listDevtoolsCommands, A as nextDevtoolsId, u as previewValue, p as registerDevtoolsCommand, h as runDevtoolsCommand, a as setDevtoolsSink };

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export type { Codec, Connector, ConnectorContext, ConnectorFactory, FieldDescrip
 export { msgpackrCodec } from './contract/msgpackrCodec.js';
 export { listSchema } from './contract/listSchema.js';
 export type { ListZodShape } from './contract/listSchema.js';
-export type { MemoryConfig, PoolTasks, Prettify, Schema, Logger, TaskContract, TaskMap, TaskMessage, TaskResult, MemoryPersistence, SharedWorkerConfig, ViewType, WorkerPoolConfig, } from './contract/types.js';
+export type { MemoryConfig, PoolTasks, Prettify, Schema, Logger, TaskContract, TaskMap, TaskMessage, TaskResult, MemoryPersistence, SharedWorkerConfig, ViewType, WorkerLifecycleEvent, WorkerLifecycleListener, WorkerPoolConfig, } from './contract/types.js';
 export { MemoryManager } from './pool/memory.js';
 export { WorkerPool } from './pool/workerPool.js';
 export type { PoolStats, RunOptions } from './pool/workerPool.js';

package/dist/index.js

@@ -1,22 +1,22 @@
-import { SchemaError as e, z as t } from "./contract/zod.js";
-import { listSchema as n } from "./contract/listSchema.js";
-import { addDevtoolsSink as r, devtoolsEnabled as i, emitDevtools as a, estimateCloneBytes as o, installFetchProbe as s, installMemoryProbe as c, listDevtoolsCommands as l, previewValue as u, registerDevtoolsCommand as d, runDevtoolsCommand as f, setDevtoolsSink as p } from "./devtools.js";
-import { msgpackrCodec as m } from "./contract/msgpackrCodec.js";
-import { reef as h } from "./contract/reef.js";
-import { getLogLevel as g, log as _, scoped as v, setLogLevel as y, setLogSink as b } from "./log.js";
-import { bindSharedMemories as x, defineSharedMemory as S, field as C, getDefinedSharedMemoryCount as w, jsonCodec as T, registerConnectorFactory as E } from "./contract/sharedMemory.js";
-import { MemoryManager as D } from "./pool/memory.js";
-import { PoolQueueFullError as O, TaskAbortedError as k, TaskTimeoutError as A, WorkerCrashedError as j } from "./pool/errors.js";
-import { WorkerPool as M } from "./pool/workerPool.js";
-import { DedicatedWorker as N } from "./pool/dedicatedWorker.js";
-import { connectWorker as P, resolveWorkerCount as F, workerClient as I } from "./pool/workerClient.js";
-import { connectSubWorker as L } from "./pool/subWorkerClient.js";
-import { connectSharedWorker as R } from "./shared/sharedWorkerClient.js";
-import { TaskRegistry as z } from "./worker/registry.js";
-import { sharedWorkerHost as B } from "./shared/sharedWorkerHost.js";
-import { createClient as V, defineService as H, implementService as U, rpc as W, serviceMethod as G } from "./service.js";
-import { RESERVED_CLIENT_KEYS as K, defineWorker as q } from "./worker/defineWorker.js";
-import { reactive as J, shallowEqual as Y, watch as X } from "./reactive.js";
-import { observe as Z } from "./observable.js";
-import { defineTask as Q, isAsyncTask as $, toTask as ee } from "./task.js";
-export { N as DedicatedWorker, D as MemoryManager, O as PoolQueueFullError, K as RESERVED_CLIENT_KEYS, e as SchemaError, k as TaskAbortedError, z as TaskRegistry, A as TaskTimeoutError, j as WorkerCrashedError, M as WorkerPool, r as addDevtoolsSink, x as bindSharedMemories, R as connectSharedWorker, L as connectSubWorker, P as connectWorker, V as createClient, H as defineService, S as defineSharedMemory, Q as defineTask, q as defineWorker, i as devtoolsEnabled, a as emitDevtools, o as estimateCloneBytes, C as field, w as getDefinedSharedMemoryCount, g as getLogLevel, U as implementService, s as installFetchProbe, c as installMemoryProbe, $ as isAsyncTask, T as jsonCodec, l as listDevtoolsCommands, n as listSchema, _ as log, m as msgpackrCodec, Z as observe, u as previewValue, J as reactive, h as reef, E as registerConnectorFactory, d as registerDevtoolsCommand, F as resolveWorkerCount, W as rpc, f as runDevtoolsCommand, v as scoped, G as serviceMethod, p as setDevtoolsSink, y as setLogLevel, b as setLogSink, Y as shallowEqual, B as sharedWorkerHost, ee as toTask, X as watch, I as workerClient, t as z };
+import { bindSharedMemories as e, defineSharedMemory as t, field as n, getDefinedSharedMemoryCount as r, jsonCodec as i, registerConnectorFactory as a } from "./contract/sharedMemory.js";
+import { reef as o } from "./contract/reef.js";
+import { SchemaError as s, z as c } from "./contract/zod.js";
+import { msgpackrCodec as l } from "./contract/msgpackrCodec.js";
+import { listSchema as u } from "./contract/listSchema.js";
+import { MemoryManager as d } from "./pool/memory.js";
+import { WorkerPool as f } from "./pool/workerPool.js";
+import { PoolQueueFullError as p, TaskAbortedError as m, TaskTimeoutError as h, WorkerCrashedError as g } from "./pool/errors.js";
+import { DedicatedWorker as _ } from "./pool/dedicatedWorker.js";
+import { connectWorker as v, resolveWorkerCount as y, workerClient as b } from "./pool/workerClient.js";
+import { connectSubWorker as x } from "./pool/subWorkerClient.js";
+import { connectSharedWorker as S } from "./shared/sharedWorkerClient.js";
+import { sharedWorkerHost as C } from "./shared/sharedWorkerHost.js";
+import { createClient as w, defineService as T, implementService as E, rpc as D, serviceMethod as O } from "./service.js";
+import { TaskRegistry as k } from "./worker/registry.js";
+import { RESERVED_CLIENT_KEYS as A, defineWorker as j } from "./worker/defineWorker.js";
+import { reactive as M, shallowEqual as N, watch as P } from "./reactive.js";
+import { observe as F } from "./observable.js";
+import { defineTask as I, isAsyncTask as L, toTask as R } from "./task.js";
+import { getLogLevel as z, log as B, scoped as V, setLogLevel as H, setLogSink as U } from "./log.js";
+import { addDevtoolsSink as W, devtoolsEnabled as G, emitDevtools as K, estimateCloneBytes as q, installFetchProbe as J, installMemoryProbe as Y, listDevtoolsCommands as X, previewValue as Z, registerDevtoolsCommand as Q, runDevtoolsCommand as $, setDevtoolsSink as ee } from "./devtools.js";
+export { _ as DedicatedWorker, d as MemoryManager, p as PoolQueueFullError, A as RESERVED_CLIENT_KEYS, s as SchemaError, m as TaskAbortedError, k as TaskRegistry, h as TaskTimeoutError, g as WorkerCrashedError, f as WorkerPool, W as addDevtoolsSink, e as bindSharedMemories, S as connectSharedWorker, x as connectSubWorker, v as connectWorker, w as createClient, T as defineService, t as defineSharedMemory, I as defineTask, j as defineWorker, G as devtoolsEnabled, K as emitDevtools, q as estimateCloneBytes, n as field, r as getDefinedSharedMemoryCount, z as getLogLevel, E as implementService, J as installFetchProbe, Y as installMemoryProbe, L as isAsyncTask, i as jsonCodec, X as listDevtoolsCommands, u as listSchema, B as log, l as msgpackrCodec, F as observe, Z as previewValue, M as reactive, o as reef, a as registerConnectorFactory, Q as registerDevtoolsCommand, y as resolveWorkerCount, D as rpc, $ as runDevtoolsCommand, V as scoped, O as serviceMethod, ee as setDevtoolsSink, H as setLogLevel, U as setLogSink, N as shallowEqual, C as sharedWorkerHost, R as toTask, P as watch, b as workerClient, c as z };

package/dist/log.js

@@ -1,5 +1,5 @@
 import { devtoolsEnabled as e, emitDevtools as t, previewValue as n } from "./devtools.js";
-//#region src/log.ts
+// src/log.ts
 var r = {
 	trace: 0,
 	debug: 1,
@@ -48,5 +48,4 @@ function p(e) {
 	};
 }
 var m = (e) => e >= 1 << 20 ? `${(e / (1 << 20)).toFixed(1)}MB` : e >= 1024 ? `${(e / 1024).toFixed(1)}KB` : `${e}B`;
-//#endregion
 export { m as fmtBytes, l as getLogLevel, f as log, p as scoped, c as setLogLevel, u as setLogSink };

package/dist/observable.js

@@ -1,22 +1,22 @@
-import { scoped as e } from "./log.js";
+import { watchNodes as e } from "./reactive.js";
 import { relabelNode as t } from "./reactiveGraph.js";
-import { watchNodes as n } from "./reactive.js";
-//#region src/observable.ts
-var r = e("observe");
-function i(e, i, a, o) {
+import { scoped as n } from "./log.js";
+// src/observable.ts
+var r = n("observe");
+function i(n, i, a, o) {
 	let s = a ?? ((e) => e), c = o?.equals ?? Object.is, l, u = -1, d = null, f = null, p = null, m = null, h = null, g = /* @__PURE__ */ new Set(), _ = () => t(h, `observe(${String(i)}) · ${g.size} sub${g.size === 1 ? "" : "s"}`), v = () => {
 		if (d || f) return;
 		let t;
 		try {
-			t = e.connector(String(i));
+			t = n.connector(String(i));
 		} catch {
-			f = e.onBound(() => {
+			f = n.onBound(() => {
 				let e = f;
 				f = null, e?.(), v();
 			});
 			return;
 		}
-		let u = n(t, s, (e) => {
+		let u = e(t, s, (e) => {
 			if (l === void 0 || !c(l, e)) {
 				l = e;
 				for (let t of g) t(e);
@@ -25,26 +25,26 @@ function i(e, i, a, o) {
 			sliced: a !== void 0,
 			label: "observe"
 		});
-		d = u.stop, h = u.effect, _(), m = t, p ??= e.onBound(() => {
-			let t;
+		d = u.stop, h = u.effect, _(), m = t, p ??= n.onBound(() => {
+			let e;
 			try {
-				t = e.connector(String(i));
+				e = n.connector(String(i));
 			} catch {
 				return;
 			}
-			t !== m && (d?.(), d = null, m = null, v());
+			e !== m && (d?.(), d = null, m = null, v());
 		}), r.debug(`observing "${String(i)}" (offset ${t.byteOffset})`);
 	}, y = () => {
 		d?.(), d = null, h = null, m = null, f?.(), f = null, p?.(), p = null;
 	};
 	return {
 		get() {
-			if (d || e.bound) try {
-				let t = e.connector(String(i)), n = t._version ? Atomics.load(t._version.view, t._version.index) : 0;
-				if (n !== u) {
-					u = n;
-					let e = s(t.read());
-					(l === void 0 || !c(l, e)) && (l = e);
+			if (d || n.bound) try {
+				let e = n.connector(String(i)), t = e._version ? Atomics.load(e._version.view, e._version.index) : 0;
+				if (t !== u) {
+					u = t;
+					let n = s(e.read());
+					l !== void 0 && c(l, n) || (l = n);
 				}
 			} catch {}
 			return l;
@@ -56,5 +56,4 @@ function i(e, i, a, o) {
 		}
 	};
 }
-//#endregion
 export { i as observe };

package/dist/pool/dedicatedWorker.d.ts

@@ -27,6 +27,7 @@ export declare class DedicatedWorker<S extends SharedSpec = SharedSpec> {
     private readonly mem;
     private readonly spawn;
     private readonly respawn;
+    private readonly onLifecycle?;
     private readonly taskTimeout?;
     private readonly label?;
     private worker;
@@ -43,6 +44,8 @@ export declare class DedicatedWorker<S extends SharedSpec = SharedSpec> {
     private attach;
     private detach;
     private handleReply;
+    /** Fan out a lifecycle transition — error boundaries subscribe through this. */
+    private lifecycle;
     private handleError;
     private rejectPending;
     /** Abort/timeout: the caller rejects now; the worker's eventual reply is discarded. */