@atolljs/core 0.1.5 → 0.1.6

package/dist/contract/reef.d.ts

@@ -24,7 +24,7 @@ import { z } from './zod.js';
  * `_zod.def`, so `reef.object({ id: z.uint32() })` mixes freely.
  */
 export declare const reef: {
-    i8: () => import("./zod.js").Fluent<{
+    i8: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -43,8 +43,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
-    u8: () => import("./zod.js").Fluent<{
+    }>>;
+    u8: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -63,8 +63,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
-    i16: () => import("./zod.js").Fluent<{
+    }>>;
+    i16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -83,8 +83,8 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
-    u16: () => import("./zod.js").Fluent<{
+    }>>;
+    u16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -103,7 +103,7 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
-    }>;
+    }>>;
     i32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
@@ -225,7 +225,7 @@ export declare const reef: {
         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.js").Fluent<{
+    int: (min: number, max: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
@@ -244,9 +244,9 @@ export declare const reef: {
         };
         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.js").Fluent<{
+    boolean: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: boolean;
             input: boolean;
@@ -265,11 +265,11 @@ export declare const reef: {
         };
         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.js").Fluent<{
+    string: (bytes: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: string;
             input: string;
@@ -288,52 +288,112 @@ export declare const reef: {
         };
         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.js").Fluent<{
+    object: <S extends z.ZodRawShape>(shape: S) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
-            output: { [K in keyof S]: S[K] extends {
+            output: { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
-            input: { [K in keyof S]: S[K] extends {
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+            input: { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
             def: import("./zod.js").SchemaDef & {
                 type: 'object';
                 shape: S;
             };
         };
         get shape(): S;
-        inner(v: unknown): { [K in keyof S]: S[K] extends {
+        inner(v: unknown): { [K in keyof S as (S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
             _zod: {
                 output: infer O;
             };
-        } ? O : never; };
-        parse(value: unknown): { [K in keyof S]: S[K] extends {
+        } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
+        parse(value: unknown): { [K in keyof S as (S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
             _zod: {
                 output: infer O;
             };
-        } ? O : never; };
+        } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+            _zod: {
+                output: infer O_1;
+            };
+        } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
         safeParse(value: unknown): {
             success: true;
-            data: { [K in keyof S]: S[K] extends {
+            data: { [K in keyof S as (S[K] extends {
                 _zod: {
                     output: infer O;
                 };
-            } ? O : never; };
+            } ? undefined extends O ? true : false : false) extends true ? never : K]: S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O_1 : never : never : never; } & { [K in keyof S as (S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? undefined extends O ? true : false : false) extends true ? K : never]?: (S[K] extends infer T_1 ? T_1 extends S[K] ? T_1 extends {
+                _zod: {
+                    output: infer O_1;
+                };
+            } ? O : never : never : never) | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never;
         } | {
             success: false;
             error: unknown;
         };
         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.js").Fluent<{
+    array: <E extends z.ZodTypeAny>(element: E) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: (E extends {
                 _zod: {
@@ -373,5 +433,5 @@ export declare const reef: {
         };
         check(...checks: import("./zod.js").Check[]): /*elided*/ any;
         register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+    }>>;
 };

package/dist/contract/zod.d.ts

@@ -52,6 +52,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;
 }
 export declare class SchemaError extends Error {
@@ -143,13 +147,23 @@ declare class ZodUnknown extends ZodType<unknown> {
 declare class ZodInstanceof<T> extends ZodType<T> {
     inner(v: unknown): T;
 }
-type ShapeOutput<S extends Record<string, ZodLike>> = {
-    [K in keyof S]: S[K] extends {
-        _zod: {
-            output: infer O;
-        };
-    } ? O : never;
+/** 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. */
 declare class ZodObjectSchema<S extends Record<string, ZodLike>> extends ZodType<ShapeOutput<S>> {
     readonly _zod: {
@@ -179,14 +193,90 @@ type OutputOf<S> = S extends {
         output: infer O;
     };
 } ? O : never;
-declare const number: () => ZodNumber;
-declare const string: () => ZodString;
-declare const boolean_: () => ZodBoolean;
-declare const bigint_: () => ZodBigint;
-declare const unknown_: () => ZodUnknown;
-declare const instanceof_: <T extends abstract new (...args: any[]) => any>(cls: T) => ZodInstanceof<InstanceType<T>>;
-declare const object_: <S extends Record<string, ZodLike>>(shape: S) => ZodObjectSchema<S>;
-declare const array: <E extends ZodLike>(element: E) => ZodArraySchema<E>;
+declare class ZodOptional<E extends ZodLike> extends ZodType<OutputOf<E> | undefined> {
+    readonly _zod: {
+        output: OutputOf<E> | undefined;
+        input: OutputOf<E> | undefined;
+        def: SchemaDef & {
+            type: 'optional';
+            element: E;
+        };
+    };
+    inner(v: unknown): OutputOf<E> | undefined;
+}
+declare class ZodNullable<E extends ZodLike> extends ZodType<OutputOf<E> | null> {
+    readonly _zod: {
+        output: OutputOf<E> | null;
+        input: OutputOf<E> | null;
+        def: SchemaDef & {
+            type: 'nullable';
+            element: E;
+        };
+    };
+    inner(v: unknown): OutputOf<E> | null;
+}
+declare class ZodLiteral<V extends string | number | boolean> extends ZodType<V> {
+    readonly _zod: {
+        output: V;
+        input: V;
+        def: SchemaDef & {
+            type: 'literal';
+        };
+    };
+    inner(v: unknown): V;
+}
+declare class ZodUnion<O extends readonly ZodLike[]> extends ZodType<OutputOf<O[number]>> {
+    readonly _zod: {
+        output: OutputOf<O[number]>;
+        input: OutputOf<O[number]>;
+        def: SchemaDef & {
+            type: 'union';
+            options: O;
+        };
+    };
+    inner(v: unknown): OutputOf<O[number]>;
+}
+declare class ZodRecord<E extends ZodLike> extends ZodType<Record<string, OutputOf<E>>> {
+    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>>;
+}
+/**
+ * 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.
+ */
+declare class ZodCallback<F extends (...args: any[]) => any = (...args: unknown[]) => unknown> extends ZodType<F> {
+    readonly _zod: {
+        output: F;
+        input: F;
+        def: SchemaDef & {
+            type: 'function';
+        };
+    };
+    inner(v: unknown): F;
+}
+declare const number: () => Fluent<ZodNumber>;
+declare const string: () => Fluent<ZodString>;
+declare const boolean_: () => Fluent<ZodBoolean>;
+declare const bigint_: () => Fluent<ZodBigint>;
+declare const unknown_: () => Fluent<ZodUnknown>;
+declare const instanceof_: <T extends abstract new (...args: any[]) => any>(cls: T) => Fluent<ZodInstanceof<InstanceType<T>>>;
+declare const object_: <S extends Record<string, ZodLike>>(shape: S) => Fluent<ZodObjectSchema<S>>;
+declare const array: <E extends ZodLike>(element: E) => Fluent<ZodArraySchema<E>>;
+declare const optional: <E extends ZodLike>(element: E) => Fluent<ZodOptional<E>>;
+declare const nullable: <E extends ZodLike>(element: E) => Fluent<ZodNullable<E>>;
+declare const literal: <V extends string | number | boolean>(value: V) => Fluent<ZodLiteral<V>>;
+declare const union: <O extends readonly [ZodLike, ...ZodLike[]]>(options: O) => Fluent<ZodUnion<O>>;
+declare const record: <E extends ZodLike>(element: E) => Fluent<ZodRecord<E>>;
+declare const callback: <F extends (...args: any[]) => any = (...args: unknown[]) => unknown>() => Fluent<ZodCallback<F>>;
 declare const int32: () => ZodNumber;
 declare const uint32: () => ZodNumber;
 declare const float32: () => ZodNumber;
@@ -204,6 +294,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. */
 export declare function fluent<S extends ZodType>(schema: S): Fluent<S>;
@@ -216,6 +310,12 @@ export declare const z: {
     array: typeof array;
     instanceof: typeof instanceof_;
     unknown: typeof unknown_;
+    optional: typeof optional;
+    nullable: typeof nullable;
+    literal: typeof literal;
+    union: typeof union;
+    record: typeof record;
+    callback: typeof callback;
     int32: typeof int32;
     uint32: typeof uint32;
     float32: typeof float32;

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { bindSharedMemories, defineSharedMemory, field, getDefinedSharedMemoryCount, jsonCodec, registerConnectorFactory } from './contract/sharedMemory.js';
 export { reef } from './contract/reef.js';
+export { z, SchemaError } from './contract/zod.js';
+export type { ZodLike } from './contract/zod.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';

package/dist/index.js

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

package/dist/index18.js

@@ -1,59 +1,88 @@
 import { scoped as e } from "./index5.js";
-import { createEffect as t, createMemo as n, createRoot as r, createSignal as i } from "solid-js";
+import { createEffect as t, createMemo as n, createRenderEffect as r, createRoot as i, createSignal as a } from "solid-js";
 //#region src/reactive.ts
-var a = e("reactive");
-function o(e, t) {
+var o = e("reactive");
+function s(e, t) {
 	if (e === t) return !0;
 	if (e == null || t == null) return !1;
 	let n = Object.keys(e), r = Object.keys(t);
 	return n.length === r.length && n.every((n) => Object.is(e[n], t[n]));
 }
-function s(e) {
-	let [t, n] = i(e.read(), { equals: !1 }), r = () => n(() => e.read());
+var c = (e, t) => {
+	let n = e._version;
+	if (!n) throw Error("This connector does not support remote observation.");
+	let r = !1, i = Atomics.load(n.view, n.index);
+	if (typeof Atomics.waitAsync == "function") return o.debug(`observing remote writes (offset ${e.byteOffset}, waitAsync)`), (async () => {
+		for (; !r;) {
+			let a = Atomics.waitAsync(n.view, n.index, i);
+			a.async && await a.value, i = Atomics.load(n.view, n.index), r || (o.trace(`remote write observed (offset ${e.byteOffset})`), t());
+		}
+		o.debug(`stopped observing (offset ${e.byteOffset})`);
+	})(), () => {
+		r = !0;
+	};
+	o.warn(`Atomics.waitAsync unavailable — observing via 50ms poll (offset ${e.byteOffset})`);
+	let a = setInterval(() => {
+		let e = Atomics.load(n.view, n.index);
+		e !== i && (i = e, t());
+	}, 50);
+	return () => {
+		r = !0, clearInterval(a);
+	};
+}, l = null, u = () => {
+	if (l !== null) return l;
+	try {
+		let e = 0, t;
+		i(() => {
+			let [n, i] = a(0);
+			t = i, r(() => {
+				n(), e++;
+			});
+		}), t?.(1), l = e > 1;
+	} catch {
+		l = !1;
+	}
+	return l || o.warn("solid-js resolved to the SSR build — watch() falls back to direct version watching"), l;
+};
+function d(e) {
+	let [t, n] = a(e.read(), { equals: !1 }), r = () => n(() => e.read());
 	return {
 		get: t,
 		peek: () => e.read(),
 		set: (t) => {
 			e.write(t), r();
 		},
-		observeRemote: () => {
-			let t = e._version;
-			if (!t) throw Error("This connector does not support remote observation.");
-			let n = !1, i = Atomics.load(t.view, t.index);
-			if (typeof Atomics.waitAsync == "function") return a.debug(`observing remote writes (offset ${e.byteOffset}, waitAsync)`), (async () => {
-				for (; !n;) {
-					let o = Atomics.waitAsync(t.view, t.index, i);
-					o.async && await o.value, i = Atomics.load(t.view, t.index), n || (a.trace(`remote write observed (offset ${e.byteOffset})`), r());
-				}
-				a.debug(`stopped observing (offset ${e.byteOffset})`);
-			})(), () => {
-				n = !0;
-			};
-			a.warn(`Atomics.waitAsync unavailable — observing via 50ms poll (offset ${e.byteOffset})`);
-			let o = setInterval(() => {
-				let e = Atomics.load(t.view, t.index);
-				e !== i && (i = e, r());
-			}, 50);
-			return () => {
-				n = !0, clearInterval(o);
-			};
-		}
+		observeRemote: () => c(e, r)
 	};
 }
-function c(e, i, o, c) {
-	let l = o ? i : ((e) => e), u = o ?? i, d = s(e), f = d.observeRemote(), p = r((e) => {
+function f(e, r, a, s) {
+	let l = a ? r : ((e) => e), f = a ?? r;
+	if (!u()) {
+		let t = (e, t) => e === void 0 || t === void 0 ? e === t : (s?.equals ?? Object.is)(e, t), n, r = () => {
+			let r = e.read(), i = r == null ? void 0 : l(r);
+			if (i === void 0 || t(n, i)) return;
+			let a = n;
+			n = i, f(i, a);
+		};
+		r();
+		let i = c(e, r);
+		return o.debug(`watching connector at offset ${e.byteOffset} (direct)`), () => {
+			o.debug(`watch stopped (offset ${e.byteOffset})`), i();
+		};
+	}
+	let p = d(e), m = p.observeRemote(), h = i((e) => {
 		let r = n(() => {
-			let e = d.get();
+			let e = p.get();
 			return e == null ? void 0 : l(e);
-		}, void 0, c?.equals ? { equals: (e, t) => e === void 0 || t === void 0 ? e === t : c.equals(e, t) } : void 0);
+		}, void 0, s?.equals ? { equals: (e, t) => e === void 0 || t === void 0 ? e === t : s.equals(e, t) } : void 0);
 		return t((e) => {
 			let t = r();
-			return t !== void 0 && u(t, e), t;
+			return t !== void 0 && f(t, e), t;
 		}), e;
 	});
-	return a.debug(`watching connector at offset ${e.byteOffset}`), () => {
-		a.debug(`watch stopped (offset ${e.byteOffset})`), f(), p();
+	return o.debug(`watching connector at offset ${e.byteOffset}`), () => {
+		o.debug(`watch stopped (offset ${e.byteOffset})`), m(), h();
 	};
 }
 //#endregion
-export { s as reactive, o as shallowEqual, c as watch };
+export { d as reactive, s as shallowEqual, f as watch };

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,9 +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 };
+export { h as SchemaError, g as ZodType, $ as fluent, m as globalRegistry, te as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolljs/core",
-  "version": "0.1.5",
+  "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",

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,

package/src/reactive.ts

@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createRoot, createSignal } from 'solid-js';
+import { createEffect, createMemo, createRenderEffect, createRoot, createSignal } from 'solid-js';
 import { Connector } from './contract/sharedMemory';
 import { scoped } from './log';
 
@@ -40,6 +40,87 @@ export interface ReactiveConnector<T> {
   observeRemote(): () => void;
 }
 
+/**
+ * Park on the connector's shared version counter and invoke `onBump` on each
+ * write — local or remote, both bump it. waitAsync when available, 50ms poll
+ * otherwise. No solid-js involved: this is the whole remote-write mechanism.
+ */
+const watchVersion = <T>(connector: Connector<T>, onBump: () => void): (() => void) => {
+  const version = connector._version;
+  if (!version) {
+    throw new Error('This connector does not support remote observation.');
+  }
+  let stopped = false;
+  let last = Atomics.load(version.view, version.index);
+
+  if (typeof Atomics.waitAsync === 'function') {
+    reactiveLog.debug(`observing remote writes (offset ${connector.byteOffset}, waitAsync)`);
+    void (async () => {
+      while (!stopped) {
+        const result = Atomics.waitAsync(version.view, version.index, last);
+        if (result.async) {
+          await result.value;
+        }
+        last = Atomics.load(version.view, version.index);
+        if (!stopped) {
+          reactiveLog.trace(`remote write observed (offset ${connector.byteOffset})`);
+          onBump();
+        }
+      }
+      reactiveLog.debug(`stopped observing (offset ${connector.byteOffset})`);
+    })();
+    return () => { stopped = true; };
+  }
+
+  reactiveLog.warn(`Atomics.waitAsync unavailable — observing via 50ms poll (offset ${connector.byteOffset})`);
+  const timer = setInterval(() => {
+    const current = Atomics.load(version.view, version.index);
+    if (current !== last) {
+      last = current;
+      onBump();
+    }
+  }, 50);
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+};
+
+/**
+ * Under `node`/`worker`/`deno` export conditions, `solid-js` resolves to the
+ * SSR build — `createEffect` is a no-op, so signal-driven `watch`/`observe`
+ * die silently. Probe once. `createRenderEffect` is the discriminator: it
+ * runs synchronously at creation in BOTH builds but only re-fires on `set`
+ * in the client build. `createEffect` can't be used — the client build
+ * defers it past the synchronous `set` below, probing a false negative.
+ * The write must land AFTER the root's create pass returns for the same
+ * reason (a set issued mid-subscription is swallowed).
+ */
+let solidLive: boolean | null = null;
+const solidIsLive = (): boolean => {
+  if (solidLive !== null) return solidLive;
+  try {
+    let runs = 0;
+    let bump: ((v: number) => number) | undefined;
+    createRoot(() => {
+      const [get, set] = createSignal(0);
+      bump = set;
+      createRenderEffect(() => {
+        get();
+        runs++;
+      });
+    });
+    bump?.(1);
+    solidLive = runs > 1;
+  } catch {
+    solidLive = false;
+  }
+  if (!solidLive) {
+    reactiveLog.warn('solid-js resolved to the SSR build — watch() falls back to direct version watching');
+  }
+  return solidLive;
+};
+
 export function reactive<T>(connector: Connector<T>): ReactiveConnector<T> {
   const [value, setValue] = createSignal<T>(connector.read(), { equals: false });
   const bump = () => setValue(() => connector.read());
@@ -51,47 +132,7 @@ export function reactive<T>(connector: Connector<T>): ReactiveConnector<T> {
       connector.write(v);
       bump();
     },
-    observeRemote: () => {
-      const version = connector._version;
-      if (!version) {
-        throw new Error('This connector does not support remote observation.');
-      }
-      let stopped = false;
-      let last = Atomics.load(version.view, version.index);
-
-      if (typeof Atomics.waitAsync === 'function') {
-        reactiveLog.debug(`observing remote writes (offset ${connector.byteOffset}, waitAsync)`);
-        void (async () => {
-          while (!stopped) {
-            const result = Atomics.waitAsync(version.view, version.index, last);
-            if (result.async) {
-              await result.value;
-            }
-            last = Atomics.load(version.view, version.index);
-            if (!stopped) {
-              reactiveLog.trace(`remote write observed (offset ${connector.byteOffset})`);
-              bump();
-            }
-          }
-          reactiveLog.debug(`stopped observing (offset ${connector.byteOffset})`);
-        })();
-        return () => { stopped = true; };
-      }
-
-      // Fallback for environments without Atomics.waitAsync
-      reactiveLog.warn(`Atomics.waitAsync unavailable — observing via 50ms poll (offset ${connector.byteOffset})`);
-      const timer = setInterval(() => {
-        const current = Atomics.load(version.view, version.index);
-        if (current !== last) {
-          last = current;
-          bump();
-        }
-      }, 50);
-      return () => {
-        stopped = true;
-        clearInterval(timer);
-      };
-    },
+    observeRemote: () => watchVersion(connector, bump),
   };
 }
 
@@ -127,6 +168,30 @@ export function watch<T, S = T>(
   const select = onChange ? (selOrCb as (value: T) => S) : ((v: T) => v as unknown as S);
   const cb = (onChange ?? selOrCb) as (slice: S, previous: S | undefined) => void;
 
+  // SSR solid build (node/worker conditions): effects never re-run, so the
+  // signal pipeline below would silently never emit. Same semantics, driven
+  // straight off the version counter instead.
+  if (!solidIsLive()) {
+    const eq = (a: S | undefined, b: S | undefined): boolean =>
+      a === undefined || b === undefined ? a === b : (options?.equals ?? Object.is)(a, b);
+    let prev: S | undefined;
+    const emit = () => {
+      const v = connector.read() as T | null | undefined;
+      const s = v == null ? undefined : select(v);
+      if (s === undefined || eq(prev, s)) return;
+      const old = prev;
+      prev = s;
+      cb(s, old);
+    };
+    emit();
+    const stop = watchVersion(connector, emit);
+    reactiveLog.debug(`watching connector at offset ${connector.byteOffset} (direct)`);
+    return () => {
+      reactiveLog.debug(`watch stopped (offset ${connector.byteOffset})`);
+      stop();
+    };
+  }
+
   const sig = reactive(connector);
   const stopRemote = sig.observeRemote();
   const dispose = createRoot((d) => {