@atolljs/core 0.1.1 → 0.1.3

package/dist/contract/zod.d.ts

@@ -1,28 +1,218 @@
 /**
- * The SDK's vendored zod surface — everything the contract layer needs,
- * narrowed.
+ * The SDK's vendored schema engine — the slice of zod v4 the contract layer
+ * needs, implemented in-house so zod never lands in the dependency tree.
  *
- * `import { z } from 'zod'` bundles the ENTIRE classic namespace in consumer
- * builds (~440KB minified): the `z` object can't be property-shaken, so it
- * drags in every locale, the JSON-schema processors, and the compile
- * pipeline. Named imports tree-shake (~93KB for the full set below).
+ * Schemas carry zod's `_zod.def` shape (`type`, `format`, `checks`,
+ * `shape`, `element`) and check defs use zod's names (`greater_than`,
+ * `number_format`, `max_length`, `length_equals`, …). The layout compiler
+ * reads those fields duck-typed — never `instanceof` — so consumer-supplied
+ * classic zod and zod/mini schemas introspect identically: `z.uint32()`,
+ * `z.object(...)`, `z.string().meta({ bytes: n })` all still work as
+ * members/field schemas.
  *
- * `instanceof` guards use the `$Zod*` base classes from `zod/v4/core` —
- * classic AND mini schemas both extend them, so user-supplied schemas match
- * either way. Constructors stay classic (`zod` named imports) because `mz`
- * output and `memory.schemas` are documented as ordinary zod — `.meta()`,
- * `.refine()`, `.parse()` must all work and compose with the consumer's own
- * `z.object(...)`.
+ * Chain methods mini omits (`.refine()`, `.meta()`, `.max()` …) are
+ * re-attached to atoll-minted schemas by `fluent()` — `reef`, `listSchema`,
+ * `memory.schemas`. Refines attach via `.check()` so the schema's
+ * `def.type` survives — a refined `reef.string` still lays out as a
+ * fixed-width string.
  */
-import { array, bigint, boolean, instanceof as instanceof_, int32, int64, float32, float64, number, object, string, uint32, uint64, unknown as unknown_ } from 'zod';
-import { $ZodArray, $ZodObject, $ZodString, $ZodType } from 'zod/v4/core';
-import type * as zod from 'zod';
+/** Check def payloads mirror zod v4's `_zod.check.def` shapes. */
+export interface CheckDef {
+    check: string;
+    value?: number | bigint;
+    inclusive?: boolean;
+    format?: string;
+    maximum?: number;
+    minimum?: number;
+    length?: number;
+}
+export interface Check {
+    readonly _zod: {
+        readonly def: CheckDef;
+    };
+    /** Returns `true` or a failure message. */
+    evaluate(value: unknown): true | string;
+}
+declare const int: () => Check;
+declare const gte: (value: number | bigint) => Check;
+declare const lte: (value: number | bigint) => Check;
+declare const nonnegative: () => Check;
+declare const refine: (fn: (v: any) => unknown, message?: string) => Check;
+declare const length: (n: number) => Check;
+declare const maxLength: (n: number) => Check;
+declare const minLength: (n: number) => Check;
+export declare const globalRegistry: {
+    add(schema: object, meta: Record<string, unknown>): void;
+    get(schema: object): Record<string, unknown> | undefined;
+};
+export type Registry = typeof globalRegistry;
+export interface SchemaDef {
+    type: string;
+    checks?: Check[];
+    format?: string;
+    shape?: Record<string, ZodLike>;
+    element?: ZodLike;
+    cls?: abstract new (...args: any[]) => unknown;
+}
+export declare class SchemaError extends Error {
+    readonly name = "SchemaError";
+}
+/** The minimal schema shape — satisfied by ours and by real zod schemas. */
+export interface ZodLike<Output = unknown, Input = Output> {
+    readonly _zod: {
+        readonly output: Output;
+        readonly input: Input;
+        readonly def: {
+            readonly type?: string;
+            readonly checks?: readonly unknown[];
+        };
+    };
+    parse(value: unknown): Output;
+    safeParse(value: unknown): {
+        success: true;
+        data: Output;
+    } | {
+        success: false;
+        error: unknown;
+    };
+}
+export declare abstract class ZodType<Output = unknown, Input = Output> implements ZodLike<Output, Input> {
+    readonly _zod: {
+        output: Output;
+        input: Input;
+        def: SchemaDef;
+    };
+    constructor(def: SchemaDef);
+    /** Base-kind check — subclasses enforce the primitive before checks run. */
+    abstract inner(value: unknown): Output;
+    parse(value: unknown): Output;
+    safeParse(value: unknown): {
+        success: true;
+        data: Output;
+    } | {
+        success: false;
+        error: unknown;
+    };
+    /** Returns a new schema with the checks appended (def.type unchanged). */
+    check(...checks: Check[]): this;
+    register(registry: Registry, meta: Record<string, unknown>): this;
+}
+declare class ZodNumber extends ZodType<number> {
+    readonly _zod: {
+        output: number;
+        input: number;
+        def: SchemaDef & {
+            type: 'number';
+        };
+    };
+    inner(v: unknown): number;
+}
+declare class ZodString extends ZodType<string> {
+    readonly _zod: {
+        output: string;
+        input: string;
+        def: SchemaDef & {
+            type: 'string';
+        };
+    };
+    inner(v: unknown): string;
+}
+declare class ZodBoolean extends ZodType<boolean> {
+    readonly _zod: {
+        output: boolean;
+        input: boolean;
+        def: SchemaDef & {
+            type: 'boolean';
+        };
+    };
+    inner(v: unknown): boolean;
+}
+declare class ZodBigint extends ZodType<bigint> {
+    readonly _zod: {
+        output: bigint;
+        input: bigint;
+        def: SchemaDef & {
+            type: 'bigint';
+        };
+    };
+    inner(v: unknown): bigint;
+}
+declare class ZodUnknown extends ZodType<unknown> {
+    inner(v: unknown): unknown;
+}
+declare class ZodInstanceof<T> extends ZodType<T> {
+    inner(v: unknown): T;
+}
+type ShapeOutput<S extends Record<string, ZodLike>> = {
+    [K in keyof S]: S[K] extends {
+        _zod: {
+            output: infer O;
+        };
+    } ? O : never;
+};
+/** Strips unknown keys like zod's object parse — output is the shape only. */
+declare class ZodObjectSchema<S extends Record<string, ZodLike>> extends ZodType<ShapeOutput<S>> {
+    readonly _zod: {
+        output: ShapeOutput<S>;
+        input: ShapeOutput<S>;
+        def: SchemaDef & {
+            type: 'object';
+            shape: S;
+        };
+    };
+    get shape(): S;
+    inner(v: unknown): ShapeOutput<S>;
+}
+declare class ZodArraySchema<E extends ZodLike> extends ZodType<OutputOf<E>[]> {
+    readonly _zod: {
+        output: OutputOf<E>[];
+        input: OutputOf<E>[];
+        def: SchemaDef & {
+            type: 'array';
+            element: E;
+        };
+    };
+    inner(v: unknown): OutputOf<E>[];
+}
+type OutputOf<S> = S extends {
+    _zod: {
+        output: infer O;
+    };
+} ? O : never;
+declare const number: () => ZodNumber;
+declare const string: () => ZodString;
+declare const boolean_: () => ZodBoolean;
+declare const bigint_: () => ZodBigint;
+declare const unknown_: () => ZodUnknown;
+declare const instanceof_: <T extends abstract new (...args: any[]) => any>(cls: T) => ZodInstanceof<InstanceType<T>>;
+declare const object_: <S extends Record<string, ZodLike>>(shape: S) => ZodObjectSchema<S>;
+declare const array: <E extends ZodLike>(element: E) => ZodArraySchema<E>;
+declare const int32: () => ZodNumber;
+declare const uint32: () => ZodNumber;
+declare const float32: () => ZodNumber;
+declare const float64: () => ZodNumber;
+declare const int64: () => ZodBigint;
+declare const uint64: () => ZodBigint;
+/** The chainable spellings re-added to atoll-minted schemas. */
+export type Fluent<S extends ZodLike> = S & {
+    /** Custom check via `.check()` — keeps `def.type`, unlike a wrapping refine. */
+    refine(fn: (value: S['_zod']['output']) => unknown, params?: string): Fluent<S>;
+    /** `meta()` reads, `meta(m)` writes — backed by the module registry. */
+    meta(): Record<string, unknown> | undefined;
+    meta(m: Record<string, unknown>): Fluent<S>;
+    min(value: number | bigint): Fluent<S>;
+    max(value: number | bigint): Fluent<S>;
+    length(n: number): Fluent<S>;
+    int(): Fluent<S>;
+};
+/** Attaches the `Fluent` methods as non-enumerable own properties. */
+export declare function fluent<S extends ZodType>(schema: S): Fluent<S>;
 export declare const z: {
     number: typeof number;
     string: typeof string;
-    boolean: typeof boolean;
-    bigint: typeof bigint;
-    object: typeof object;
+    boolean: typeof boolean_;
+    bigint: typeof bigint_;
+    object: typeof object_;
     array: typeof array;
     instanceof: typeof instanceof_;
     unknown: typeof unknown_;
@@ -32,22 +222,61 @@ export declare const z: {
     float64: typeof float64;
     int64: typeof int64;
     uint64: typeof uint64;
-    /** Core classes — instanceof-matching for user schemas (classic or mini). */
-    ZodType: zod.core.$constructor<$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>, zod.core.$ZodTypeDef>;
-    ZodObject: zod.core.$constructor<$ZodObject<Readonly<Readonly<{
-        [k: string]: $ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>;
-    }>>, zod.core.$ZodObjectConfig>, zod.core.$ZodObjectDef<Readonly<Readonly<{
-        [k: string]: $ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>;
-    }>>>>;
-    ZodArray: zod.core.$constructor<$ZodArray<$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>, zod.core.$ZodArrayDef<$ZodType<unknown, unknown, zod.core.$ZodTypeInternals<unknown, unknown>>>>;
-    ZodString: zod.core.$constructor<$ZodString<unknown>, zod.core.$ZodStringDef>;
+    int: typeof int;
+    gte: typeof gte;
+    lte: typeof lte;
+    nonnegative: typeof nonnegative;
+    refine: typeof refine;
+    length: typeof length;
+    maxLength: typeof maxLength;
+    minLength: typeof minLength;
+    globalRegistry: {
+        add(schema: object, meta: Record<string, unknown>): void;
+        get(schema: object): Record<string, unknown> | undefined;
+    };
+    /** Base classes — `instanceof` covers atoll-minted schemas. */
+    ZodType: typeof ZodType;
+    ZodObject: typeof ZodObjectSchema;
+    ZodArray: typeof ZodArraySchema;
+    ZodString: typeof ZodString;
 };
 export declare namespace z {
-    type ZodTypeAny = zod.ZodTypeAny;
-    type ZodType<Output = unknown, Input = unknown> = zod.ZodType<Output, Input>;
-    type ZodString = zod.ZodString;
-    type ZodArray<T extends zod.ZodTypeAny = zod.ZodTypeAny> = zod.ZodArray<T>;
-    type ZodObject<S extends zod.ZodRawShape = zod.ZodRawShape> = zod.ZodObject<S>;
-    type ZodRawShape = zod.ZodRawShape;
-    type output<T extends zod.ZodTypeAny> = zod.output<T>;
+    type ZodTypeAny = ZodLike;
+    type ZodType<Output = unknown, Input = unknown> = ZodLike<Output, Input>;
+    type ZodRawShape = Record<string, ZodLike>;
+    interface ZodObject<S extends ZodRawShape = ZodRawShape> extends ZodLike<ShapeOutput<S>, ShapeOutput<S>> {
+        readonly _zod: {
+            output: ShapeOutput<S>;
+            input: ShapeOutput<S>;
+            def: {
+                type: 'object';
+                shape: S;
+                checks?: readonly unknown[];
+            };
+        };
+    }
+    interface ZodArray<E extends ZodTypeAny = ZodTypeAny> extends ZodLike<OutputOf<E>[]> {
+        readonly _zod: {
+            output: OutputOf<E>[];
+            input: OutputOf<E>[];
+            def: {
+                type: 'array';
+                element: E;
+                checks?: readonly unknown[];
+            };
+        };
+    }
+    interface ZodString extends ZodLike<string> {
+        readonly _zod: {
+            output: string;
+            input: string;
+            def: {
+                type: 'string';
+                checks?: readonly unknown[];
+            };
+        };
+    }
+    type ZodMiniObject<S extends ZodRawShape = ZodRawShape> = ZodObject<S>;
+    type output<T extends ZodTypeAny> = OutputOf<T>;
 }
+export {};

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory';
-export { mz } from './contract/mz';
+export { reef } from './contract/reef';
 export type { Codec, Connector, ConnectorContext, ConnectorFactory, FieldDescriptor, FieldGroup, FieldSchema, FixedArrayDescriptor, FixedObjectDescriptor, FlatKey, InferField, PathConnector, SpecPath, SpecSchemas, SharedAccess, SharedMemory, SharedMemoryOptions, SharedSpec, ScalarKind, ListConnector, ListDescriptor, ListFieldSpec, ListFields, ListMember, ListRecord, ListSpec, } from './contract/sharedMemory';
-export { msgpackCodec } from './contract/msgpackCodec';
 export { msgpackrCodec } from './contract/msgpackrCodec';
 export { listSchema } from './contract/listSchema';
 export type { ListZodShape } from './contract/listSchema';

package/dist/index.js

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

package/dist/index10.js

@@ -1,22 +1,193 @@
-//#region src/pool/errors.ts
-var e = class extends Error {
-	constructor(e = "WorkerPool task queue is full") {
-		super(e), this.name = "PoolQueueFullError";
+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);
 	}
-}, t = class extends Error {
-	constructor(e = "task aborted") {
-		super(e), this.name = "AbortError";
+}), 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(", ")}`);
 	}
-}, n = class extends Error {
-	constructor(e = "task timed out") {
-		super(e), this.name = "TaskTimeoutError";
+	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;
 	}
-}, r = class extends Error {
-	constructor(e = "worker crashed") {
-		super(e), this.name = "WorkerCrashedError";
+	handleReply(e, t) {
+		let n = t.messageId === void 0 ? void 0 : this.pending.get(t.messageId);
+		n && (this.pending.delete(t.messageId), e.inFlight--, this.detach(n), n.done || (n.done = !0, this.statsAgg.runMs.add(performance.now() - (n.sentAt ?? n.enqueuedAt)), t.success ? (this.statsAgg.completed++, c.debug(`← ${n.contract.taskId} ok`), n.resolve(t.result)) : (this.statsAgg.failed++, c.warn(`← ${n.contract.taskId} failed: ${t.error}`), n.reject(Error(t.error)))), this.drainQueue(), this.checkDrained());
+	}
+	handleWorkerError(e, t) {
+		if (this.closed) return;
+		let n = t, r = n?.message ?? (n?.error ? String(n.error) : "worker error");
+		s.warn(`worker error: ${r}`);
+		for (let [t, n] of [...this.pending]) if (n.slot === e) {
+			if (this.pending.delete(t), this.detach(n), n.done) continue;
+			n.done = !0, this.statsAgg.failed++, n.reject(new o(r));
+		}
+		let i = this.slots.indexOf(e);
+		if (i >= 0 && this.slots.splice(i, 1), e.worker.terminate(), this.respawn) s.info("respawning crashed worker"), this.addWorker(this.spawn());
+		else if (this.slots.length === 0) for (let e of this.queue.splice(0)) e.done = !0, this.detach(e), this.statsAgg.failed++, e.reject(new o(r));
+		this.drainQueue(), this.checkDrained();
+	}
+	pickWorker() {
+		let e;
+		for (let t of this.slots) t.inFlight >= this.concurrency || (!e || t.inFlight < e.inFlight) && (e = t);
+		return e;
+	}
+	drainQueue() {
+		let e;
+		for (; this.queue.length > 0 && (e = this.pickWorker());) {
+			let t = this.queue.shift();
+			t.done || this.send(e, t);
+		}
+	}
+	send(e, t) {
+		let n = this.nextMessageId++;
+		t.messageId = n, t.slot = e, t.sentAt = performance.now(), this.statsAgg.waitMs.add(performance.now() - t.enqueuedAt), e.inFlight++, this.pending.set(n, t), c.debug(`→ ${t.contract.taskId}`, {
+			worker: this.slots.indexOf(e),
+			args: t.args
+		}), e.worker.postMessage({
+			type: "EXECUTE_TASK",
+			messageId: n,
+			taskId: t.contract.taskId,
+			args: t.args
+		});
+	}
+	detach(e) {
+		e.timer && clearTimeout(e.timer), e.signal && e.onSignalAbort && e.signal.removeEventListener("abort", e.onSignalAbort);
+	}
+	cancel(e, t) {
+		if (e.done) return;
+		let n = this.queue.indexOf(e);
+		n >= 0 && this.queue.splice(n, 1), e.done = !0, this.detach(e), this.statsAgg.aborted++, e.reject(t), this.drainQueue(), this.checkDrained();
+	}
+	checkDrained() {
+		if (this.queue.length === 0 && this.pending.size === 0) {
+			let e = this.drainWaiters.splice(0);
+			for (let t of e) t();
+		}
+	}
+	dispatch(e, t, n) {
+		return this.closed || this.slots.length === 0 ? Promise.reject(new o("WorkerPool has been terminated — no workers available.")) : n?.signal?.aborted ? Promise.reject(new i()) : new Promise((o, s) => {
+			let c = {
+				contract: e,
+				args: t,
+				enqueuedAt: performance.now(),
+				resolve: o,
+				reject: s,
+				done: !1,
+				signal: n?.signal
+			};
+			n?.signal && (c.onSignalAbort = () => this.cancel(c, new i()), n.signal.addEventListener("abort", c.onSignalAbort, { once: !0 }));
+			let l = n?.timeout ?? this.taskTimeout;
+			l !== void 0 && (c.timer = setTimeout(() => this.cancel(c, new a()), l));
+			let u = this.pickWorker();
+			if (u) this.send(u, c);
+			else if (this.queue.length >= this.maxQueue) {
+				c.done = !0, this.detach(c), s(new r());
+				return;
+			} else this.queue.push(c);
+		});
+	}
+	runTask(e, ...t) {
+		return this.dispatch(e, t);
+	}
+	get sharedBuffer() {
+		return this.memoryManager?.getBuffer();
+	}
+	get workers() {
+		return this.slots.map((e) => e.worker);
+	}
+	stats() {
+		return {
+			workers: this.slots.length,
+			idle: this.slots.filter((e) => e.inFlight === 0).length,
+			inFlight: this.pending.size,
+			queued: this.queue.length,
+			completed: this.statsAgg.completed,
+			failed: this.statsAgg.failed,
+			aborted: this.statsAgg.aborted,
+			waitMs: {
+				count: this.statsAgg.waitMs.count,
+				mean: this.statsAgg.waitMs.mean,
+				max: this.statsAgg.waitMs.max
+			},
+			runMs: {
+				count: this.statsAgg.runMs.count,
+				mean: this.statsAgg.runMs.mean,
+				max: this.statsAgg.runMs.max
+			}
+		};
+	}
+	close() {
+		return this.queue.length === 0 && this.pending.size === 0 ? (this.terminate(), Promise.resolve()) : new Promise((e) => {
+			this.drainWaiters.push(() => {
+				this.terminate(), e();
+			});
+		});
+	}
+	terminate() {
+		this.closed = !0, this.persistence?.stop()?.catch?.((e) => s.warn("memory persistence stop failed", e)), s.info(`terminating ${this.slots.length} worker(s)`);
+		let e = new o("pool terminated");
+		for (let [, t] of this.pending) this.detach(t), !t.done && (t.done = !0, this.statsAgg.failed++, t.reject(e));
+		this.pending.clear();
+		for (let t of this.queue.splice(0)) t.done = !0, this.detach(t), this.statsAgg.failed++, t.reject(e);
+		for (let e of this.slots) e.worker.terminate();
+		this.slots = [], this.checkDrained();
 	}
 };
 //#endregion
-export { e as PoolQueueFullError, t as TaskAbortedError, n as TaskTimeoutError, r as WorkerCrashedError };
+export { u as WorkerPool };
 
 //# sourceMappingURL=index10.js.map