@atolljs/core 0.1.2 → 0.1.4

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,13 +1,12 @@
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="assets/atoll-dark.svg" />
-  <source media="(prefers-color-scheme: light)" srcset="assets/atoll-light.svg" />
-  <img src="assets/atoll-light.svg" alt="Atoll — islands of framework workers around a shared core" width="280" />
+  <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>
 
-# 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
@@ -182,8 +181,11 @@ manifest also pins `publishConfig.registry` to `registry.npmjs.org`, so the
 destination is declared in the repo rather than resolved from the
 publisher's local npmrc.
 
-Staging needs each package to already exist on the registry, so the first
-release is a manual bootstrap — from the repo root:
+Staging needs each package to already exist on the registry — the script
+pre-flights `npm view` on every package and aborts before anything stages
+if one is missing, so a new package can never leave a release half-staged.
+The first release (and any release adding a package) is therefore a manual
+bootstrap — from the repo root:
 
 ```bash
 npm login                                    # once
@@ -202,7 +204,7 @@ even if compromised. Configure per package (needs the package to exist on
 npm, and npm CLI ≥ 11.10):
 
 ```bash
-for p in core node react vue solidjs svelte angular nextjs nestjs \
+for p in core node react vue solidjs svelte angular nextjs nestjs cli \
          islands react-island vue-island svelte-island solid-island angular-island; do
   npm trust github "@atolljs/$p" --repo jwhenry3/atolljs --file publish.yml --allow-stage-publish -y
   sleep 2

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;