@atolljs/core 0.1.7 → 0.1.8

package/dist/index8.js

@@ -1,21 +1,515 @@
-import { fluent as e, z as t } from "./index3.js";
-//#region 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))),
-	i16: () => e(t.number().check(t.int(), t.gte(-32768), t.lte(32767))),
-	u16: () => e(t.number().check(t.int(), t.gte(0), t.lte(65535))),
-	i32: () => e(t.int32()),
-	u32: () => e(t.uint32()),
-	f32: () => e(t.float32()),
-	f64: () => e(t.float64()),
-	i64: () => e(t.int64()),
-	u64: () => e(t.uint64()),
-	int: (n, r) => e(t.number().check(t.int(), t.gte(n), t.lte(r))),
-	boolean: () => e(t.boolean()),
-	string: (r) => e(t.string().check(t.refine((e) => n.encode(e).byteLength <= r, `exceeds ${r} UTF-8 bytes`)).register(t.globalRegistry, { bytes: r })),
-	object: (n) => e(t.object(n)),
-	array: (n) => e(t.array(n))
+import { msgpackrCodec as e } from "./index2.js";
+import { fluent as t, z as n } from "./index3.js";
+import { memberToSpec as r, zodArrayInfo as i, zodObjectShape as a, zodStringBytes as o } from "./index4.js";
+import { devtoolsEnabled as s, emitDevtools as c } from "./index5.js";
+import { checkWatchOnWrite as l, ensureMemoryCommands as u, memoryWatches as d } from "./index6.js";
+import { fmtBytes as f, scoped as p } from "./index7.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";
+function y(e) {
+	let t = [];
+	for (let [n, r] of Object.entries(e)) if (v(r)) t.push({
+		path: n,
+		descriptor: r
+	});
+	else for (let [e, i] of Object.entries(r)) {
+		if (!v(i)) throw TypeError(`shared memory "${n}.${e}" is not a field descriptor — intent groups nest one level only`);
+		t.push({
+			path: `${n}.${e}`,
+			descriptor: i
+		});
+	}
+	return t;
+}
+var b = new TextEncoder(), x = new TextDecoder(), S = {
+	encode: (e) => b.encode(JSON.stringify(e)),
+	decode: (e) => JSON.parse(x.decode(e))
+}, C = /* @__PURE__ */ new Map();
+function w(e, t) {
+	C.set(e, t);
+}
+var T = {
+	i8: 1,
+	u8: 1,
+	i16: 2,
+	u16: 2,
+	i32: 4,
+	u32: 4,
+	f32: 4,
+	f64: 8,
+	i64: 8,
+	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 = {}, n = {}, i = 0;
+	for (let a of Object.keys(e)) {
+		let o = r(e[a], String(a));
+		n[a] = o, i = g(i, D(o)), t[a] = i, i += E(o);
+	}
+	return {
+		layout: n,
+		offsets: t,
+		recordSize: _(i)
+	};
+}
+var k = {
+	number: () => ({
+		kind: "number",
+		byteLength: 8
+	}),
+	boolean: () => ({
+		kind: "boolean",
+		byteLength: 8
+	}),
+	string: (e) => {
+		let { schema: t, maxBytes: n } = e;
+		if (n !== void 0) return {
+			kind: "string",
+			byteLength: 4 + n,
+			schema: t
+		};
+		let r = t ? o(t) : null;
+		if (r !== null) return {
+			kind: "string",
+			byteLength: 4 + r,
+			schema: t
+		};
+		throw TypeError("field.string: pass { maxBytes } or a schema carrying a byte budget — reef.string(n) / z.string().meta({ bytes: n })");
+	},
+	object: (e) => {
+		let { schema: t, maxBytes: n } = e;
+		if (n === void 0 && t) {
+			let e = a(t);
+			if (e) {
+				let { layout: n, offsets: r, recordSize: i } = O(e);
+				return {
+					kind: "object",
+					byteLength: 8 + i,
+					schema: t,
+					layout: n,
+					offsets: r,
+					recordSize: i
+				};
+			}
+			throw TypeError("field.object: schema can't derive a fixed byte width (not a zod object of fixed-width members) — pass { maxBytes } for codec-encoded storage");
+		}
+		if (n === void 0) throw TypeError("field.object: pass { schema } for a fixed-layout field or { maxBytes } for a codec-encoded field");
+		return {
+			kind: "object",
+			byteLength: 4 + n,
+			schema: t
+		};
+	},
+	array: (e) => {
+		let { schema: t, maxBytes: n } = e;
+		if (n === void 0 && t) {
+			let e = i(t);
+			if (e) {
+				if (e.capacity === null) throw TypeError("field.array: z.array() needs .max(n) or .length(n) — bounded arrays are fixed-width");
+				let n;
+				try {
+					n = r(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(n), D(n));
+				return {
+					kind: "array",
+					byteLength: 8 + e.capacity * i,
+					schema: t,
+					element: n,
+					elementStride: i,
+					capacity: e.capacity
+				};
+			}
+			throw TypeError("field.array: schema can't derive a fixed byte width (not a bounded zod array) — pass { maxBytes } for codec-encoded storage");
+		}
+		if (n === void 0) throw TypeError("field.array: pass { schema } for a fixed-layout field or { maxBytes } for a codec-encoded field");
+		return {
+			kind: "array",
+			byteLength: 4 + n,
+			schema: t
+		};
+	},
+	int32Array: ({ length: e }) => ({
+		kind: "Int32",
+		byteLength: e * 4
+	}),
+	float64Array: ({ length: e }) => ({
+		kind: "Float64",
+		byteLength: e * 8
+	}),
+	bigInt64Array: ({ length: e }) => ({
+		kind: "BigInt64",
+		byteLength: e * 8
+	}),
+	uint8Array: ({ length: e }) => ({
+		kind: "Uint8",
+		byteLength: e
+	}),
+	list: ({ schema: e, count: t }) => {
+		let n = a(e);
+		if (!n) throw TypeError("field.list: schema must be a reef.object() of fixed-width members");
+		let { layout: r, offsets: i, recordSize: o } = O(n);
+		return {
+			kind: "list",
+			byteLength: o * t,
+			schema: e,
+			layout: r,
+			offsets: i,
+			recordSize: o,
+			count: t
+		};
+	}
+}, A = {
+	Int32: Int32Array,
+	Float64: Float64Array,
+	BigInt64: BigInt64Array,
+	Uint8: Uint8Array
 };
+w("number", (e, t, n) => {
+	let r = new Float64Array(t.buffer, n, 1);
+	return {
+		byteOffset: n,
+		byteLength: e.byteLength,
+		read: () => r[0],
+		write: (e) => {
+			r[0] = e;
+		}
+	};
+}), w("boolean", (e, t, n) => {
+	let r = new Uint8Array(t.buffer, n, 1);
+	return {
+		byteOffset: n,
+		byteLength: e.byteLength,
+		read: () => r[0] === 1,
+		write: (e) => {
+			r[0] = +!!e;
+		}
+	};
+});
+for (let e of Object.keys(A)) w(e, (t, n, r) => {
+	let i = A[e], a = new i(n.buffer, r, t.byteLength / i.BYTES_PER_ELEMENT);
+	return {
+		byteOffset: r,
+		byteLength: t.byteLength,
+		read: () => a,
+		write: (e) => a.set(e)
+	};
+});
+w("string", (e, t, n) => {
+	let r = new TextEncoder(), i = new TextDecoder(), a = e.byteLength - 4, o = new Uint32Array(t.buffer, n, 1), s = (e) => {
+		if (e.byteLength > a) throw Error(`Encoded value of ${e.byteLength} bytes exceeds field capacity of ${a} bytes at offset ${n}`);
+		o[0] = e.byteLength, new Uint8Array(t.buffer, n + 4, e.byteLength).set(e);
+	}, c = () => new Uint8Array(t.buffer, n + 4, o[0]).slice();
+	return {
+		byteOffset: n,
+		byteLength: e.byteLength,
+		read: () => i.decode(c()),
+		write: (t) => s(r.encode(e.schema ? e.schema.parse(t) : t))
+	};
+});
+function j(e) {
+	let t = new DataView(e.buffer), n = new Uint8Array(e.buffer), r = new TextEncoder(), i = new TextDecoder(), a = {
+		i8: {
+			get: (e) => t.getInt8(e),
+			set: (e, n) => t.setInt8(e, n)
+		},
+		u8: {
+			get: (e) => t.getUint8(e),
+			set: (e, n) => t.setUint8(e, n)
+		},
+		i16: {
+			get: (e) => t.getInt16(e),
+			set: (e, n) => t.setInt16(e, n)
+		},
+		u16: {
+			get: (e) => t.getUint16(e),
+			set: (e, n) => t.setUint16(e, n)
+		},
+		i32: {
+			get: (e) => t.getInt32(e),
+			set: (e, n) => t.setInt32(e, n)
+		},
+		u32: {
+			get: (e) => t.getUint32(e),
+			set: (e, n) => t.setUint32(e, n)
+		},
+		f32: {
+			get: (e) => t.getFloat32(e),
+			set: (e, n) => t.setFloat32(e, n)
+		},
+		f64: {
+			get: (e) => t.getFloat64(e),
+			set: (e, n) => t.setFloat64(e, n)
+		},
+		i64: {
+			get: (e) => t.getBigInt64(e),
+			set: (e, n) => t.setBigInt64(e, n)
+		},
+		u64: {
+			get: (e) => t.getBigUint64(e),
+			set: (e, n) => t.setBigUint64(e, n)
+		}
+	}, o = (e, t) => {
+		let r = n.indexOf(0, e), a = r === -1 || r - e >= t ? t : r - e;
+		return i.decode(n.slice(e, e + a));
+	}, s = /* @__PURE__ */ new Uint8Array(64), c = (e, t, i) => {
+		s.length < t && (s = new Uint8Array(t));
+		let { read: a, written: o } = r.encodeInto(i, s);
+		if (a < i.length || o > t) throw Error(`String exceeds inline field capacity of ${t} bytes`);
+		n.set(s.subarray(0, o), e), o < t && n.fill(0, e + o, e + t);
+	}, l = (e) => {
+		if (typeof e == "string") {
+			let t = a[e];
+			return {
+				get: (e) => t.get(e),
+				set: (e, n) => t.set(e, n)
+			};
+		}
+		return "bool" in e ? {
+			get: (e) => !!t.getUint8(e),
+			set: (e, n) => t.setUint8(e, +!!n)
+		} : {
+			get: (t) => o(t, e.string),
+			set: (t, n) => c(t, e.string, n)
+		};
+	};
+	return {
+		ops: l,
+		compile: (e, t) => {
+			let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+			for (let i of Object.keys(e)) {
+				let { get: a, set: o } = l(e[i]), s = t[i];
+				n.set(i, (e, t) => {
+					t[i] = a(e + s);
+				}), r.set(i, (e, t) => o(e + s, t[i]));
+			}
+			let i = [...n.values()], a = [...r.values()];
+			return {
+				read(e, t = {}, r) {
+					if (r) for (let i of r) n.get(i)(e, t);
+					else for (let n of i) n(e, t);
+					return t;
+				},
+				write(e, t, n) {
+					if (n) for (let i of n) r.get(i)(e, t);
+					else for (let n of a) n(e, t);
+				}
+			};
+		}
+	};
+}
+var M = (e, t, n) => {
+	let { schema: r, byteLength: i, kind: a } = e, o = e;
+	if (o.layout && o.offsets && o.recordSize !== void 0) {
+		let e = new Uint32Array(t.buffer, n, 2), a = n + 8, s = j(t).compile(o.layout, o.offsets);
+		return {
+			byteOffset: n,
+			byteLength: i,
+			read: () => e[0] ? s.read(a, {}) : void 0,
+			write: (t) => {
+				s.write(a, r ? r.parse(t) : t), e[0] = 1;
+			}
+		};
+	}
+	if (o.element !== void 0 && o.elementStride !== void 0 && o.capacity !== void 0) {
+		let e = new Uint32Array(t.buffer, n, 1), a = new Uint32Array(t.buffer, n + 4, 1), s = j(t).ops(o.element), c = o.elementStride, l = o.capacity, u = n + 8;
+		return {
+			byteOffset: n,
+			byteLength: i,
+			read: () => {
+				if (!e[0]) return;
+				let t = a[0];
+				return Array.from({ length: t }, (e, t) => s.get(u + t * c));
+			},
+			write: (t) => {
+				let n = r ? r.parse(t) : t;
+				if (n.length > l) throw Error(`${n.length} elements exceeds array capacity of ${l}`);
+				n.forEach((e, t) => s.set(u + t * c, e)), a[0] = n.length, e[0] = 1;
+			}
+		};
+	}
+	let s = i - 4, c = new Uint32Array(t.buffer, n, 1), l = (e) => {
+		if (e.byteLength > s) throw Error(`Encoded value of ${e.byteLength} bytes exceeds field capacity of ${s} bytes at offset ${n}`);
+		c[0] = e.byteLength, new Uint8Array(t.buffer, n + 4, e.byteLength).set(e);
+	}, u = () => new Uint8Array(t.buffer, n + 4, c[0]).slice();
+	return {
+		byteOffset: n,
+		byteLength: i,
+		read: () => {
+			let e = u();
+			if (e.byteLength === 0) return;
+			let n = t.codec.decode(e);
+			return r ? r.parse(n) : n;
+		},
+		write: (e) => l(t.codec.encode(r ? r.parse(e) : e))
+	};
+};
+w("object", M), w("array", M);
+function N(e, t, n) {
+	let r = e, { offsets: i, recordSize: a, count: o } = r, l = j(t).compile(r.layout, i), u = (e) => {
+		if (e < 0 || e >= o) throw RangeError(`Record index ${e} out of bounds (0..${o - 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);
+	};
+	return {
+		byteOffset: n,
+		byteLength: e.byteLength,
+		recordCount: o,
+		recordSize: a,
+		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 && s() && c({
+					type: "memory:write",
+					path: t.path,
+					version: e + 1
+				});
+			}
+		},
+		read: () => Array.from({ length: o }, (e, t) => d(t)),
+		write: (e) => {
+			if (e.length > o) throw Error(`${e.length} records exceeds list array capacity of ${o}`);
+			e.forEach((e, t) => f(t, e));
+		}
+	};
+}
+w("list", N);
+var P = [];
+function F(e) {
+	let t = {};
+	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(e) {
+	if (e.schema) return e.schema;
+	switch (e.kind) {
+		case "number": return t(n.number());
+		case "boolean": return t(n.boolean());
+		case "string": return t(n.string());
+		case "Int32": return t(n.instanceof(Int32Array));
+		case "Float64": return t(n.instanceof(Float64Array));
+		case "BigInt64": return t(n.instanceof(BigInt64Array));
+		case "Uint8": return t(n.instanceof(Uint8Array));
+		default: return t(n.unknown());
+	}
+}
+var L = class {
+	totalBytes;
+	spec;
+	schemas;
+	codec;
+	plugins;
+	entries;
+	offsets = /* @__PURE__ */ new Map();
+	versionOffset;
+	connectors = /* @__PURE__ */ new Map();
+	boundListeners = /* @__PURE__ */ new Set();
+	isBound = !1;
+	boundBuffer;
+	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), ${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)}`])),
+			pluginOverrides: Object.keys(this.plugins ?? {})
+		});
+	}
+	bind(e) {
+		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 o = a(r, {
+				buffer: e,
+				codec: this.codec,
+				version: {
+					view: t,
+					index: i
+				},
+				path: n
+			}, this.offsets.get(n)), u = o.commit;
+			this.connectors.set(n, {
+				...o,
+				write: (e) => {
+					o.write(e);
+					let r = Atomics.add(t, i, 1);
+					Atomics.notify(t, i), s() && (c({
+						type: "memory:write",
+						path: n,
+						version: r + 1
+					}), d.size && l(this, n, r + 1));
+				},
+				...u && s() ? { commit: () => {
+					u(), d.size && l(this, n, Atomics.load(t, i));
+				} } : {},
+				_version: {
+					view: t,
+					index: i
+				},
+				_path: n
+			});
+		}), s() && (u(() => P), c({
+			type: "memory:bind",
+			fields: this.entries.map((e, t) => [t, e.path]),
+			totalBytes: this.totalBytes
+		})), this.isBound = !0, this.boundBuffer = e;
+		for (let e of [...this.boundListeners]) e();
+	}
+	get bound() {
+		return this.isBound;
+	}
+	get buffer() {
+		if (!this.boundBuffer) throw Error("Shared memory contract is not bound to a buffer on this thread.");
+		return this.boundBuffer;
+	}
+	fields() {
+		return this.entries.map(({ path: e, descriptor: t }) => ({
+			path: e,
+			byteOffset: this.offsets.get(e),
+			byteLength: t.byteLength
+		}));
+	}
+	onBound(e) {
+		return this.boundListeners.add(e), this.isBound && e(), () => this.boundListeners.delete(e);
+	}
+	connector(e) {
+		let t = String(e), n = this.connectors.get(t);
+		if (!n) throw Error(`Shared memory field "${t}" was accessed before the buffer was bound on this thread.`);
+		return n;
+	}
+};
+function R(e, t = {}) {
+	let n = new L(e, t);
+	for (let [t, r] of Object.entries(e)) if (v(r)) Object.defineProperty(n, t, {
+		enumerable: !0,
+		get: () => n.connector(t)
+	});
+	else {
+		let e = {};
+		for (let i of Object.keys(r)) Object.defineProperty(e, i, {
+			enumerable: !0,
+			get: () => n.connector(`${t}.${i}`)
+		});
+		Object.defineProperty(n, t, {
+			enumerable: !0,
+			get: () => e
+		});
+	}
+	return n;
+}
+function z(e) {
+	for (let t of P) t.bind(e);
+	m.info(`bound ${P.length} contract(s) — ${f(e.byteLength)} buffer`);
+}
+function B() {
+	return P.length;
+}
 //#endregion
-export { r as reef };
+export { L as SharedMemory, z as bindSharedMemories, R as defineSharedMemory, k as field, B as getDefinedSharedMemoryCount, S as jsonCodec, w as registerConnectorFactory };

package/dist/index9.js

@@ -1,35 +1,21 @@
-//#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
-		});
-	}
-	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}`);
-		}
-	}
-	getBuffer() {
-		return this.memory.buffer;
-	}
+import { fluent as e, z as t } from "./index3.js";
+//#region 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))),
+	i16: () => e(t.number().check(t.int(), t.gte(-32768), t.lte(32767))),
+	u16: () => e(t.number().check(t.int(), t.gte(0), t.lte(65535))),
+	i32: () => e(t.int32()),
+	u32: () => e(t.uint32()),
+	f32: () => e(t.float32()),
+	f64: () => e(t.float64()),
+	i64: () => e(t.int64()),
+	u64: () => e(t.uint64()),
+	int: (n, r) => e(t.number().check(t.int(), t.gte(n), t.lte(r))),
+	boolean: () => e(t.boolean()),
+	string: (r) => e(t.string().check(t.refine((e) => n.encode(e).byteLength <= r, `exceeds ${r} UTF-8 bytes`)).register(t.globalRegistry, { bytes: r })),
+	object: (n) => e(t.object(n)),
+	array: (n) => e(t.array(n))
 };
 //#endregion
-export { e as MemoryManager };
+export { r as reef };

package/dist/pool/dedicatedWorker.d.ts

@@ -0,0 +1,63 @@
+import type { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory.js';
+import type { MemoryPersistence, TaskContract, TaskMap, WorkerPoolConfig } from '../contract/types.js';
+import type { PoolStats, RunOptions } from './workerPool.js';
+/**
+ * Config for a single dedicated worker: the WorkerPool config minus the
+ * pool-only knobs (size, per-worker concurrency cap, queue bound, task
+ * methods). Every call posts straight to the worker.
+ */
+export type DedicatedWorkerConfig<S extends SharedSpec = SharedSpec> = Omit<WorkerPoolConfig<S, TaskMap>, 'poolSize' | 'concurrency' | 'maxQueue' | 'tasks'>;
+/**
+ * One worker, no pool: what `connectWorker({ workers: 1 })` (the default)
+ * builds. Calls are posted to the worker immediately, with no queue and no
+ * scheduler; the worker's own message loop runs them in arrival order (a
+ * task that awaits lets the next message start, exactly as in a pool slot
+ * with a raised concurrency cap). Kept from the pool: per-call
+ * timeout/abort, crash respawn, `stats()`, and the same devtools events,
+ * with `pool:init` flagged `dedicated: true`.
+ */
+export declare class DedicatedWorker<S extends SharedSpec = SharedSpec> {
+    /**
+     * Devtools correlation id: '<name>-w' when the config has a `name`, else
+     * 'worker-N'. The same role a pool's id plays.
+     */
+    readonly poolId: string;
+    readonly sharedMemory: (SharedMemory<S> & SharedAccess<S>) | undefined;
+    readonly persistence: MemoryPersistence | undefined;
+    private readonly mem;
+    private readonly spawn;
+    private readonly respawn;
+    private readonly taskTimeout?;
+    private readonly label?;
+    private worker;
+    private pending;
+    private nextMessageId;
+    private nextCallId;
+    private closed;
+    /** Dashboard fault injection (`pool.chaos`); null unless devtools set it. */
+    private chaos;
+    private devtoolsOff?;
+    private drainWaiters;
+    private statsAgg;
+    constructor(config: DedicatedWorkerConfig<S>);
+    private attach;
+    private detach;
+    private handleReply;
+    private handleError;
+    private rejectPending;
+    /** Abort/timeout: the caller rejects now; the worker's eventual reply is discarded. */
+    private cancel;
+    private checkDrained;
+    /** Post the call straight to the worker — no queue, no scheduler. */
+    dispatch<Args extends any[], Result>(contract: TaskContract<Args, Result>, args: Args, options?: RunOptions): Promise<Result>;
+    runTask<Args extends any[], Result>(contract: TaskContract<Args, Result>, ...args: Args): Promise<Result>;
+    /** The shared buffer handed to the worker via INIT_MEMORY; undefined when message-only. */
+    get sharedBuffer(): SharedArrayBuffer | undefined;
+    /** The worker, as a one-element snapshot (same shape as `WorkerPool.workers`). */
+    get workers(): readonly Worker[];
+    /** Same shape as `WorkerPool.stats()`; `queued` and `waitMs` stay zero (there is no queue). */
+    stats(): PoolStats;
+    /** Resolves once nothing is in flight, then terminates. */
+    close(): Promise<void>;
+    terminate(): void;
+}