@atolljs/core 0.1.1 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Justin Henry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,7 +1,12 @@
-# AtollJS
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="assets/atoll-horizontal-dark.svg" />
+  <source media="(prefers-color-scheme: light)" srcset="assets/atoll-horizontal-light.svg" />
+  <img src="assets/atoll-horizontal-light.svg" alt="Atoll — islands of framework workers around a shared core" width="420" />
+</picture>
 
-[![CI](https://github.com/jwhenry3/atolljs/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/jwhenry3/atolljs/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/jwhenry3/atolljs/graph/badge.svg?branch=master)](https://codecov.io/gh/jwhenry3/atolljs)
+[![CI](https://github.com/jwhenry3/atolljs/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/jwhenry3/atolljs/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/jwhenry3/atolljs/graph/badge.svg?branch=main)](https://codecov.io/gh/jwhenry3/atolljs)
+[![Socket Badge](https://badge.socket.dev/npm/package/@atolljs/core)](https://badge.socket.dev/npm/package/@atolljs/core)
 
 Typed shared-memory worker pools for TypeScript — deterministic `SharedArrayBuffer`
 layouts, first-class task methods, and cross-thread reactive state. A worker
@@ -9,7 +14,7 @@ atoll: pools and shared workers joined to your app through one shared-memory
 fabric, so work is offloaded as typed method calls while large state stays put
 (zero-copy, no postMessage serialization of the values themselves).
 
-**[Atoll — package documentation](https://jwhenry3.github.io/atolljs/consumer/#/quickstart)**
+**[Atoll — package documentation](https://jwhenry3.github.io/atolljs/consumer/quickstart/)**
 
 ## Install
 
@@ -89,7 +94,7 @@ Shared memory is opt-in: leave `sharedMemory` out of both `defineWorker` and
 `connectWorker` and you get a typed, pooled, cancellable worker RPC that runs
 anywhere Workers do — no isolation headers needed. With shared memory,
 `SharedArrayBuffer` requires
-[cross-origin isolation headers](https://jwhenry3.github.io/atolljs/consumer/#/hosting)
+[cross-origin isolation headers](https://jwhenry3.github.io/atolljs/consumer/hosting/)
 (COOP/COEP) in the browser; Node needs nothing.
 
 ## Packages
@@ -101,35 +106,35 @@ install only what you use.
 
 | Framework | Package | What it is | Docs |
 |---|---|---|---|
-| React | [`@atolljs/react`](https://www.npmjs.com/package/@atolljs/react) | Hooks — `useObservable`, `useSharedValue`, `useTask` | [React guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-react) |
-| Vue | [`@atolljs/vue`](https://www.npmjs.com/package/@atolljs/vue) | Composables — `useObservable`, `useSharedValue`, `useTask` | [Vue guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-vue) |
-| SolidJS | [`@atolljs/solidjs`](https://www.npmjs.com/package/@atolljs/solidjs) | Primitives — `createObservable`, `createSharedValue`, `createTask` | [SolidJS guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-solid) |
-| Svelte | [`@atolljs/svelte`](https://www.npmjs.com/package/@atolljs/svelte) | Svelte 5 rune bindings — `observableValue`, `sharedValue`, `taskState` | [Svelte guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-svelte) |
-| Angular | [`@atolljs/angular`](https://www.npmjs.com/package/@atolljs/angular) | Signals + DI — `observableSignal`, `sharedValue`, `taskState`, `provideAtoll` | [Angular guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-angular) |
-| Next.js | [`@atolljs/nextjs`](https://www.npmjs.com/package/@atolljs/nextjs) | Client-component bindings (React re-export) | [Next.js guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-nextjs) |
-| NestJS | [`@atolljs/nestjs`](https://www.npmjs.com/package/@atolljs/nestjs) | Server-side module/decorators for worker pools | [NestJS guide](https://jwhenry3.github.io/atolljs/consumer/#/fw-nestjs) |
+| React | [`@atolljs/react`](https://www.npmjs.com/package/@atolljs/react) | Hooks — `useObservable`, `useSharedValue`, `useTask` | [React guide](https://jwhenry3.github.io/atolljs/consumer/fw-react/) |
+| Vue | [`@atolljs/vue`](https://www.npmjs.com/package/@atolljs/vue) | Composables — `useObservable`, `useSharedValue`, `useTask` | [Vue guide](https://jwhenry3.github.io/atolljs/consumer/fw-vue/) |
+| SolidJS | [`@atolljs/solidjs`](https://www.npmjs.com/package/@atolljs/solidjs) | Primitives — `createObservable`, `createSharedValue`, `createTask` | [SolidJS guide](https://jwhenry3.github.io/atolljs/consumer/fw-solid/) |
+| Svelte | [`@atolljs/svelte`](https://www.npmjs.com/package/@atolljs/svelte) | Svelte 5 rune bindings — `observableValue`, `sharedValue`, `taskState` | [Svelte guide](https://jwhenry3.github.io/atolljs/consumer/fw-svelte/) |
+| Angular | [`@atolljs/angular`](https://www.npmjs.com/package/@atolljs/angular) | Signals + DI — `observableSignal`, `sharedValue`, `taskState`, `provideAtoll` | [Angular guide](https://jwhenry3.github.io/atolljs/consumer/fw-angular/) |
+| Next.js | [`@atolljs/nextjs`](https://www.npmjs.com/package/@atolljs/nextjs) | Client-component bindings (React re-export) | [Next.js guide](https://jwhenry3.github.io/atolljs/consumer/fw-nextjs/) |
+| NestJS | [`@atolljs/nestjs`](https://www.npmjs.com/package/@atolljs/nestjs) | Server-side module/decorators for worker pools | [NestJS guide](https://jwhenry3.github.io/atolljs/consumer/fw-nestjs/) |
 
 ### Worker islands — render framework trees off the main thread
 
 | Framework | Package | What it is | Docs |
 |---|---|---|---|
-| *(engine)* | [`@atolljs/islands`](https://www.npmjs.com/package/@atolljs/islands) | `mountIsland`, op protocol, proxy DOM, worker runtimes | [Worker islands](https://jwhenry3.github.io/atolljs/consumer/#/islands) |
-| React | [`@atolljs/react-island`](https://www.npmjs.com/package/@atolljs/react-island) | `<Island/>`, `islandComponent`, `lazyIsland` | [React islands](https://jwhenry3.github.io/atolljs/consumer/#/fw-react/worker-islands) |
-| Vue | [`@atolljs/vue-island`](https://www.npmjs.com/package/@atolljs/vue-island) | `useIsland`, `<AtollIsland>` + Vue worker renderer | [Vue islands](https://jwhenry3.github.io/atolljs/consumer/#/fw-vue/worker-islands) |
-| Svelte | [`@atolljs/svelte-island`](https://www.npmjs.com/package/@atolljs/svelte-island) | `use:island`, `createIslandState` + Svelte 5 worker renderer | [Svelte islands](https://jwhenry3.github.io/atolljs/consumer/#/fw-svelte/worker-islands) |
-| SolidJS | [`@atolljs/solid-island`](https://www.npmjs.com/package/@atolljs/solid-island) | `createIsland`, `Island` + `solid-js/universal` worker renderer | [Solid islands](https://jwhenry3.github.io/atolljs/consumer/#/fw-solid/worker-islands) |
-| Angular | [`@atolljs/angular-island`](https://www.npmjs.com/package/@atolljs/angular-island) | `<atoll-island>`, `[atollIsland]` + `Renderer2` worker renderer | [Angular islands](https://jwhenry3.github.io/atolljs/consumer/#/fw-angular/worker-islands) |
+| *(engine)* | [`@atolljs/islands`](https://www.npmjs.com/package/@atolljs/islands) | `mountIsland`, op protocol, proxy DOM, worker runtimes | [Worker islands](https://jwhenry3.github.io/atolljs/consumer/islands/) |
+| React | [`@atolljs/react-island`](https://www.npmjs.com/package/@atolljs/react-island) | `<Island/>`, `islandComponent`, `lazyIsland` | [React islands](https://jwhenry3.github.io/atolljs/consumer/fw-react/worker-islands/) |
+| Vue | [`@atolljs/vue-island`](https://www.npmjs.com/package/@atolljs/vue-island) | `useIsland`, `<AtollIsland>` + Vue worker renderer | [Vue islands](https://jwhenry3.github.io/atolljs/consumer/fw-vue/worker-islands/) |
+| Svelte | [`@atolljs/svelte-island`](https://www.npmjs.com/package/@atolljs/svelte-island) | `use:island`, `createIslandState` + Svelte 5 worker renderer | [Svelte islands](https://jwhenry3.github.io/atolljs/consumer/fw-svelte/worker-islands/) |
+| SolidJS | [`@atolljs/solid-island`](https://www.npmjs.com/package/@atolljs/solid-island) | `createIsland`, `Island`, `islandComponent`, `lazyIsland` + `solid-js/universal` worker renderer | [Solid islands](https://jwhenry3.github.io/atolljs/consumer/fw-solid/worker-islands/) |
+| Angular | [`@atolljs/angular-island`](https://www.npmjs.com/package/@atolljs/angular-island) | `islandComponent` facades typed off `@AngularIsland` worker components, `<atoll-island>`/`[atollIsland]` + `Renderer2` worker renderer | [Angular islands](https://jwhenry3.github.io/atolljs/consumer/fw-angular/worker-islands/) |
 
 ### Runtimes
 
 | Package | What it is | Docs |
 |---|---|---|
-| [`@atolljs/core`](https://www.npmjs.com/package/@atolljs/core) | Core SDK — `defineWorker`/`connectWorker` typed worker clients over `WorkerPool`, shared-memory contracts, `watch`/`observe`, codecs | [Quickstart](https://jwhenry3.github.io/atolljs/consumer/#/quickstart) · [Shared memory](https://jwhenry3.github.io/atolljs/consumer/#/shared-memory) · [Tasks](https://jwhenry3.github.io/atolljs/consumer/#/tasks) |
-| [`@atolljs/node`](https://www.npmjs.com/package/@atolljs/node) | `node:worker_threads` runtime adapter | [Tasks](https://jwhenry3.github.io/atolljs/consumer/#/tasks) |
+| [`@atolljs/core`](https://www.npmjs.com/package/@atolljs/core) | Core SDK — `defineWorker`/`connectWorker` typed worker clients over `WorkerPool`, shared-memory contracts, `watch`/`observe`, codecs | [Quickstart](https://jwhenry3.github.io/atolljs/consumer/quickstart/) · [Shared memory](https://jwhenry3.github.io/atolljs/consumer/shared-memory/) · [Tasks](https://jwhenry3.github.io/atolljs/consumer/tasks/) |
+| [`@atolljs/node`](https://www.npmjs.com/package/@atolljs/node) | `node:worker_threads` runtime adapter | [Tasks](https://jwhenry3.github.io/atolljs/consumer/tasks/) |
 
 ## Documentation
 
-- **[Atoll — package documentation](https://jwhenry3.github.io/atolljs/consumer/#/quickstart)** —
+- **[Atoll — package documentation](https://jwhenry3.github.io/atolljs/consumer/quickstart/)** —
   the consumer-facing site: quickstart, API guides, framework pages, islands,
   hosting & headers.
 - [`docs/`](docs/README.md) — in-repo documentation covering internals,
@@ -144,7 +149,7 @@ packages/<fw>/      independently publishable framework bindings
 packages/incidents/ demo domain package (contract + worker + pool)
 examples/<fw>/      per-framework demo apps
 docs/               in-repo markdown documentation (internals + bindings)
-docs-consumer/      consumer docs site (deploys to GitHub Pages on master)
+docs-consumer/      consumer docs site (deploys to GitHub Pages on main)
 ```
 
 ```bash

package/dist/contract/listSchema.d.ts

@@ -1,4 +1,4 @@
-import { z } from './zod';
+import { z, type Fluent } from './zod';
 import type { ListFieldSpec, ListFields, ListMember } from './sharedMemory';
 /** Maps a list member to the zod shape whose inferred output type is
  *  identical to `ListRecord<F>[K]` — zod members pass through as
@@ -12,7 +12,7 @@ export type ListZodShape<F extends ListFields> = {
 };
 /**
  * Builds a zod object schema from a member map — the shape you would pass
- * to `mz.object(...)` for `field.list({ schema, count })`. Members may be
+ * to `reef.object(...)` for `field.list({ schema, count })`. Members may be
  * spec tokens or zod schemas; the result's `z.infer` is the record type:
  *
  * ```ts
@@ -25,7 +25,7 @@ export type ListZodShape<F extends ListFields> = {
  * capacity the connector enforces; zod `z.string().meta({ bytes: n })`
  * members get the same bound attached to the declared schema.
  */
-export declare function listSchema<F extends ListFields>(fields: F): z.ZodObject<ListZodShape<F>>;
+export declare function listSchema<F extends ListFields>(fields: F): Fluent<z.ZodMiniObject<ListZodShape<F>>>;
 /**
  * Compiles one fixed-layout member — a spec token or a zod schema — to its
  * binary layout form. Throws for members that can't express a fixed-width
@@ -43,5 +43,5 @@ export declare function zodArrayInfo(schema: unknown): {
     element: z.ZodTypeAny;
     capacity: number | null;
 } | null;
-/** The byte budget carried by `mz.string(n)` / `z.string().meta({ bytes: n })` — null otherwise. */
+/** The byte budget carried by `reef.string(n)` / `z.string().meta({ bytes: n })` — null otherwise. */
 export declare function zodStringBytes(schema: unknown): number | null;

package/dist/contract/reef.d.ts

@@ -0,0 +1,377 @@
+import { z } from './zod';
+/**
+ * Reef — the atoll's structural barrier: the fixed-width schema
+ * vocabulary standing between your data and the raw buffer. Every helper
+ * mints a schema the layout compiler can read a byte width from: number
+ * formats (`reef.u32()`), int bounds (`reef.int(0, 3)` → u8), byte budgets
+ * (`reef.string(10)`), or flags (`reef.boolean()` → u8). There are no unfixed
+ * members — `reef.number()`/`z.date()`/`z.enum()` aren't exposed because they
+ * can't promise a width.
+ *
+ * Schemas are minted by the vendored engine in `./zod.ts` — a zod-shaped
+ * `_zod.def` surface (`type`/`format`/`checks`/`shape`/`element`), so no
+ * zod dependency ships. Width coverage: int32/uint32/float32/float64/
+ * int64/uint64 are format-tagged; reef fills the gaps (i8/u8/i16/u16 via
+ * bounded ints, which the compiler narrows identically) so all ten scalar
+ * kinds have one spelling.
+ *
+ * Composition derives byte width upward — `reef.object({...})` members lay out
+ * as a fixed record (field.object derives byteLength from it, no maxBytes),
+ * `reef.array(el).max(n)` bounds element capacity for field.array, and
+ * `reef.string(n)` carries the budget for field.string. Schemas keep the
+ * classic chain spellings — `.meta()`, `.refine()`, `.max()`/`.length()` —
+ * and consumer-supplied zod schemas introspect identically through their
+ * `_zod.def`, so `reef.object({ id: z.uint32() })` mixes freely.
+ */
+export declare const reef: {
+    i8: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    u8: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    i16: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    u16: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    i32: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    u32: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    f32: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    f64: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    i64: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: bigint;
+            input: bigint;
+            def: import("./zod").SchemaDef & {
+                type: 'bigint';
+            };
+        };
+        inner(v: unknown): bigint;
+        parse(value: unknown): bigint;
+        safeParse(value: unknown): {
+            success: true;
+            data: bigint;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    u64: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: bigint;
+            input: bigint;
+            def: import("./zod").SchemaDef & {
+                type: 'bigint';
+            };
+        };
+        inner(v: unknown): bigint;
+        parse(value: unknown): bigint;
+        safeParse(value: unknown): {
+            success: true;
+            data: bigint;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+    }>;
+    /** Bounded int — compiles to the narrowest covering kind (0..3 → u8). */
+    int: (min: number, max: number) => import("./zod").Fluent<{
+        readonly _zod: {
+            output: number;
+            input: number;
+            def: import("./zod").SchemaDef & {
+                type: 'number';
+            };
+        };
+        inner(v: unknown): number;
+        parse(value: unknown): number;
+        safeParse(value: unknown): {
+            success: true;
+            data: number;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    /** A flag byte — reads and writes as boolean. */
+    boolean: () => import("./zod").Fluent<{
+        readonly _zod: {
+            output: boolean;
+            input: boolean;
+            def: import("./zod").SchemaDef & {
+                type: 'boolean';
+            };
+        };
+        inner(v: unknown): boolean;
+        parse(value: unknown): boolean;
+        safeParse(value: unknown): {
+            success: true;
+            data: boolean;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    /** Fixed-capacity inline UTF-8 string — `bytes` is the byte budget. The
+     *  schema itself refuses over-budget values, so `.parse` and connector
+     *  writes enforce the same limit. */
+    string: (bytes: number) => import("./zod").Fluent<{
+        readonly _zod: {
+            output: string;
+            input: string;
+            def: import("./zod").SchemaDef & {
+                type: 'string';
+            };
+        };
+        inner(v: unknown): string;
+        parse(value: unknown): string;
+        safeParse(value: unknown): {
+            success: true;
+            data: string;
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    /** A fixed-layout record shape — every member must be a fixed-width schema. */
+    object: <S extends z.ZodRawShape>(shape: S) => import("./zod").Fluent<{
+        readonly _zod: {
+            output: { [K in keyof S]: S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never; };
+            input: { [K in keyof S]: S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never; };
+            def: import("./zod").SchemaDef & {
+                type: 'object';
+                shape: S;
+            };
+        };
+        get shape(): S;
+        inner(v: unknown): { [K in keyof S]: S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? O : never; };
+        parse(value: unknown): { [K in keyof S]: S[K] extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? O : never; };
+        safeParse(value: unknown): {
+            success: true;
+            data: { [K in keyof S]: S[K] extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never; };
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+    /** A fixed-stride element — bound it with `.max(n)` or `.length(n)` before field.array. */
+    array: <E extends z.ZodTypeAny>(element: E) => import("./zod").Fluent<{
+        readonly _zod: {
+            output: (E extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never)[];
+            input: (E extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never)[];
+            def: import("./zod").SchemaDef & {
+                type: 'array';
+                element: E;
+            };
+        };
+        inner(v: unknown): (E extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? O : never)[];
+        parse(value: unknown): (E extends {
+            _zod: {
+                output: infer O;
+            };
+        } ? O : never)[];
+        safeParse(value: unknown): {
+            success: true;
+            data: (E extends {
+                _zod: {
+                    output: infer O;
+                };
+            } ? O : never)[];
+        } | {
+            success: false;
+            error: unknown;
+        };
+        check(...checks: import("./zod").Check[]): /*elided*/ any;
+        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>;
+};

package/dist/contract/sharedMemory.d.ts

@@ -91,7 +91,7 @@ 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)`).
+ * expresses the same thing (`reef.u32()`, `reef.int(0, 3)`, `reef.string(n)`).
  * Schemas are compiled to tokens for layout and kept as the field's
  * validation schema — one declaration.
  */
@@ -102,7 +102,7 @@ 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
+     * The declared record schema — a `reef.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.
      */
@@ -173,7 +173,7 @@ export interface FixedArrayDescriptor<T = unknown> extends FieldDescriptor<T[]>
 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()`);
+     * (`reef` helpers, `z.uint32()`, bounded ints, `reef.string(n)`, `z.boolean()`);
      * `byteLength` derives from the member widths. Compile fails loudly for
      * members with no fixed width (unbounded strings, nested objects).
      */
@@ -193,9 +193,9 @@ interface ObjectFieldFactory {
 interface ArrayFieldFactory {
     /**
      * Inline fixed layout — the schema is a bounded zod array
-     * (`mz.array(mz.u32()).max(n)`, `.length(n)`); `byteLength` derives from
+     * (`reef.array(reef.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.
+     * (scalars, `reef.string(n)`, booleans) — use `field.list` for record arrays.
      */
     <S extends z.ZodArray>(options: {
         schema: S;
@@ -216,7 +216,7 @@ interface StringFieldFactory {
         maxBytes: number;
         schema?: Schema<string>;
     }): FieldDescriptor<string>;
-    /** Budget derived from the schema — `mz.string(n)` / `z.string().meta({ bytes: n })`. */
+    /** Budget derived from the schema — `reef.string(n)` / `z.string().meta({ bytes: n })`. */
     (options: {
         schema: Schema<string>;
     }): FieldDescriptor<string>;
@@ -243,9 +243,9 @@ export declare const field: {
         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`
+     * A fixed-layout array of `count` records. `schema` is a `reef.object` of
+     * fixed-width members (`reef.u32()`, `reef.int(0, 3)`, `reef.string(n)`,
+     * `reef.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.
      */
@@ -255,13 +255,13 @@ export declare const field: {
     }) => ListDescriptor<S>;
 };
 /**
- * The zod schema for a field's logical unit: the declared `schema` for
+ * The 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
+ * A 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.
  */
@@ -280,9 +280,9 @@ export declare class SharedMemory<S extends SharedSpec = SharedSpec> {
     /** 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
+     * One 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.
+     * scalar schemas elsewhere.
      */
     readonly schemas: SpecSchemas<S>;
     private readonly codec;