@atolljs/core 0.1.4 → 0.1.5

package/dist/contract/listSchema.d.ts

@@ -1,5 +1,5 @@
-import { z, type Fluent } from './zod';
-import type { ListFieldSpec, ListFields, ListMember } from './sharedMemory';
+import { z, type Fluent } from './zod.js';
+import type { ListFieldSpec, ListFields, ListMember } from './sharedMemory.js';
 /** Maps a list member to the zod shape whose inferred output type is
  *  identical to `ListRecord<F>[K]` — zod members pass through as
  *  themselves so declared bounds (e.g. `.max(3)`) stay in effect. */

package/dist/contract/msgpackrCodec.d.ts

@@ -1,2 +1,2 @@
-import type { Codec } from './sharedMemory';
+import type { Codec } from './sharedMemory.js';
 export declare const msgpackrCodec: Codec;

package/dist/contract/reef.d.ts

@@ -1,4 +1,4 @@
-import { z } from './zod';
+import { z } from './zod.js';
 /**
  * Reef — the atoll's structural barrier: the fixed-width schema
  * vocabulary standing between your data and the raw buffer. Every helper
@@ -24,11 +24,11 @@ import { z } from './zod';
  * `_zod.def`, so `reef.object({ id: z.uint32() })` mixes freely.
  */
 export declare const reef: {
-    i8: () => import("./zod").Fluent<{
+    i8: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -41,14 +41,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
-    u8: () => import("./zod").Fluent<{
+    u8: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -61,14 +61,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    i16: () => import("./zod").Fluent<{
+    i16: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -81,14 +81,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    u16: () => import("./zod").Fluent<{
+    u16: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -101,14 +101,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    i32: () => import("./zod").Fluent<{
+    i32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -121,14 +121,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    u32: () => import("./zod").Fluent<{
+    u32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -141,14 +141,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    f32: () => import("./zod").Fluent<{
+    f32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -161,14 +161,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    f64: () => import("./zod").Fluent<{
+    f64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -181,14 +181,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    i64: () => import("./zod").Fluent<{
+    i64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: bigint;
             input: bigint;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'bigint';
             };
         };
@@ -201,14 +201,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
-    u64: () => import("./zod").Fluent<{
+    u64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: bigint;
             input: bigint;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'bigint';
             };
         };
@@ -221,15 +221,15 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
     /** Bounded int — compiles to the narrowest covering kind (0..3 → u8). */
-    int: (min: number, max: number) => import("./zod").Fluent<{
+    int: (min: number, max: number) => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -242,15 +242,15 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
     /** A flag byte — reads and writes as boolean. */
-    boolean: () => import("./zod").Fluent<{
+    boolean: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: boolean;
             input: boolean;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'boolean';
             };
         };
@@ -263,17 +263,17 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
     /** Fixed-capacity inline UTF-8 string — `bytes` is the byte budget. The
      *  schema itself refuses over-budget values, so `.parse` and connector
      *  writes enforce the same limit. */
-    string: (bytes: number) => import("./zod").Fluent<{
+    string: (bytes: number) => import("./zod.js").Fluent<{
         readonly _zod: {
             output: string;
             input: string;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'string';
             };
         };
@@ -286,11 +286,11 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
     /** A fixed-layout record shape — every member must be a fixed-width schema. */
-    object: <S extends z.ZodRawShape>(shape: S) => import("./zod").Fluent<{
+    object: <S extends z.ZodRawShape>(shape: S) => import("./zod.js").Fluent<{
         readonly _zod: {
             output: { [K in keyof S]: S[K] extends {
                 _zod: {
@@ -302,7 +302,7 @@ export declare const reef: {
                     output: infer O;
                 };
             } ? O : never; };
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'object';
                 shape: S;
             };
@@ -329,11 +329,11 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
     /** A fixed-stride element — bound it with `.max(n)` or `.length(n)` before field.array. */
-    array: <E extends z.ZodTypeAny>(element: E) => import("./zod").Fluent<{
+    array: <E extends z.ZodTypeAny>(element: E) => import("./zod.js").Fluent<{
         readonly _zod: {
             output: (E extends {
                 _zod: {
@@ -345,7 +345,7 @@ export declare const reef: {
                     output: infer O;
                 };
             } ? O : never)[];
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'array';
                 element: E;
             };
@@ -371,7 +371,7 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
 };

package/dist/contract/sharedMemory.d.ts

@@ -1,5 +1,5 @@
-import type { Prettify, Schema } from './types';
-import { z } from './zod';
+import type { Prettify, Schema } from './types.js';
+import { z } from './zod.js';
 /**
  * Declares the datatype of a single field in the shared memory contract.
  * `byteLength` is the fixed region reserved for the field; structured types

package/dist/contract/types.d.ts

@@ -1,4 +1,4 @@
-import type { SharedAccess, SharedMemory, SharedSpec } from './sharedMemory';
+import type { SharedAccess, SharedMemory, SharedSpec } from './sharedMemory.js';
 export type ViewType = 'Int32' | 'Float64' | 'BigInt64' | 'Uint8';
 /**
  * Minimal validation contract — compatible with zod schemas (`z.object(...)`)

package/dist/index.d.ts

@@ -1,29 +1,29 @@
-export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory';
-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 { msgpackrCodec } from './contract/msgpackrCodec';
-export { listSchema } from './contract/listSchema';
-export type { ListZodShape } from './contract/listSchema';
-export type { MemoryConfig, PoolTasks, Prettify, Schema, Logger, TaskContract, TaskMap, TaskMessage, TaskResult, MemoryPersistence, SharedWorkerConfig, ViewType, WorkerPoolConfig, } from './contract/types';
-export { MemoryManager } from './pool/memory';
-export { WorkerPool } from './pool/workerPool';
-export type { PoolStats, RunOptions } from './pool/workerPool';
-export { PoolQueueFullError, TaskAbortedError, TaskTimeoutError, WorkerCrashedError, } from './pool/errors';
-export { connectWorker, workerClient } from './pool/workerClient';
-export type { ClientMethods, ConnectWorkerConfig, WorkerClient, WorkerMethods, } from './pool/workerClient';
-export { connectSharedWorker } from './shared/sharedWorkerClient';
-export type { SharedWorkerClient } from './shared/sharedWorkerClient';
-export { sharedWorkerHost } from './shared/sharedWorkerHost';
-export { createClient, defineService, implementService, rpc, serviceMethod } from './service';
-export type { RpcMethodDef, RpcMethodInput, RpcMethodInputMap, RpcMethodMap, ServiceClient, ServiceContract, ServiceHandlers, ServiceImpl, ServiceMethod, TaskRunner, } from './service';
-export { TaskRegistry } from './worker/registry';
-export { defineWorker, RESERVED_CLIENT_KEYS } from './worker/defineWorker';
-export type { DefineWorkerConfig, WorkerDefinition, WorkerMethod, WorkerMethodMap, WorkerServiceMap, } from './worker/defineWorker';
-export { reactive, shallowEqual, watch } from './reactive';
-export type { EqualityFn, ReactiveConnector, SliceOptions } from './reactive';
-export { observe } from './observable';
-export type { ObservableValue } from './observable';
-export { defineTask, isAsyncTask, toTask } from './task';
-export type { AsyncTask, TaskSnapshot } from './task';
-export { getLogLevel, log, scoped, setLogLevel, setLogSink } from './log';
-export type { LogEntry, LogLevel, LogSink } from './log';
+export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory.js';
+export { reef } from './contract/reef.js';
+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.js';
+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 { MemoryManager } from './pool/memory.js';
+export { WorkerPool } from './pool/workerPool.js';
+export type { PoolStats, RunOptions } from './pool/workerPool.js';
+export { PoolQueueFullError, TaskAbortedError, TaskTimeoutError, WorkerCrashedError, } from './pool/errors.js';
+export { connectWorker, workerClient } from './pool/workerClient.js';
+export type { ClientMethods, ConnectWorkerConfig, WorkerClient, WorkerMethods, } from './pool/workerClient.js';
+export { connectSharedWorker } from './shared/sharedWorkerClient.js';
+export type { SharedWorkerClient } from './shared/sharedWorkerClient.js';
+export { sharedWorkerHost } from './shared/sharedWorkerHost.js';
+export { createClient, defineService, implementService, rpc, serviceMethod } from './service.js';
+export type { RpcMethodDef, RpcMethodInput, RpcMethodInputMap, RpcMethodMap, ServiceClient, ServiceContract, ServiceHandlers, ServiceImpl, ServiceMethod, TaskRunner, } from './service.js';
+export { TaskRegistry } from './worker/registry.js';
+export { defineWorker, RESERVED_CLIENT_KEYS } from './worker/defineWorker.js';
+export type { DefineWorkerConfig, WorkerDefinition, WorkerMethod, WorkerMethodMap, WorkerServiceMap, } from './worker/defineWorker.js';
+export { reactive, shallowEqual, watch } from './reactive.js';
+export type { EqualityFn, ReactiveConnector, SliceOptions } from './reactive.js';
+export { observe } from './observable.js';
+export type { ObservableValue } from './observable.js';
+export { defineTask, isAsyncTask, toTask } from './task.js';
+export type { AsyncTask, TaskSnapshot } from './task.js';
+export { getLogLevel, log, scoped, setLogLevel, setLogSink } from './log.js';
+export type { LogEntry, LogLevel, LogSink } from './log.js';

package/dist/index10.js

@@ -189,5 +189,3 @@ var s = t("pool"), c = t("task"), l = () => ({
 };
 //#endregion
 export { u as WorkerPool };
-
-//# sourceMappingURL=index10.js.map

package/dist/index11.js

@@ -48,5 +48,3 @@ function r(n) {
 }
 //#endregion
 export { r as connectWorker, n as workerClient };
-
-//# sourceMappingURL=index11.js.map

package/dist/index12.js

@@ -62,5 +62,3 @@ async function i(e) {
 }
 //#endregion
 export { i as connectSharedWorker };
-
-//# sourceMappingURL=index12.js.map

package/dist/index13.js

@@ -23,5 +23,3 @@ var t = e("registry"), n = class {
 };
 //#endregion
 export { n as TaskRegistry };
-
-//# sourceMappingURL=index13.js.map

package/dist/index14.js

@@ -59,5 +59,3 @@ function u() {
 }
 //#endregion
 export { l as attachSharedPort, u as sharedWorkerHost };
-
-//# sourceMappingURL=index14.js.map

package/dist/index15.js

@@ -46,5 +46,3 @@ function s(e, t) {
 }
 //#endregion
 export { s as createClient, a as defineService, o as implementService, r as rpc, i as serviceMethod };
-
-//# sourceMappingURL=index15.js.map

package/dist/index16.js

@@ -2,45 +2,53 @@ import { fmtBytes as e, scoped as t } from "./index5.js";
 import { bindSharedMemories as n, getDefinedSharedMemoryCount as r } from "./index6.js";
 import { TaskRegistry as i } from "./index13.js";
 //#region src/worker/workerBootstrap.ts
-var a = t("worker"), o = !1;
-typeof self > "u" ? a.warn("workerBootstrap: no worker global found — skipping message wiring") : self.onmessage = async (t) => {
-	let s = t.data;
-	if (s.type === "INIT") {
-		o = !0, r() > 0 && a.warn("pool sent INIT without memory, but shared-memory contracts are defined — field access will throw until bound"), a.info("initialized (message-only pool — no shared memory)");
-		return;
-	}
-	if (s.type === "INIT_MEMORY") {
-		let t = s.memory;
-		n(t.buffer), o = !0, a.info(`shared memory initialized (${e(t.buffer.byteLength)})`);
-		return;
-	}
-	if (s.type === "EXECUTE_TASK") {
-		let { messageId: e, taskId: t, args: n } = s;
-		if (!o) {
-			a.warn(`rejected ${t} — shared memory not initialized`), self.postMessage({
-				messageId: e,
-				success: !1,
-				error: "Shared memory not initialized in worker."
-			});
+var a = t("worker"), o = !1, s = !1;
+function c() {
+	if (!s) {
+		if (typeof self > "u") {
+			a.warn("workerBootstrap: no worker global found — skipping message wiring");
 			return;
 		}
-		let r = performance.now();
-		try {
-			let o = await i.execute(t, ...n || []);
-			a.debug(`task ${t} → ${(performance.now() - r).toFixed(1)}ms`), self.postMessage({
-				messageId: e,
-				success: !0,
-				result: o
-			});
-		} catch (n) {
-			a.warn(`task ${t} failed: ${n.message || String(n)}`), self.postMessage({
-				messageId: e,
-				success: !1,
-				error: n.message || String(n)
-			});
-		}
+		s = !0, self.onmessage = async (t) => {
+			let s = t.data;
+			if (s.type === "INIT") {
+				o = !0, r() > 0 && a.warn("pool sent INIT without memory, but shared-memory contracts are defined — field access will throw until bound"), a.info("initialized (message-only pool — no shared memory)");
+				return;
+			}
+			if (s.type === "INIT_MEMORY") {
+				let t = s.memory;
+				n(t.buffer), o = !0, a.info(`shared memory initialized (${e(t.buffer.byteLength)})`);
+				return;
+			}
+			if (s.type === "EXECUTE_TASK") {
+				let { messageId: e, taskId: t, args: n } = s;
+				if (!o) {
+					a.warn(`rejected ${t} — shared memory not initialized`), self.postMessage({
+						messageId: e,
+						success: !1,
+						error: "Shared memory not initialized in worker."
+					});
+					return;
+				}
+				let r = performance.now();
+				try {
+					let o = await i.execute(t, ...n || []);
+					a.debug(`task ${t} → ${(performance.now() - r).toFixed(1)}ms`), self.postMessage({
+						messageId: e,
+						success: !0,
+						result: o
+					});
+				} catch (n) {
+					a.warn(`task ${t} failed: ${n.message || String(n)}`), self.postMessage({
+						messageId: e,
+						success: !1,
+						error: n.message || String(n)
+					});
+				}
+			}
+		};
 	}
-};
+}
+c();
 //#endregion
-
-//# sourceMappingURL=index16.js.map
+export { c as installWorkerListener };

package/dist/index17.js

@@ -1,19 +1,20 @@
 import { scoped as e } from "./index5.js";
 import { TaskRegistry as t } from "./index13.js";
-import "./index16.js";
+import { installWorkerListener as n } from "./index16.js";
 //#region src/worker/defineWorker.ts
-var n = e("worker"), r = [
+var r = e("worker"), i = [
 	"start",
 	"terminate",
 	"pool",
 	"sharedMemory",
 	"then",
 	"with"
-], i = (e) => typeof e == "object" && !!e && "run" in e, a = new Set(r);
-function o(e) {
-	let r = e.methods ?? {}, o = e.services ?? {}, s = 0, c = (e, n, r, o) => {
-		if (a.has(n)) throw Error(`defineWorker: "${n}" is reserved for the client API — rename the method`);
-		if (i(r)) {
+], a = (e) => typeof e == "object" && !!e && "run" in e, o = new Set(i);
+function s(e) {
+	n();
+	let i = e.methods ?? {}, s = e.services ?? {}, c = 0, l = (e, n, r, i) => {
+		if (o.has(n)) throw Error(`defineWorker: "${n}" is reserved for the client API — rename the method`);
+		if (a(r)) {
 			let { def: n } = r;
 			t.register({
 				taskId: n.taskId ?? e,
@@ -21,22 +22,20 @@ function o(e) {
 				...n.argsSchema ? { argsSchema: n.argsSchema } : {},
 				...n.resultSchema ? { resultSchema: n.resultSchema } : {}
 			}, r.run.bind(r));
-		} else t.register({ taskId: e }, r.bind(o));
-		s++;
+		} else t.register({ taskId: e }, r.bind(i));
+		c++;
 	};
-	for (let [e, t] of Object.entries(r)) c(e, e, t, r);
-	for (let [e, t] of Object.entries(o)) {
-		if (a.has(e)) throw Error(`defineWorker: service name "${e}" is reserved for the client API — rename it`);
-		for (let [n, r] of Object.entries(t)) c(`${e}.${n}`, n, r, t);
+	for (let [e, t] of Object.entries(i)) l(e, e, t, i);
+	for (let [e, t] of Object.entries(s)) {
+		if (o.has(e)) throw Error(`defineWorker: service name "${e}" is reserved for the client API — rename it`);
+		for (let [n, r] of Object.entries(t)) l(`${e}.${n}`, n, r, t);
 	}
-	n.info(`worker defined — ${s} method(s)`);
-	let l = {
-		methods: r,
-		services: o
+	r.info(`worker defined — ${c} method(s)`);
+	let u = {
+		methods: i,
+		services: s
 	};
-	return e.sharedMemory && (l.sharedMemory = e.sharedMemory), l;
+	return e.sharedMemory && (u.sharedMemory = e.sharedMemory), u;
 }
 //#endregion
-export { r as RESERVED_CLIENT_KEYS, o as defineWorker };
-
-//# sourceMappingURL=index17.js.map
+export { i as RESERVED_CLIENT_KEYS, s as defineWorker };

package/dist/index18.js

@@ -57,5 +57,3 @@ function c(e, i, o, c) {
 }
 //#endregion
 export { s as reactive, o as shallowEqual, c as watch };
-
-//# sourceMappingURL=index18.js.map

package/dist/index19.js

@@ -52,5 +52,3 @@ function r(e, r, i, a) {
 }
 //#endregion
 export { r as observe };
-
-//# sourceMappingURL=index19.js.map

package/dist/index2.js

@@ -6,5 +6,3 @@ var t = new e({ useRecords: !0 }), n = {
 };
 //#endregion
 export { n as msgpackrCodec };
-
-//# sourceMappingURL=index2.js.map

package/dist/index20.js

@@ -55,5 +55,3 @@ function i(e) {
 }
 //#endregion
 export { n as defineTask, r as isAsyncTask, i as toTask };
-
-//# sourceMappingURL=index20.js.map

package/dist/index3.js

@@ -200,5 +200,3 @@ var U = {
 };
 //#endregion
 export { h as SchemaError, g as ZodType, H as fluent, m as globalRegistry, U as z };
-
-//# sourceMappingURL=index3.js.map

package/dist/index4.js

@@ -123,5 +123,3 @@ function v(e) {
 }
 //#endregion
 export { o as listSchema, m as memberToSpec, g as zodArrayInfo, h as zodObjectShape, v as zodStringBytes };
-
-//# sourceMappingURL=index4.js.map

package/dist/index5.js

@@ -36,5 +36,3 @@ function l(e) {
 var u = (e) => e >= 1 << 20 ? `${(e / (1 << 20)).toFixed(1)}MB` : e >= 1024 ? `${(e / 1024).toFixed(1)}KB` : `${e}B`;
 //#endregion
 export { u as fmtBytes, o as getLogLevel, c as log, l as scoped, a as setLogLevel, s as setLogSink };
-
-//# sourceMappingURL=index5.js.map

package/dist/index6.js

@@ -489,5 +489,3 @@ function F() {
 }
 //#endregion
 export { M as SharedMemory, P as bindSharedMemories, N as defineSharedMemory, w as field, F as getDefinedSharedMemoryCount, _ as jsonCodec, y as registerConnectorFactory };
-
-//# sourceMappingURL=index6.js.map

package/dist/index7.js

@@ -19,5 +19,3 @@ var n = new TextEncoder(), r = {
 };
 //#endregion
 export { r as reef };
-
-//# sourceMappingURL=index7.js.map

package/dist/index8.js

@@ -33,5 +33,3 @@ var e = class {
 };
 //#endregion
 export { e as MemoryManager };
-
-//# sourceMappingURL=index8.js.map

package/dist/index9.js

@@ -18,5 +18,3 @@ var e = class extends Error {
 };
 //#endregion
 export { e as PoolQueueFullError, t as TaskAbortedError, n as TaskTimeoutError, r as WorkerCrashedError };
-
-//# sourceMappingURL=index9.js.map

package/dist/observable.d.ts

@@ -1,5 +1,5 @@
-import type { Connector, PathConnector, SharedMemory, SharedSpec, SpecPath } from './contract/sharedMemory';
-import { type SliceOptions } from './reactive';
+import type { Connector, PathConnector, SharedMemory, SharedSpec, SpecPath } from './contract/sharedMemory.js';
+import { type SliceOptions } from './reactive.js';
 /**
  * A minimal subscribable snapshot — `get()` plus `subscribe()`. This is the
  * interface every framework binding adapts (useSyncExternalStore, refs,

package/dist/pool/memory.d.ts

@@ -1,4 +1,4 @@
-import { MemoryConfig, ViewType } from '../contract/types';
+import { MemoryConfig, ViewType } from '../contract/types.js';
 export declare class MemoryManager {
     memory: WebAssembly.Memory;
     private maxPages;

package/dist/pool/workerClient.d.ts

@@ -1,8 +1,8 @@
-import type { ServiceMethod, TaskRunner } from '../service';
-import type { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory';
-import type { MemoryConfig, Prettify } from '../contract/types';
-import { WorkerPool, type RunOptions } from './workerPool';
-import type { WorkerDefinition, WorkerMethodMap } from '../worker/defineWorker';
+import type { ServiceMethod, TaskRunner } from '../service.js';
+import type { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory.js';
+import type { MemoryConfig, Prettify } from '../contract/types.js';
+import { WorkerPool, type RunOptions } from './workerPool.js';
+import type { WorkerDefinition, WorkerMethodMap } from '../worker/defineWorker.js';
 /** Maps a worker method's declared type to its async client signature. */
 type Sig<F> = F extends ServiceMethod<infer A extends any[], infer R> ? (...args: A) => Promise<R> : F extends {
     run: (...args: infer A extends any[]) => infer R;
@@ -62,7 +62,7 @@ export type WorkerClient<W extends WorkerDefinition, S extends SharedSpec> = Wor
  * One-line worker hookup for the main thread — the WorkerPool boilerplate
  * (worker factory, shared memory, sizing) collapses into the client itself:
  *
- *   import type { IncidentsWorker } from './worker/incidents.worker';
+ *   import type { IncidentsWorker } from './worker/incidents.worker.js';
  *
  *   export const incidents = connectWorker<IncidentsWorker>({
  *     sharedMemory: incidentsMemory,

package/dist/pool/workerPool.d.ts

@@ -1,5 +1,5 @@
-import { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory';
-import { MemoryPersistence, PoolTasks, TaskContract, TaskMap, WorkerPoolConfig } from '../contract/types';
+import { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory.js';
+import { MemoryPersistence, PoolTasks, TaskContract, TaskMap, WorkerPoolConfig } from '../contract/types.js';
 /** Per-call dispatch controls. */
 export interface RunOptions {
     /**

package/dist/reactive.d.ts

@@ -1,4 +1,4 @@
-import { Connector } from './contract/sharedMemory';
+import { Connector } from './contract/sharedMemory.js';
 /** Emission control for slices — return `true` when `next` should be treated
  *  as unchanged (no emit). Defaults to `Object.is`. */
 export type EqualityFn<T> = (prev: T, next: T) => boolean;

package/dist/service.d.ts

@@ -1,4 +1,4 @@
-import type { Schema, TaskContract, ViewType } from './contract/types';
+import type { Schema, TaskContract, ViewType } from './contract/types.js';
 /**
  * One RPC method's declaration. Identical fields to {@link TaskContract}
  * except `taskId` is optional — when omitted the wire id is derived as

package/dist/shared/sharedWorkerClient.d.ts

@@ -1,5 +1,5 @@
-import { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory';
-import { PoolTasks, TaskContract, TaskMap, SharedWorkerConfig } from '../contract/types';
+import { SharedAccess, SharedMemory, SharedSpec } from '../contract/sharedMemory.js';
+import { PoolTasks, TaskContract, TaskMap, SharedWorkerConfig } from '../contract/types.js';
 declare class SharedWorkerClientImpl<S extends SharedSpec = SharedSpec> {
     readonly clientIndex: number;
     readonly sharedMemory: SharedMemory<S> & SharedAccess<S>;

package/dist/task.d.ts

@@ -1,4 +1,4 @@
-import type { ObservableValue } from './observable';
+import type { ObservableValue } from './observable.js';
 /**
  * Point-in-time state of an {@link AsyncTask}. Replaced wholesale on every
  * transition so `get()` stays stable for `useSyncExternalStore`-style

package/dist/testing/inProcessWorker.d.ts

@@ -0,0 +1,27 @@
+export declare class InProcessWorker {
+    url: URL;
+    options?: any;
+    static created: InProcessWorker[];
+    static handlerModules: Array<() => Promise<unknown>>;
+    executed: any[];
+    terminated: boolean;
+    private listeners;
+    private ready;
+    /** Module-load failure — a crashed worker never executes another task. */
+    private dead;
+    constructor(url: URL, options?: any);
+    postMessage(data: any): void;
+    /** Imports the registered handler modules — what a real worker's entry does at boot. */
+    private boot;
+    /** Module-load failure = a real worker's 'error' event. */
+    private crashOnBoot;
+    private handle;
+    private emit;
+    /** Simulates a worker crash: fires 'error' listeners like a real worker's error event. */
+    crash(message?: string): void;
+    addEventListener(type: string, l: (event: any) => void): void;
+    removeEventListener(type: string, l: (event: any) => void): void;
+    terminate(): void;
+}
+/** Flushes microtasks + the waitAsync observer loop after a shared write. */
+export declare const flushObservers: () => Promise<unknown>;

package/dist/worker/defineWorker.d.ts

@@ -1,6 +1,5 @@
-import './workerBootstrap';
-import type { ServiceMethod } from '../service';
-import type { SharedMemory, SharedSpec } from '../contract/sharedMemory';
+import type { ServiceMethod } from '../service.js';
+import type { SharedMemory, SharedSpec } from '../contract/sharedMemory.js';
 /**
  * One worker-exposed method: a plain function (siblings reachable via `this`)
  * or a {@link ServiceMethod} unit (`{ def, run }` — schemas enforced on the
@@ -38,7 +37,7 @@ export interface WorkerDefinition<S extends SharedSpec = SharedSpec, M extends W
 export declare const RESERVED_CLIENT_KEYS: readonly ['start', 'terminate', 'pool', 'sharedMemory', 'then', 'with'];
 /**
  * The worker-side half of the tRPC-style pair: the worker script owns the
- * runtime (importing this module wires `self.onmessage` via workerBootstrap)
+ * runtime (calling this wires `self.onmessage` via workerBootstrap)
  * and the method list — the main thread imports only `typeof` the returned
  * definition and drives it through a {@link connectWorker} Proxy client.
  *

package/dist/worker/registry.d.ts

@@ -1,4 +1,4 @@
-import { TaskContract } from '../contract/types';
+import { TaskContract } from '../contract/types.js';
 export type TaskHandler<Args extends any[] = any[], Result = any> = (...args: Args) => Result | Promise<Result>;
 export declare class TaskRegistry {
     private static tasks;

package/dist/worker/workerBootstrap.d.ts

@@ -1 +1,9 @@
-export {};
+/**
+ * Wire `self.onmessage` to the pool protocol (INIT / INIT_MEMORY /
+ * EXECUTE_TASK). Runs automatically on import for the public
+ * `import '@atolljs/core/worker/workerBootstrap'` entry, and is also called
+ * from `defineWorker()` — an explicit call survives bundler tree-shaking,
+ * unlike a bare side-effect import whose `sideEffects` glob can miss
+ * renamed dist chunks. Idempotent: safe on repeated defineWorker() calls.
+ */
+export declare function installWorkerListener(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolljs/core",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Typed shared-memory worker pools — defineWorker/connectWorker, SharedArrayBuffer contracts, cross-thread reactivity",
   "homepage": "https://jwhenry3.github.io/atolljs/consumer/quickstart/",
   "type": "module",
@@ -12,7 +12,10 @@
       "import": "./dist/index.js"
     },
     "./package.json": "./package.json",
-    "./*": "./src/*"
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./src/*"
+    }
   },
   "files": [
     "dist",
@@ -29,7 +32,7 @@
     "kill:all": "node scripts/kill-all.mjs",
     "atoll": "node packages/cli/src/cli.ts",
     "serve:all": "node scripts/serve-all.mjs",
-    "build": "tsc --noEmit && vite build",
+    "build": "tsc --noEmit && vite build && node scripts/core-dts.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "stats": "node scripts/bundle-stats.mjs",

package/src/worker/defineWorker.ts

@@ -1,4 +1,4 @@
-import './workerBootstrap'; // side-effect: wires self.onmessage (guarded for main-thread import)
+import { installWorkerListener } from './workerBootstrap';
 import { TaskRegistry } from './registry';
 import { scoped } from '../log';
 import type { ServiceMethod } from '../service';
@@ -62,7 +62,7 @@ const RESERVED = new Set<string>(RESERVED_CLIENT_KEYS);
 
 /**
  * The worker-side half of the tRPC-style pair: the worker script owns the
- * runtime (importing this module wires `self.onmessage` via workerBootstrap)
+ * runtime (calling this wires `self.onmessage` via workerBootstrap)
  * and the method list — the main thread imports only `typeof` the returned
  * definition and drives it through a {@link connectWorker} Proxy client.
  *
@@ -88,6 +88,10 @@ export function defineWorker<
   M extends WorkerMethodMap = {},
   Svc extends WorkerServiceMap = {},
 >(config: DefineWorkerConfig<S, M, Svc>): WorkerDefinition<S, M, Svc> {
+  // Called (not a bare import) so the wiring survives bundler tree-shaking —
+  // a `sideEffects` glob can't match renamed dist chunks (index16.js), which
+  // is how vite's dep-optimizer used to drop the entire message pump.
+  installWorkerListener();
   const methods = (config.methods ?? {}) as M;
   const services = (config.services ?? {}) as Svc;
 

package/src/worker/workerBootstrap.ts

@@ -5,52 +5,68 @@ import { fmtBytes, scoped } from '../log';
 const workerLog = scoped('worker');
 
 let memoryInitialized = false;
+let wired = false;
 
-if (typeof self === 'undefined') {
-  // Imported outside a worker context (e.g. a Nest entry that shares the
-  // atoll-nestjs barrel with the worker entry) — nothing to wire.
-  workerLog.warn('workerBootstrap: no worker global found — skipping message wiring');
-} else {
-  self.onmessage = async (event) => {
-  const data = event.data;
-
-  if (data.type === 'INIT') {
-    memoryInitialized = true;
-    if (getDefinedSharedMemoryCount() > 0) {
-      workerLog.warn(
-        'pool sent INIT without memory, but shared-memory contracts are defined — field access will throw until bound',
-      );
-    }
-    workerLog.info('initialized (message-only pool — no shared memory)');
-    return;
-  }
-
-  if (data.type === 'INIT_MEMORY') {
-    const memory = data.memory as WebAssembly.Memory;
-    bindSharedMemories(memory.buffer as unknown as SharedArrayBuffer);
-    memoryInitialized = true;
-    workerLog.info(`shared memory initialized (${fmtBytes(memory.buffer.byteLength)})`);
+/**
+ * Wire `self.onmessage` to the pool protocol (INIT / INIT_MEMORY /
+ * EXECUTE_TASK). Runs automatically on import for the public
+ * `import '@atolljs/core/worker/workerBootstrap'` entry, and is also called
+ * from `defineWorker()` — an explicit call survives bundler tree-shaking,
+ * unlike a bare side-effect import whose `sideEffects` glob can miss
+ * renamed dist chunks. Idempotent: safe on repeated defineWorker() calls.
+ */
+export function installWorkerListener(): void {
+  if (wired) return;
+  if (typeof self === 'undefined') {
+    // Imported outside a worker context (e.g. a Nest entry that shares the
+    // atoll-nestjs barrel with the worker entry) — nothing to wire.
+    workerLog.warn('workerBootstrap: no worker global found — skipping message wiring');
     return;
   }
+  wired = true;
 
-  if (data.type === 'EXECUTE_TASK') {
-    const { messageId, taskId, args } = data;
+  self.onmessage = async (event) => {
+    const data = event.data;
 
-    if (!memoryInitialized) {
-      workerLog.warn(`rejected ${taskId} — shared memory not initialized`);
-      self.postMessage({ messageId, success: false, error: 'Shared memory not initialized in worker.' });
+    if (data.type === 'INIT') {
+      memoryInitialized = true;
+      if (getDefinedSharedMemoryCount() > 0) {
+        workerLog.warn(
+          'pool sent INIT without memory, but shared-memory contracts are defined — field access will throw until bound',
+        );
+      }
+      workerLog.info('initialized (message-only pool — no shared memory)');
       return;
     }
 
-    const t0 = performance.now();
-    try {
-      const result = await TaskRegistry.execute(taskId, ...(args || []));
-      workerLog.debug(`task ${taskId} → ${(performance.now() - t0).toFixed(1)}ms`);
-      self.postMessage({ messageId, success: true, result });
-    } catch (err: any) {
-      workerLog.warn(`task ${taskId} failed: ${err.message || String(err)}`);
-      self.postMessage({ messageId, success: false, error: err.message || String(err) });
+    if (data.type === 'INIT_MEMORY') {
+      const memory = data.memory as WebAssembly.Memory;
+      bindSharedMemories(memory.buffer as unknown as SharedArrayBuffer);
+      memoryInitialized = true;
+      workerLog.info(`shared memory initialized (${fmtBytes(memory.buffer.byteLength)})`);
+      return;
     }
+
+    if (data.type === 'EXECUTE_TASK') {
+      const { messageId, taskId, args } = data;
+
+      if (!memoryInitialized) {
+        workerLog.warn(`rejected ${taskId} — shared memory not initialized`);
+        self.postMessage({ messageId, success: false, error: 'Shared memory not initialized in worker.' });
+        return;
+      }
+
+      const t0 = performance.now();
+      try {
+        const result = await TaskRegistry.execute(taskId, ...(args || []));
+        workerLog.debug(`task ${taskId} → ${(performance.now() - t0).toFixed(1)}ms`);
+        self.postMessage({ messageId, success: true, result });
+      } catch (err: any) {
+        workerLog.warn(`task ${taskId} failed: ${err.message || String(err)}`);
+        self.postMessage({ messageId, success: false, error: err.message || String(err) });
+      }
     }
   };
 }
+
+installWorkerListener();