@atolljs/core 0.1.4 → 0.1.6

package/dist/contract/listSchema.d.ts

@@ -1,5 +1,5 @@
-import { z, type Fluent } from './zod';
-import type { ListFieldSpec, ListFields, ListMember } from './sharedMemory';
+import { z, type Fluent } from './zod.js';
+import type { ListFieldSpec, ListFields, ListMember } from './sharedMemory.js';
 /** Maps a list member to the zod shape whose inferred output type is
  *  identical to `ListRecord<F>[K]` — zod members pass through as
  *  themselves so declared bounds (e.g. `.max(3)`) stay in effect. */

package/dist/contract/msgpackrCodec.d.ts

@@ -1,2 +1,2 @@
-import type { Codec } from './sharedMemory';
+import type { Codec } from './sharedMemory.js';
 export declare const msgpackrCodec: Codec;

package/dist/contract/reef.d.ts

@@ -1,4 +1,4 @@
-import { z } from './zod';
+import { z } from './zod.js';
 /**
  * Reef — the atoll's structural barrier: the fixed-width schema
  * vocabulary standing between your data and the raw buffer. Every helper
@@ -24,11 +24,11 @@ import { z } from './zod';
  * `_zod.def`, so `reef.object({ id: z.uint32() })` mixes freely.
  */
 export declare const reef: {
-    i8: () => import("./zod").Fluent<{
+    i8: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -41,14 +41,14 @@ export declare const reef: {
             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<{
+        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<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -61,14 +61,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
-    }>;
-    i16: () => import("./zod").Fluent<{
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
+    }>>;
+    i16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -81,14 +81,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
-    }>;
-    u16: () => import("./zod").Fluent<{
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
+    }>>;
+    u16: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -101,14 +101,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
-    }>;
-    i32: () => import("./zod").Fluent<{
+        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;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -121,14 +121,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    u32: () => import("./zod").Fluent<{
+    u32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -141,14 +141,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    f32: () => import("./zod").Fluent<{
+    f32: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -161,14 +161,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    f64: () => import("./zod").Fluent<{
+    f64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -181,14 +181,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): any;
     }>;
-    i64: () => import("./zod").Fluent<{
+    i64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: bigint;
             input: bigint;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'bigint';
             };
         };
@@ -201,14 +201,14 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
     }>;
-    u64: () => import("./zod").Fluent<{
+    u64: () => import("./zod.js").Fluent<{
         readonly _zod: {
             output: bigint;
             input: bigint;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'bigint';
             };
         };
@@ -221,15 +221,15 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): any;
+        check(...checks: import("./zod.js").Check[]): any;
+        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").Fluent<{
+    int: (min: number, max: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: number;
             input: number;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'number';
             };
         };
@@ -242,15 +242,15 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+        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").Fluent<{
+    boolean: () => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: boolean;
             input: boolean;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'boolean';
             };
         };
@@ -263,17 +263,17 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+        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").Fluent<{
+    string: (bytes: number) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: string;
             input: string;
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'string';
             };
         };
@@ -286,54 +286,114 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+        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").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; };
-            def: import("./zod").SchemaDef & {
+            } ? 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").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+        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").Fluent<{
+    array: <E extends z.ZodTypeAny>(element: E) => import("./zod.js").Fluent<import("./zod.js").Fluent<{
         readonly _zod: {
             output: (E extends {
                 _zod: {
@@ -345,7 +405,7 @@ export declare const reef: {
                     output: infer O;
                 };
             } ? O : never)[];
-            def: import("./zod").SchemaDef & {
+            def: import("./zod.js").SchemaDef & {
                 type: 'array';
                 element: E;
             };
@@ -371,7 +431,7 @@ export declare const reef: {
             success: false;
             error: unknown;
         };
-        check(...checks: import("./zod").Check[]): /*elided*/ any;
-        register(registry: import("./zod").Registry, meta: Record<string, unknown>): /*elided*/ any;
-    }>;
+        check(...checks: import("./zod.js").Check[]): /*elided*/ any;
+        register(registry: import("./zod.js").Registry, meta: Record<string, unknown>): /*elided*/ any;
+    }>>;
 };

package/dist/contract/sharedMemory.d.ts

@@ -1,5 +1,5 @@
-import type { Prettify, Schema } from './types';
-import { z } from './zod';
+import type { Prettify, Schema } from './types.js';
+import { z } from './zod.js';
 /**
  * Declares the datatype of a single field in the shared memory contract.
  * `byteLength` is the fixed region reserved for the field; structured types

package/dist/contract/types.d.ts

@@ -1,4 +1,4 @@
-import type { SharedAccess, SharedMemory, SharedSpec } from './sharedMemory';
+import type { SharedAccess, SharedMemory, SharedSpec } from './sharedMemory.js';
 export type ViewType = 'Int32' | 'Float64' | 'BigInt64' | 'Uint8';
 /**
  * Minimal validation contract — compatible with zod schemas (`z.object(...)`)

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;