@atolljs/core 0.1.4 → 0.1.6

package/dist/index3.js

@@ -93,16 +93,16 @@ var e = (e, t) => ({
 	inner(e) {
 		return typeof e == "bigint" ? e : _("bigint");
 	}
-}, S = class extends g {
+}, ee = class extends g {
 	inner(e) {
 		return e;
 	}
-}, C = class extends g {
+}, S = class extends g {
 	inner(e) {
 		let t = this._zod.def.cls;
 		return e instanceof t ? e : _(t.name ?? "instance");
 	}
-}, w = class extends g {
+}, C = class extends g {
 	get shape() {
 		return this._zod.def.shape;
 	}
@@ -112,55 +112,109 @@ var e = (e, t) => ({
 		for (let [n, r] of Object.entries(this.shape)) t[n] = r.parse(e[n]);
 		return t;
 	}
-}, T = class extends g {
+}, w = class extends g {
 	inner(e) {
 		if (!Array.isArray(e)) return _("array");
 		let t = this._zod.def.element;
 		return e.map((e) => t.parse(e));
 	}
-}, E = () => new v({ type: "number" }), D = () => new y({ type: "string" }), O = () => new b({ type: "boolean" }), k = () => new x({ type: "bigint" }), A = () => new S({ type: "unknown" }), j = (e) => new C({
+}, T = class extends g {
+	inner(e) {
+		return e === void 0 ? void 0 : this._zod.def.element.parse(e);
+	}
+}, E = class extends g {
+	inner(e) {
+		return e === null ? null : this._zod.def.element.parse(e);
+	}
+}, D = class extends g {
+	inner(e) {
+		return e === this._zod.def.literal ? e : _(JSON.stringify(this._zod.def.literal));
+	}
+}, O = class extends g {
+	inner(e) {
+		for (let t of this._zod.def.options) {
+			let n = t.safeParse(e);
+			if (n.success) return n.data;
+		}
+		return _("a union member");
+	}
+}, k = class extends g {
+	inner(e) {
+		(typeof e != "object" || !e || Array.isArray(e)) && _("object");
+		let t = this._zod.def.element, n = {};
+		for (let [r, i] of Object.entries(e)) n[r] = t.parse(i);
+		return n;
+	}
+}, A = class extends g {
+	inner(e) {
+		return typeof e == "function" ? e : _("function");
+	}
+}, j = () => $(new v({ type: "number" })), M = () => $(new y({ type: "string" })), N = () => $(new b({ type: "boolean" })), P = () => $(new x({ type: "bigint" })), F = () => $(new ee({ type: "unknown" })), I = (e) => $(new S({
 	type: "instanceof",
 	cls: e
-}), M = (e) => new w({
+})), L = (e) => $(new C({
 	type: "object",
 	shape: e
-}), N = (e) => new T({
+})), R = (e) => $(new w({
 	type: "array",
 	element: e
-}), P = () => new v({
+})), z = (e) => $(new T({
+	type: "optional",
+	element: e
+})), B = (e) => $(new E({
+	type: "nullable",
+	element: e
+})), V = (e) => $(new D({
+	type: "literal",
+	literal: e
+})), H = (e) => $(new O({
+	type: "union",
+	options: e
+})), U = (e) => $(new k({
+	type: "record",
+	element: e
+})), W = () => $(new A({ type: "function" })), G = () => new v({
 	type: "number",
 	format: "int32"
-}).check(d("int32", t, n)), F = () => new v({
+}).check(d("int32", t, n)), K = () => new v({
 	type: "number",
 	format: "uint32"
-}).check(d("uint32", 0, 4294967295)), I = () => new v({
+}).check(d("uint32", 0, 4294967295)), q = () => new v({
 	type: "number",
 	format: "float32"
-}), L = () => new v({
+}), J = () => new v({
 	type: "number",
 	format: "float64"
-}), R = () => new x({
+}), Y = () => new x({
 	type: "bigint",
 	format: "int64"
-}).check(f("int64", -(2n ** 63n), 2n ** 63n - 1n)), z = () => new x({
+}).check(f("int64", -(2n ** 63n), 2n ** 63n - 1n)), X = () => new x({
 	type: "bigint",
 	format: "uint64"
-}).check(f("uint64", 0n, 2n ** 64n - 1n)), B = /* @__PURE__ */ new Set([
+}).check(f("uint64", 0n, 2n ** 64n - 1n)), Z = /* @__PURE__ */ new Set([
 	"string",
 	"array",
 	"set"
-]), V = (e, t, n) => {
-	let r = B.has(e._zod.def.type);
+]), Q = (e, t, n) => {
+	let r = Z.has(e._zod.def.type);
 	return t === "min" ? r ? u(n) : i(n) : r ? l(n) : a(n);
 };
-function H(e) {
+function $(e) {
 	let t = e.check.bind(e), n = e.register.bind(e), i = {
-		refine: (e, n) => H(t(s(e, n))),
-		meta: (t) => t === void 0 ? m.get(e) : H(n(m, t)),
-		min: (n) => H(t(V(e, "min", n))),
-		max: (n) => H(t(V(e, "max", n))),
-		length: (e) => H(t(c(e))),
-		int: () => H(t(r()))
+		refine: (e, n) => $(t(s(e, n))),
+		meta: (t) => t === void 0 ? m.get(e) : $(n(m, t)),
+		min: (n) => $(t(Q(e, "min", n))),
+		max: (n) => $(t(Q(e, "max", n))),
+		length: (e) => $(t(c(e))),
+		int: () => $(t(r())),
+		optional: () => $(new T({
+			type: "optional",
+			element: e
+		})),
+		nullable: () => $(new E({
+			type: "nullable",
+			element: e
+		}))
 	};
 	for (let [t, n] of Object.entries(i)) Object.defineProperty(e, t, {
 		value: n,
@@ -169,21 +223,27 @@ function H(e) {
 	});
 	return e;
 }
-var U = {
-	number: E,
-	string: D,
-	boolean: O,
-	bigint: k,
-	object: M,
-	array: N,
-	instanceof: j,
-	unknown: A,
-	int32: P,
-	uint32: F,
-	float32: I,
-	float64: L,
-	int64: R,
-	uint64: z,
+var te = {
+	number: j,
+	string: M,
+	boolean: N,
+	bigint: P,
+	object: L,
+	array: R,
+	instanceof: I,
+	unknown: F,
+	optional: z,
+	nullable: B,
+	literal: V,
+	union: H,
+	record: U,
+	callback: W,
+	int32: G,
+	uint32: K,
+	float32: q,
+	float64: J,
+	int64: Y,
+	uint64: X,
 	int: r,
 	gte: i,
 	lte: a,
@@ -194,11 +254,9 @@ var U = {
 	minLength: u,
 	globalRegistry: m,
 	ZodType: g,
-	ZodObject: w,
-	ZodArray: T,
+	ZodObject: C,
+	ZodArray: w,
 	ZodString: y
 };
 //#endregion
-export { h as SchemaError, g as ZodType, H as fluent, m as globalRegistry, U as z };
-
-//# sourceMappingURL=index3.js.map
+export { h as SchemaError, g as ZodType, $ as fluent, m as globalRegistry, te as z };

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.6",
   "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/contract/zod.ts

@@ -98,6 +98,10 @@ export interface SchemaDef {
   format?: string;
   shape?: Record<string, ZodLike>;
   element?: ZodLike;
+  /** union members. */
+  options?: readonly ZodLike[];
+  /** literal value. */
+  literal?: unknown;
   cls?: abstract new (...args: any[]) => unknown;
 }
 
@@ -205,9 +209,24 @@ class ZodInstanceof<T> extends ZodType<T> {
   }
 }
 
-type ShapeOutput<S extends Record<string, ZodLike>> = {
-  [K in keyof S]: S[K] extends { _zod: { output: infer O } } ? O : never;
-};
+/** Members whose output admits `undefined` become optional keys — mirroring
+ *  zod's `z.optional()` object-member semantics (message-domain schemas like
+ *  island prop contracts need this; reef's fixed-width members never produce
+ *  it, so the split preserves their all-required output). */
+type IsOptional<S, K extends keyof S> =
+  S[K] extends { _zod: { output: infer O } }
+    ? undefined extends O
+      ? true
+      : false
+    : false;
+
+type Flatten<T> = { [K in keyof T]: T[K] };
+
+type ShapeOutput<S extends Record<string, ZodLike>> = Flatten<
+  { [K in keyof S as IsOptional<S, K> extends true ? never : K]: OutputOf<S[K]> } & {
+    [K in keyof S as IsOptional<S, K> extends true ? K : never]?: OutputOf<S[K]>;
+  }
+>;
 
 /** Strips unknown keys like zod's object parse — output is the shape only. */
 class ZodObjectSchema<S extends Record<string, ZodLike>> extends ZodType<ShapeOutput<S>> {
@@ -242,21 +261,111 @@ class ZodArraySchema<E extends ZodLike> extends ZodType<OutputOf<E>[]> {
 
 type OutputOf<S> = S extends { _zod: { output: infer O } } ? O : never;
 
-/* ------------------------------------------------------------------ */
-/* Factories — the vendored `zod/mini` spelling                         */
-/* ------------------------------------------------------------------ */
+/* ── Message-domain kinds ────────────────────────────────────────────────
+ * Layout-free members for contracts that ride postMessage instead of the
+ * shared buffer — island prop/event schemas (defineIslandContract). The
+ * layout compiler doesn't understand these def.types and rejects them with
+ * "can't lay out" if they ever appear inside a fixed-width field — that
+ * loud failure is intended: they have no byte width.
+ */
+
+class ZodOptional<E extends ZodLike> extends ZodType<OutputOf<E> | undefined> {
+  declare readonly _zod: {
+    output: OutputOf<E> | undefined; input: OutputOf<E> | undefined;
+    def: SchemaDef & { type: 'optional'; element: E };
+  };
+  inner(v: unknown): OutputOf<E> | undefined {
+    // The intersected def narrows element to E; read it as the element's
+    // output type so the wrapper's output lines up.
+    return v === undefined
+      ? undefined
+      : (this._zod.def.element as ZodLike<OutputOf<E>>).parse(v);
+  }
+}
+class ZodNullable<E extends ZodLike> extends ZodType<OutputOf<E> | null> {
+  declare readonly _zod: {
+    output: OutputOf<E> | null; input: OutputOf<E> | null;
+    def: SchemaDef & { type: 'nullable'; element: E };
+  };
+  inner(v: unknown): OutputOf<E> | null {
+    return v === null
+      ? null
+      : (this._zod.def.element as ZodLike<OutputOf<E>>).parse(v);
+  }
+}
+class ZodLiteral<V extends string | number | boolean> extends ZodType<V> {
+  declare readonly _zod: { output: V; input: V; def: SchemaDef & { type: 'literal' } };
+  inner(v: unknown): V {
+    return v === this._zod.def.literal ? (v as V) : fail(JSON.stringify(this._zod.def.literal));
+  }
+}
+class ZodUnion<O extends readonly ZodLike[]> extends ZodType<OutputOf<O[number]>> {
+  declare readonly _zod: {
+    output: OutputOf<O[number]>; input: OutputOf<O[number]>;
+    def: SchemaDef & { type: 'union'; options: O };
+  };
+  inner(v: unknown): OutputOf<O[number]> {
+    for (const option of this._zod.def.options as readonly ZodLike<OutputOf<O[number]>>[]) {
+      const r = option.safeParse(v);
+      if (r.success) return r.data;
+    }
+    return fail('a union member');
+  }
+}
+class ZodRecord<E extends ZodLike> extends ZodType<Record<string, OutputOf<E>>> {
+  declare readonly _zod: {
+    output: Record<string, OutputOf<E>>; input: Record<string, OutputOf<E>>;
+    def: SchemaDef & { type: 'record'; element: E };
+  };
+  inner(v: unknown): Record<string, OutputOf<E>> {
+    if (typeof v !== 'object' || v === null || Array.isArray(v)) fail('object');
+    const el = this._zod.def.element;
+    const out: Record<string, unknown> = {};
+    for (const [k, value] of Object.entries(v as Record<string, unknown>)) {
+      out[k] = el.parse(value);
+    }
+    return out as Record<string, OutputOf<E>>;
+  }
+}
+/**
+ * Function-typed members — how a props schema declares a `callbackProp`
+ * slot: the wire carries a `{__cb:id}` handle that `unmarshalCallbackProps`
+ * restores to a callable BEFORE contract validation runs, so at parse time
+ * the member is a real function.
+ */
+class ZodCallback<F extends (...args: any[]) => any = (...args: unknown[]) => unknown>
+  extends ZodType<F> {
+  declare readonly _zod: { output: F; input: F; def: SchemaDef & { type: 'function' } };
+  inner(v: unknown): F {
+    return typeof v === 'function' ? (v as F) : fail('function');
+  }
+}
 
-const number = () => new ZodNumber({ type: 'number' });
-const string = () => new ZodString({ type: 'string' });
-const boolean_ = () => new ZodBoolean({ type: 'boolean' });
-const bigint_ = () => new ZodBigint({ type: 'bigint' });
-const unknown_ = () => new ZodUnknown({ type: 'unknown' });
+// z factories return FLUENT schemas — `z.string().optional()` chains like
+// classic zod; the mini spellings (`z.optional(z.string())`) stay valid.
+const number = () => fluent(new ZodNumber({ type: 'number' }));
+const string = () => fluent(new ZodString({ type: 'string' }));
+const boolean_ = () => fluent(new ZodBoolean({ type: 'boolean' }));
+const bigint_ = () => fluent(new ZodBigint({ type: 'bigint' }));
+const unknown_ = () => fluent(new ZodUnknown({ type: 'unknown' }));
 const instanceof_ = <T extends abstract new (...args: any[]) => any>(cls: T) =>
-  new ZodInstanceof<InstanceType<T>>({ type: 'instanceof', cls });
+  fluent(new ZodInstanceof<InstanceType<T>>({ type: 'instanceof', cls }));
 const object_ = <S extends Record<string, ZodLike>>(shape: S) =>
-  new ZodObjectSchema<S>({ type: 'object', shape });
+  fluent(new ZodObjectSchema<S>({ type: 'object', shape }));
 const array = <E extends ZodLike>(element: E) =>
-  new ZodArraySchema<E>({ type: 'array', element });
+  fluent(new ZodArraySchema<E>({ type: 'array', element }));
+const optional = <E extends ZodLike>(element: E) =>
+  fluent(new ZodOptional<E>({ type: 'optional', element }));
+const nullable = <E extends ZodLike>(element: E) =>
+  fluent(new ZodNullable<E>({ type: 'nullable', element }));
+const literal = <V extends string | number | boolean>(value: V) =>
+  fluent(new ZodLiteral<V>({ type: 'literal', literal: value }));
+const union = <O extends readonly [ZodLike, ...ZodLike[]]>(options: O) =>
+  fluent(new ZodUnion<O>({ type: 'union', options }));
+const record = <E extends ZodLike>(element: E) =>
+  fluent(new ZodRecord<E>({ type: 'record', element }));
+const callback = <F extends (...args: any[]) => any = (...args: unknown[]) => unknown>() =>
+  fluent(new ZodCallback<F>({ type: 'function' }));
 
 const int32 = () => new ZodNumber({ type: 'number', format: 'int32' }).check(intRange('int32', int32min, int32max));
 const uint32 = () => new ZodNumber({ type: 'number', format: 'uint32' }).check(intRange('uint32', 0, 4294967295));
@@ -288,6 +397,10 @@ export type Fluent<S extends ZodLike> = S & {
   max(value: number | bigint): Fluent<S>;
   length(n: number): Fluent<S>;
   int(): Fluent<S>;
+  /** Wraps in an optional member — the `label?: string` spelling. */
+  optional(): Fluent<ZodOptional<S>>;
+  /** Wraps in a nullable member — `T | null`. */
+  nullable(): Fluent<ZodNullable<S>>;
 };
 
 /** Attaches the `Fluent` methods as non-enumerable own properties. */
@@ -302,6 +415,8 @@ export function fluent<S extends ZodType>(schema: S): Fluent<S> {
     max: (v: number | bigint) => fluent(boundCheck_(boundCheck(schema, 'max', v))),
     length: (n: number) => fluent(boundCheck_(length(n))),
     int: () => fluent(boundCheck_(int())),
+    optional: () => fluent(new ZodOptional({ type: 'optional', element: schema })),
+    nullable: () => fluent(new ZodNullable({ type: 'nullable', element: schema })),
   };
   for (const [key, fn] of Object.entries(own)) {
     Object.defineProperty(schema, key, { value: fn, enumerable: false, configurable: true });
@@ -316,6 +431,7 @@ export function fluent<S extends ZodType>(schema: S): Fluent<S> {
 export const z = {
   number, string, boolean: boolean_, bigint: bigint_, object: object_, array,
   instanceof: instanceof_, unknown: unknown_,
+  optional, nullable, literal, union, record, callback,
   int32, uint32, float32, float64, int64, uint64,
   int, gte, lte, nonnegative, refine, length, maxLength, minLength,
   globalRegistry,

package/src/index.ts

@@ -2,6 +2,8 @@
 
 export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory';
 export { reef } from './contract/reef';
+export { z, SchemaError } from './contract/zod';
+export type { ZodLike } from './contract/zod';
 export type {
   Codec,
   Connector,