@atolljs/core 0.1.0 → 0.1.1

package/dist/contract/sharedMemory.d.ts

@@ -0,0 +1,350 @@
+import type { Prettify, Schema } from './types';
+import { z } from './zod';
+/**
+ * Declares the datatype of a single field in the shared memory contract.
+ * `byteLength` is the fixed region reserved for the field; structured types
+ * (string, object, array) carry a 4-byte length header inside that region.
+ */
+export interface FieldDescriptor<T = unknown> {
+    readonly kind: string;
+    readonly byteLength: number;
+    readonly schema?: Schema<T>;
+    readonly __fieldType?: T;
+}
+/**
+ * A group of fields under one intent — any plain-object member of the spec
+ * that isn't a descriptor. Group names are the user's vocabulary:
+ * `lists`, `state`, `signals`, `telemetry` — one level deep.
+ */
+export type FieldGroup = Record<string, FieldDescriptor>;
+export type SharedSpec = Record<string, FieldDescriptor | FieldGroup>;
+/** Spec keys that hold a descriptor directly (not an intent group). */
+export type FlatKey<S extends SharedSpec> = {
+    [K in keyof S]: S[K] extends FieldDescriptor ? K : never;
+}[keyof S];
+/**
+ * Every legal field path of a spec — flat fields give their key (`metrics`),
+ * grouped fields give `group.field` (`signals.seedProgress`).
+ */
+export type SpecPath<S extends SharedSpec> = {
+    [K in keyof S & string]: S[K] extends FieldGroup ? `${K}.${keyof S[K] & string}` : K;
+}[keyof S & string];
+/**
+ * Serializer for structured (object/array) fields. Both threads must use the
+ * same codec — it comes from the shared contract definition, so it does.
+ */
+export interface Codec {
+    encode(value: unknown): Uint8Array;
+    decode(data: Uint8Array): unknown;
+}
+export declare const jsonCodec: Codec;
+/**
+ * Context handed to connector factories at bind time.
+ */
+export interface ConnectorContext {
+    buffer: SharedArrayBuffer;
+    codec: Codec;
+    /** Slot in the shared version counter — bump + notify on granular writes. */
+    version?: {
+        view: Int32Array;
+        index: number;
+    };
+}
+/**
+ * A connector factory builds a connector for one field kind over a region of
+ * the shared buffer. Factories are the plugin unit of the SDK: register new
+ * kinds globally via `registerConnectorFactory` or override per contract via
+ * `SharedMemoryOptions.plugins`.
+ */
+export type ConnectorFactory = (descriptor: FieldDescriptor, ctx: ConnectorContext, byteOffset: number) => Connector<any>;
+/** Registers (or overrides) the connector factory for a field kind, SDK-wide. */
+export declare function registerConnectorFactory(kind: string, factory: ConnectorFactory): void;
+export interface SharedMemoryOptions {
+    codec?: Codec;
+    plugins?: Record<string, ConnectorFactory>;
+}
+/** The element type a field descriptor holds — `InferField<typeof memory.spec.x>`. */
+export type InferField<D> = D extends FieldDescriptor<infer T> ? T : unknown;
+/**
+ * A bound connector reads and writes a single field of the shared memory
+ * contract. Both threads hold an identical connector for each field.
+ */
+export interface Connector<T> {
+    readonly byteOffset: number;
+    readonly byteLength: number;
+    read(): T;
+    write(value: T): void;
+    /** Internal: slot in the shared version counter block, bumped on every write. */
+    readonly _version?: {
+        view: Int32Array;
+        index: number;
+    };
+}
+export type ScalarKind = 'i8' | 'u8' | 'i16' | 'u16' | 'i32' | 'u32' | 'f32' | 'f64' | 'i64' | 'u64';
+/** A fixed-layout member spec: a scalar kind, `{ string: n }` for an inline UTF-8 field of n bytes, or `{ bool: true }` for a flag byte. */
+export type ListFieldSpec = ScalarKind | {
+    string: number;
+} | {
+    bool: true;
+};
+export type ListSpec = Record<string, ListFieldSpec>;
+/**
+ * A fixed-width member inside a record or element position — a binary spec
+ * token (`'u32'`, `{ string: n }`, `{ bool: true }`) or a zod schema that
+ * expresses the same thing (`mz.u32()`, `mz.int(0, 3)`, `mz.string(n)`).
+ * Schemas are compiled to tokens for layout and kept as the field's
+ * validation schema — one declaration.
+ */
+export type ListMember = ListFieldSpec | z.ZodTypeAny;
+export type ListFields = Record<string, ListMember>;
+/** The plain-object shape of one record in a list field — `z.output` of the declared record schema. */
+export type ListRecord<S extends z.ZodObject> = z.output<S>;
+export interface ListDescriptor<S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> extends Omit<FieldDescriptor<ListRecord<S>[]>, 'schema'> {
+    readonly kind: 'list';
+    /**
+     * The declared record schema — an `mz.object` of fixed-width members. It
+     * IS the layout source AND the record validator (`schemas.lists.x` is this
+     * same object). Note it parses one record, not the whole array.
+     */
+    readonly schema: S;
+    /** The compiled binary spec per member — always scalar tokens/`{string:n}`/`{bool}`. */
+    readonly layout: Record<keyof z.output<S> & string, ListFieldSpec>;
+    readonly offsets: Record<keyof z.output<S> & string, number>;
+    readonly recordSize: number;
+    readonly count: number;
+}
+/**
+ * A connector over a fixed-layout record array. `readAt`/`writeAt` access a
+ * single record directly via DataView — no encode/decode pass, ever.
+ * `readAt(index, out)` reuses `out` for allocation-free scans.
+ */
+export interface ListConnector<R> extends Connector<R[]> {
+    readonly recordCount: number;
+    readonly recordSize: number;
+    readAt(index: number): R;
+    /** Read into `out`; pass `fields` to read a subset (skips e.g. inline strings). */
+    readAt(index: number, out: Partial<R>, fields?: (keyof R)[]): R;
+    writeAt(index: number, record: R): void;
+    /** Write only the listed fields — partial updates leave other fields untouched. */
+    writeAt(index: number, record: Partial<R>, fields: (keyof R)[]): void;
+    /**
+     * Bump the field version counter and wake remote observers. `writeAt` is
+     * intentionally pure memory access — call commit() after a batch of writes
+     * to propagate them (bursts coalesce to latest anyway).
+     */
+    commit(): void;
+}
+type AccessMember<V> = V extends FieldDescriptor ? V extends ListDescriptor<infer S> ? ListConnector<ListRecord<S>> : Connector<InferField<V>> : V extends FieldGroup ? Prettify<SharedAccess<V>> : never;
+export type SharedAccess<S extends SharedSpec> = {
+    [K in keyof S]: AccessMember<S[K]>;
+};
+/**
+ * The connector a `SpecPath` resolves to — `PathConnector<S, 'state.metrics'>`
+ * digs through the intent group to the member's connector.
+ */
+export type PathConnector<S extends SharedSpec, P> = P extends `${infer G}.${infer F}` ? S[G] extends FieldGroup ? F extends keyof S[G] ? AccessMember<S[G][F]> : never : never : P extends keyof S ? AccessMember<S[P]> : never;
+/**
+ * A `field.object({ schema })` whose zod members compiled to an inline fixed
+ * layout — an 8-byte header (`written` flag + reserved) plus one record.
+ * `maxBytes` never appears: the byte width IS the schema.
+ */
+export interface FixedObjectDescriptor<T = unknown> extends FieldDescriptor<T> {
+    readonly kind: 'object';
+    readonly schema: Schema<T>;
+    /** The compiled binary spec per member — always scalar tokens/`{string:n}`/`{bool}`. */
+    readonly layout: Record<string, ListFieldSpec>;
+    readonly offsets: Record<string, number>;
+    readonly recordSize: number;
+}
+/**
+ * A `field.array({ schema })` whose bounded zod array compiled to an inline
+ * layout — an 8-byte header (`written` flag + element count) plus `capacity`
+ * fixed-stride elements.
+ */
+export interface FixedArrayDescriptor<T = unknown> extends FieldDescriptor<T[]> {
+    readonly kind: 'array';
+    readonly schema: Schema<T[]>;
+    /** The compiled element spec — scalar token, `{string:n}`, or `{bool}`. */
+    readonly element: ListFieldSpec;
+    /** Bytes per element, aligned. */
+    readonly elementStride: number;
+    readonly capacity: number;
+}
+interface ObjectFieldFactory {
+    /**
+     * Inline fixed layout — the schema is a zod object of fixed-width members
+     * (`mz` helpers, `z.uint32()`, bounded ints, `mz.string(n)`, `z.boolean()`);
+     * `byteLength` derives from the member widths. Compile fails loudly for
+     * members with no fixed width (unbounded strings, nested objects).
+     */
+    <S extends z.ZodObject<z.ZodRawShape>>(options: {
+        schema: S;
+    }): FixedObjectDescriptor<z.output<S>>;
+    /** Codec-encoded blob — explicit byte budget for arbitrary payloads. */
+    <T = unknown>(options: {
+        maxBytes: number;
+        schema?: Schema<T>;
+    }): FieldDescriptor<T>;
+    /** Schema with no derivable width — rejected at construction. */
+    <T = unknown>(options: {
+        schema: Schema<T>;
+    }): FieldDescriptor<T>;
+}
+interface ArrayFieldFactory {
+    /**
+     * Inline fixed layout — the schema is a bounded zod array
+     * (`mz.array(mz.u32()).max(n)`, `.length(n)`); `byteLength` derives from
+     * the element width × the bound. Elements must be fixed-width members
+     * (scalars, `mz.string(n)`, booleans) — use `field.list` for record arrays.
+     */
+    <S extends z.ZodArray>(options: {
+        schema: S;
+    }): FixedArrayDescriptor<S extends z.ZodArray<infer E> ? z.output<E> : unknown>;
+    /** Codec-encoded blob — explicit byte budget for arbitrary payloads. */
+    <T = unknown>(options: {
+        maxBytes: number;
+        schema?: Schema<T[]>;
+    }): FieldDescriptor<T[]>;
+    /** Schema with no derivable width — rejected at construction. */
+    <T = unknown>(options: {
+        schema: Schema<T[]>;
+    }): FieldDescriptor<T[]>;
+}
+interface StringFieldFactory {
+    /** Explicit byte budget — 4-byte length header + up to `maxBytes` of UTF-8. */
+    (options: {
+        maxBytes: number;
+        schema?: Schema<string>;
+    }): FieldDescriptor<string>;
+    /** Budget derived from the schema — `mz.string(n)` / `z.string().meta({ bytes: n })`. */
+    (options: {
+        schema: Schema<string>;
+    }): FieldDescriptor<string>;
+}
+/**
+ * Field datatype helpers for `defineSharedMemory`.
+ */
+export declare const field: {
+    number: () => FieldDescriptor<number>;
+    boolean: () => FieldDescriptor<boolean>;
+    string: StringFieldFactory;
+    object: ObjectFieldFactory;
+    array: ArrayFieldFactory;
+    int32Array: ({ length }: {
+        length: number;
+    }) => FieldDescriptor<Int32Array>;
+    float64Array: ({ length }: {
+        length: number;
+    }) => FieldDescriptor<Float64Array>;
+    bigInt64Array: ({ length }: {
+        length: number;
+    }) => FieldDescriptor<BigInt64Array>;
+    uint8Array: ({ length }: {
+        length: number;
+    }) => FieldDescriptor<Uint8Array>;
+    /**
+     * A fixed-layout array of `count` records. `schema` is an `mz.object` of
+     * fixed-width members (`mz.u32()`, `mz.int(0, 3)`, `mz.string(n)`,
+     * `mz.boolean()`) — the same schema `field.object` takes, repeated `count`
+     * times. Every record occupies `recordSize` bytes at a computable offset:
+     * reads and writes are direct memory access, no serialization.
+     */
+    list: <S extends z.ZodObject<z.ZodRawShape>>({ schema, count }: {
+        schema: S;
+        count: number;
+    }) => ListDescriptor<S>;
+};
+/**
+ * The zod schema for a field's logical unit: the declared `schema` for
+ * object/array/list fields (for lists, the record schema), and a derived
+ * scalar/typed-array schema for everything else.
+ */
+export type FieldSchema<D> = 'schema' extends keyof D ? NonNullable<D['schema']> : z.ZodType<InferField<D>>;
+/**
+ * A zod schema per field — `memory.schemas.<field>` re-exports what the spec
+ * declared inline. Intent groups mirror their spec shape:
+ * `memory.schemas.lists.incidents` is the record schema.
+ */
+type SchemaMember<V> = V extends FieldDescriptor ? FieldSchema<V> : V extends FieldGroup ? Prettify<SpecSchemas<V>> : never;
+export type SpecSchemas<S extends SharedSpec> = {
+    [K in keyof S]: SchemaMember<S[K]>;
+};
+/**
+ * A shared memory contract: a fixed, deterministic layout of typed fields over
+ * a SharedArrayBuffer. Both threads import the same contract object; the pool
+ * binds it on the main thread and the worker bootstrap binds it inside workers,
+ * guaranteeing identical memory usage on both sides.
+ */
+export declare class SharedMemory<S extends SharedSpec = SharedSpec> {
+    readonly totalBytes: number;
+    /** The field descriptors the contract was defined with — the inline spec. */
+    readonly spec: S;
+    /**
+     * One zod schema per field, derived from the spec: declared schemas on
+     * object/array fields, the record schema on list fields, and derived
+     * scalar schemas (z.number(), z.string(), …) elsewhere.
+     */
+    readonly schemas: SpecSchemas<S>;
+    private readonly codec;
+    private readonly plugins?;
+    private readonly entries;
+    private readonly offsets;
+    private readonly versionOffset;
+    private readonly connectors;
+    private readonly boundListeners;
+    private isBound;
+    private boundBuffer?;
+    constructor(spec: S, options?: SharedMemoryOptions);
+    /** Binds this contract's connectors to the shared buffer. Called by the SDK on each thread. */
+    bind(buffer: SharedArrayBuffer): void;
+    /** True once the contract has been bound to a buffer on this thread. */
+    get bound(): boolean;
+    /**
+     * The buffer this contract is bound to on this thread — the raw backing
+     * store persistence adapters and snapshot tooling read/write through.
+     * Throws while unbound.
+     */
+    get buffer(): SharedArrayBuffer;
+    /**
+     * Every field's address in the layout — `{ path, byteOffset, byteLength }`.
+     * Persistence adapters use this to read/write field regions directly and
+     * to pair each region with its `connector(path)._version` slot.
+     */
+    fields(): {
+        path: string;
+        byteOffset: number;
+        byteLength: number;
+    }[];
+    /**
+     * Fires when the contract is bound on this thread — immediately if already
+     * bound. Returns an unsubscribe function.
+     */
+    onBound(cb: () => void): () => void;
+    /** Typed lookup for flat (ungrouped) field keys. */
+    connector<K extends FlatKey<S>>(key: K): SharedAccess<S>[K];
+    /**
+     * Looks up a bound connector by its field path — `incidents` for flat
+     * fields, `lists.incidents` for grouped ones.
+     */
+    connector(path: string): Connector<any>;
+}
+/**
+ * Defines a shared memory contract. Spec values are field descriptors or
+ * intent groups (one level of nesting — the group's name is the intent):
+ *
+ *   defineSharedMemory({
+ *     lists:   { incidents: field.list({ schema, count }) },
+ *     state:   { metrics:   field.object({ maxBytes, schema }) },
+ *     signals: { progress:  field.number() },
+ *   });
+ *
+ * The returned object exposes a typed connector per field, nested the same
+ * way: `memory.lists.incidents.readAt(0)`, `memory.signals.progress.write(…)`.
+ * Flat members (`memory.counter`) keep working for ungrouped fields.
+ */
+export declare function defineSharedMemory<S extends SharedSpec>(spec: S, options?: SharedMemoryOptions): SharedMemory<S> & Prettify<SharedAccess<S>>;
+/** Binds every defined shared memory contract to the buffer. Used by the worker bootstrap. */
+export declare function bindSharedMemories(buffer: SharedArrayBuffer): void;
+/** How many shared-memory contracts this module graph has defined. */
+export declare function getDefinedSharedMemoryCount(): number;
+export {};

package/dist/contract/types.d.ts

@@ -0,0 +1,131 @@
+import type { SharedAccess, SharedMemory, SharedSpec } from './sharedMemory';
+export type ViewType = 'Int32' | 'Float64' | 'BigInt64' | 'Uint8';
+/**
+ * Minimal validation contract — compatible with zod schemas (`z.object(...)`)
+ * and any validator exposing `parse`.
+ */
+export interface Schema<T> {
+    parse(value: unknown): T;
+}
+export type Logger = (...args: unknown[]) => void;
+/**
+ * Flattens a computed object type into its concrete shape so IDE hovers show
+ * `{ id: number; site: string }` instead of the mapped-type machinery that
+ * produced it. Applied to synthetic types (e.g. list records); user-named
+ * types keep their names since the name is the better display.
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export interface MemoryConfig {
+    initialPages?: number;
+    maximumPages?: number;
+    growthFactor?: number;
+}
+/**
+ * Runtime handle for a memory-persistence adapter — e.g. the Redis adapter
+ * in '@atolljs/node/redis'. The adapter mirrors the bound contract's field
+ * regions to external storage; the buffer stays the synchronous source of
+ * truth.
+ */
+export interface MemoryPersistence {
+    /** Resolves when initial state has been restored into the local buffer. */
+    readonly ready?: Promise<unknown>;
+    /** Push dirty fields now — most adapters also flush on an interval. */
+    flush?(): Promise<unknown>;
+    /** Final flush + release external resources. Invoked by pool.terminate(). */
+    stop(): void | Promise<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;
+    /**
+     * Bundler-detectable worker factory. Most bundlers only emit a worker chunk
+     * when the entry appears inline, so prefer this form:
+     * `createWorker: () => new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' })`.
+     * One of `workerUrl` / `createWorker` is required.
+     */
+    createWorker?: () => Worker;
+    /**
+     * The contract the pool binds and hands to each worker via INIT_MEMORY.
+     * Omit for message-only workers — the SharedArrayBuffer/isolation check is
+     * skipped and workers receive a plain `{ type: 'INIT' }` handshake.
+     */
+    sharedMemory?: SharedMemory<S> & Prettify<SharedAccess<S>>;
+    /**
+     * Persistence adapter for `sharedMemory` — invoked with the contract right
+     * after the pool binds it, and its `stop()` runs on `terminate()`.
+     * `redisMemoryAdapter(client)` from '@atolljs/node/redis' produces one.
+     */
+    persistence?: (memory: SharedMemory<S>) => MemoryPersistence | undefined;
+    /** Worker count — a number, or 'auto' (the default) for navigator.hardwareConcurrency ?? 4. */
+    poolSize?: number | 'auto';
+    memory?: MemoryConfig;
+    /** Max in-flight tasks per worker (default 1); excess tasks queue FIFO. */
+    concurrency?: number;
+    /** Max queued tasks (default Infinity); a full queue rejects with PoolQueueFullError. */
+    maxQueue?: number;
+    /** Default true — a worker 'error' rejects its in-flight tasks and spawns a replacement. */
+    respawn?: boolean;
+    /**
+     * Default per-task timeout in ms (per-call `options.timeout` overrides).
+     * The timer starts at enqueue, so it bounds queue-wait + execution together.
+     */
+    taskTimeout?: number;
+    /**
+     * Named task contracts. Keys become first-class pool methods:
+     * `tasks: { queryIncidents: QueryIncidents }` → `pool.queryIncidents(q)`.
+     */
+    tasks?: T;
+}
+export interface SharedWorkerConfig<S extends SharedSpec = SharedSpec, T extends TaskMap = TaskMap> {
+    /** SharedWorker entry as a URL — e.g. `new URL('./worker.ts', import.meta.url)`. */
+    workerUrl?: URL;
+    /**
+     * Bundler-detectable factory — `createWorker: () => new SharedWorker(new URL('./worker.ts', import.meta.url), { type: 'module' })`.
+     * One of `workerUrl` / `createWorker` / `port` is required.
+     */
+    createWorker?: () => SharedWorker;
+    /** A pre-opened MessagePort — tests, or hosts that forward a port another way. */
+    port?: MessagePort;
+    sharedMemory: SharedMemory<S> & Prettify<SharedAccess<S>>;
+    /**
+     * Buffer sizing hint sent on connect — the first connected client wins;
+     * the shared worker allocates the buffer once and shares it with everyone.
+     */
+    memory?: MemoryConfig;
+    /**
+     * Named task contracts. Keys become first-class client methods:
+     * `tasks: { queryIncidents: QueryIncidents }` → `client.queryIncidents(q)`.
+     */
+    tasks?: T;
+    /** Connect handshake timeout in ms (default 10000). */
+    connectTimeoutMs?: number;
+}
+export interface TaskContract<Args extends any[] = any[], Result = any> {
+    taskId: string;
+    dataType?: ViewType;
+    argsSchema?: Schema<Args>;
+    resultSchema?: Schema<Result>;
+}
+/** A map of named task contracts — keys become first-class WorkerPool methods. */
+export type TaskMap = Record<string, TaskContract<any[], any>>;
+/**
+ * The method surface a WorkerPool exposes for a task map: each contract
+ * becomes a function with its declared args returning `Promise<Result>`.
+ */
+export type PoolTasks<T extends TaskMap> = {
+    [K in keyof T]: T[K] extends TaskContract<infer Args, infer Result> ? (...args: Args) => Promise<Result> : never;
+};
+export interface TaskMessage {
+    taskId: string;
+    args?: any[];
+    memoryOffset?: number;
+    byteLength?: number;
+}
+export interface TaskResult {
+    taskId: string;
+    success: boolean;
+    result?: any;
+    error?: string;
+}

package/dist/contract/zod.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The SDK's vendored zod surface — everything the contract layer needs,
+ * narrowed.
+ *
+ * `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).
+ *
+ * `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(...)`.
+ */
+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';
+export declare const z: {
+    number: typeof number;
+    string: typeof string;
+    boolean: typeof boolean;
+    bigint: typeof bigint;
+    object: typeof object;
+    array: typeof array;
+    instanceof: typeof instanceof_;
+    unknown: typeof unknown_;
+    int32: typeof int32;
+    uint32: typeof uint32;
+    float32: typeof float32;
+    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>;
+};
+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>;
+}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory';
+export { mz } from './contract/mz';
+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';
+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';

package/dist/index.js

@@ -1,19 +1,19 @@
 import { msgpackrCodec as e } from "./index2.js";
-import { listSchema as t } from "./index3.js";
-import { getLogLevel as n, log as r, scoped as i, setLogLevel as a, setLogSink as o } from "./index4.js";
-import { defineSharedMemory as s, field as c, getDefinedSharedMemoryCount as l, jsonCodec as u, registerConnectorFactory as d } from "./index5.js";
-import { mz as f } from "./index6.js";
-import { msgpackCodec 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 connectSharedWorker, b as connectWorker, T as createClient, E as defineService, s as defineSharedMemory, I as defineTask, j as defineWorker, c as field, l as getDefinedSharedMemoryCount, n as getLogLevel, D as implementService, L as isAsyncTask, u as jsonCodec, t as listSchema, r as log, p as msgpackCodec, e as msgpackrCodec, f as mz, F as observe, M as reactive, d 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 };
+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 };