typesea 0.1.0 → 0.3.0

package/dist/builders/object/types.js

@@ -1,5 +1,7 @@
 /**
  * @file types.ts
  * @brief Object builder type algebra.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export {};

package/dist/builders/runtime.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file runtime.ts
+ * @brief Runtime-object guard builders.
+ * @details These builders describe JavaScript object domains that JSON Schema
+ * and AOT source cannot faithfully serialize.
+ */
+import { BaseGuard, type Guard, type Infer, type Presence } from "../guard/index.js";
+export type InstanceConstructor<TValue> = abstract new (...args: never[]) => TValue;
+export type JsonPrimitive = string | number | boolean | null;
+export interface JsonArray {
+    readonly length: number;
+    readonly [index: number]: JsonValue;
+}
+export interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+export type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+/**
+ * @brief Build a guard backed by ordinary instanceof semantics.
+ * @param constructor Constructor function used as the instance domain.
+ * @returns Fresh guard accepting values whose prototype chain matches constructor.
+ * @throws TypeError when constructor is not callable.
+ */
+export declare function instanceOf<TValue>(constructor: InstanceConstructor<TValue>): BaseGuard<TValue>;
+/**
+ * @brief Require one own data property after a base guard succeeds.
+ * @param base Guard applied to the candidate value first.
+ * @param key Own string property key to inspect.
+ * @param value Guard applied to the property value.
+ * @returns Fresh guard preserving the base domain and recording the property type.
+ */
+export declare function property<TBase extends Guard<unknown, Presence>, const TKey extends string, TValue extends Guard<unknown, Presence>>(base: TBase, key: TKey, value: TValue): BaseGuard<Infer<TBase> & Readonly<Record<TKey, Infer<TValue>>>>;
+/**
+ * @brief Build a recursive JSON-value guard.
+ * @returns Fresh guard accepting JSON-serializable values.
+ * @details The guard accepts finite numbers because TypeSea number semantics
+ * reject NaN and infinities. Object values are string-keyed records.
+ */
+export declare function json(): BaseGuard<JsonValue>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/builders/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/builders/runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,SAAS,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAIrF,MAAM,MAAM,mBAAmB,CAAC,MAAM,IAClC,QAAQ,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,MAAM,CAAC;AAE9C,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE7D,MAAM,WAAW,SAAS;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,UAAU;IACvB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,MAAM,SAAS,GACf,aAAa,GACb,SAAS,GACT,UAAU,CAAC;AAEjB;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAC7B,WAAW,EAAE,mBAAmB,CAAC,MAAM,CAAC,GACzC,SAAS,CAAC,MAAM,CAAC,CAcnB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACpB,KAAK,SAAS,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EACtC,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,MAAM,SAAS,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAEvC,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,IAAI,EACT,KAAK,EAAE,MAAM,GACd,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAUjE;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,IAAI,SAAS,CAAC,SAAS,CAAC,CAU3C"}

package/dist/builders/runtime.js

@@ -0,0 +1,150 @@
+/**
+ * @file runtime.ts
+ * @brief Runtime-object guard builders.
+ * @details These builders describe JavaScript object domains that JSON Schema
+ * and AOT source cannot faithfully serialize.
+ */
+import { SchemaTag } from "../kind/index.js";
+import { BaseGuard } from "../guard/index.js";
+import { readGuardSchema } from "../internal/index.js";
+/**
+ * @brief Build a guard backed by ordinary instanceof semantics.
+ * @param constructor Constructor function used as the instance domain.
+ * @returns Fresh guard accepting values whose prototype chain matches constructor.
+ * @throws TypeError when constructor is not callable.
+ */
+export function instanceOf(constructor) {
+    const rawConstructor = constructor;
+    if (typeof rawConstructor !== "function") {
+        throw new TypeError("instanceOf constructor must be a function");
+    }
+    if (!hasObjectPrototype(rawConstructor)) {
+        throw new TypeError("instanceOf constructor must expose an object prototype");
+    }
+    const ctor = rawConstructor;
+    return new BaseGuard({
+        tag: SchemaTag.InstanceOf,
+        constructor: ctor,
+        name: readConstructorName(ctor)
+    });
+}
+/**
+ * @brief Require one own data property after a base guard succeeds.
+ * @param base Guard applied to the candidate value first.
+ * @param key Own string property key to inspect.
+ * @param value Guard applied to the property value.
+ * @returns Fresh guard preserving the base domain and recording the property type.
+ */
+export function property(base, key, value) {
+    if (typeof key !== "string") {
+        throw new TypeError("property key must be a string");
+    }
+    return new BaseGuard({
+        tag: SchemaTag.Property,
+        base: readGuardSchema(base, "property base"),
+        key,
+        value: readGuardSchema(value, "property value")
+    });
+}
+/**
+ * @brief Build a recursive JSON-value guard.
+ * @returns Fresh guard accepting JSON-serializable values.
+ * @details The guard accepts finite numbers because TypeSea number semantics
+ * reject NaN and infinities. Object values are string-keyed records.
+ */
+export function json() {
+    let cached;
+    const root = new BaseGuard({
+        tag: SchemaTag.Lazy,
+        get: () => {
+            cached ??= makeJsonSchema(root.schema);
+            return cached;
+        }
+    });
+    return root;
+}
+/**
+ * @brief Materialize the recursive JSON schema after the root guard exists.
+ * @param root Recursive root schema used by arrays and records.
+ * @returns Union schema for every JSON value variant.
+ */
+function makeJsonSchema(root) {
+    return {
+        tag: SchemaTag.Union,
+        options: [
+            {
+                tag: SchemaTag.String,
+                checks: []
+            },
+            {
+                tag: SchemaTag.Number,
+                checks: []
+            },
+            {
+                tag: SchemaTag.Boolean
+            },
+            {
+                tag: SchemaTag.Literal,
+                value: null
+            },
+            {
+                tag: SchemaTag.Array,
+                item: root,
+                checks: []
+            },
+            {
+                tag: SchemaTag.Refine,
+                inner: {
+                    tag: SchemaTag.Record,
+                    value: root
+                },
+                predicate: isJsonObject,
+                name: "json_object"
+            }
+        ]
+    };
+}
+/**
+ * @brief Accept only JSON object containers.
+ * @param value Candidate value already checked as a record.
+ * @returns True for ordinary or null-prototype objects.
+ */
+function isJsonObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * @brief Read a stable diagnostic name from a constructor function.
+ * @param constructor Function supplied to instanceOf.
+ * @returns Constructor name or a generic fallback.
+ */
+function readConstructorName(constructor) {
+    const descriptor = Object.getOwnPropertyDescriptor(constructor, "name");
+    const name = descriptor !== undefined && "value" in descriptor
+        ? descriptor.value
+        : undefined;
+    return descriptor !== undefined &&
+        "value" in descriptor &&
+        typeof name === "string" &&
+        name.length !== 0
+        ? name
+        : "constructor";
+}
+/**
+ * @brief Check that a function can participate in ordinary instance checks.
+ * @param constructor Function supplied to instanceOf.
+ * @returns True when the function exposes an object prototype slot.
+ */
+function hasObjectPrototype(constructor) {
+    const descriptor = Object.getOwnPropertyDescriptor(constructor, "prototype");
+    if (descriptor === undefined ||
+        !("value" in descriptor)) {
+        return false;
+    }
+    const prototype = descriptor.value;
+    return (typeof prototype === "object" && prototype !== null) ||
+        typeof prototype === "function";
+}

package/dist/builders/scalar.d.ts

@@ -1,39 +1,79 @@
 /**
  * @file scalar.ts
  * @brief Primitive and literal guard builders.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
-import { BaseGuard, NumberGuard, StringGuard } from "../guard/index.js";
+import { BaseGuard, DateGuard, NumberGuard, StringGuard } from "../guard/index.js";
 import type { LiteralValue } from "../schema/index.js";
+export type EnumValues = readonly [string, ...string[]];
 /**
- * @brief string guard.
+ * @brief Shared string guard singleton.
+ * @details Primitive guards are immutable, so exporting one instance avoids
+ * allocation for the common `t.string` path.
  */
 export declare const stringGuard: StringGuard<"required">;
 /**
- * @brief unknown guard.
+ * @brief Shared unknown guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const unknownGuard: BaseGuard<unknown, "required">;
 /**
- * @brief never guard.
+ * @brief Shared never guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const neverGuard: BaseGuard<never, "required">;
 /**
- * @brief number guard.
+ * @brief Shared finite number guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const numberGuard: NumberGuard<"required">;
 /**
- * @brief bigint guard.
+ * @brief Shared valid Date guard singleton.
+ * @details Date validation accepts Date objects whose time value is finite.
+ * Invalid Date instances are rejected.
+ */
+export declare const dateGuard: DateGuard<"required">;
+/**
+ * @brief Shared bigint guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const bigintGuard: BaseGuard<bigint, "required">;
 /**
- * @brief symbol guard.
+ * @brief Shared symbol guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const symbolGuard: BaseGuard<symbol, "required">;
 /**
- * @brief boolean guard.
+ * @brief Shared boolean guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export declare const booleanGuard: BaseGuard<boolean, "required">;
+export declare const nullGuard: BaseGuard<null, "required">;
+export declare const undefinedGuard: BaseGuard<undefined, "required">;
+export declare const voidGuard: BaseGuard<undefined, "required">;
 /**
- * @brief literal.
+ * @brief Build a literal guard after rejecting non-literal runtime values.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
+ * @param value Literal value to match with Object.is.
+ * @returns Fresh guard for exactly the supplied literal.
+ * @throws TypeError when the value cannot be represented as a TypeSea literal.
  */
 export declare function literal<const TValue extends LiteralValue>(value: TValue): BaseGuard<TValue>;
+/**
+ * @brief Build a string literal enum guard.
+ * @param values Non-empty tuple of string literals.
+ * @returns Fresh guard accepting exactly one supplied enum member.
+ * @throws TypeError when values are empty, non-strings, or duplicated.
+ * @details The public export is aliased as `enum`; this internal name avoids
+ * spelling a reserved word as a local binding.
+ */
+export declare function enumValues<const TValues extends EnumValues>(values: TValues): BaseGuard<TValues[number]>;
 //# sourceMappingURL=scalar.d.ts.map

package/dist/builders/scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalar.d.ts","sourceRoot":"","sources":["../../src/builders/scalar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,SAAS,EACT,WAAW,EACX,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD;;GAEG;AACH,eAAO,MAAM,WAAW,yBAGtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,gCAEvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,UAAU,8BAErB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW,yBAGtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW,+BAEtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW,+BAEtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,gCAEvB,CAAC;AAEH;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,MAAM,SAAS,YAAY,EACvD,KAAK,EAAE,MAAM,GACZ,SAAS,CAAC,MAAM,CAAC,CAQnB"}
+{"version":3,"file":"scalar.d.ts","sourceRoot":"","sources":["../../src/builders/scalar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACH,SAAS,EACT,SAAS,EACT,WAAW,EACX,WAAW,EACd,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,YAAY,EAAU,MAAM,oBAAoB,CAAC;AAG/D,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,WAAW,yBAGtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAEvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,8BAErB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,yBAGtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,SAAS,uBAGpB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,+BAEtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,+BAEtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,gCAEvB,CAAC;AAEH,eAAO,MAAM,SAAS,6BAGpB,CAAC;AAEH,eAAO,MAAM,cAAc,kCAGzB,CAAC;AAEH,eAAO,MAAM,SAAS,kCAAiB,CAAC;AAExC;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,MAAM,SAAS,YAAY,EACrD,KAAK,EAAE,MAAM,GACd,SAAS,CAAC,MAAM,CAAC,CAYnB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,OAAO,SAAS,UAAU,EACvD,MAAM,EAAE,OAAO,GAChB,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CA0B5B"}

package/dist/builders/scalar.js

@@ -1,63 +1,141 @@
 /**
  * @file scalar.ts
  * @brief Primitive and literal guard builders.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 import { SchemaTag } from "../kind/index.js";
-import { BaseGuard, NumberGuard, StringGuard } from "../guard/index.js";
+import { BaseGuard, DateGuard, NumberGuard, StringGuard } from "../guard/index.js";
 import { isLiteralValue } from "../schema/index.js";
 /**
- * @brief string guard.
+ * @brief Shared string guard singleton.
+ * @details Primitive guards are immutable, so exporting one instance avoids
+ * allocation for the common `t.string` path.
  */
 export const stringGuard = new StringGuard({
     tag: SchemaTag.String,
     checks: []
 });
 /**
- * @brief unknown guard.
+ * @brief Shared unknown guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const unknownGuard = new BaseGuard({
     tag: SchemaTag.Unknown
 });
 /**
- * @brief never guard.
+ * @brief Shared never guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const neverGuard = new BaseGuard({
     tag: SchemaTag.Never
 });
 /**
- * @brief number guard.
+ * @brief Shared finite number guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const numberGuard = new NumberGuard({
     tag: SchemaTag.Number,
     checks: []
 });
 /**
- * @brief bigint guard.
+ * @brief Shared valid Date guard singleton.
+ * @details Date validation accepts Date objects whose time value is finite.
+ * Invalid Date instances are rejected.
+ */
+export const dateGuard = new DateGuard({
+    tag: SchemaTag.Date,
+    checks: []
+});
+/**
+ * @brief Shared bigint guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const bigintGuard = new BaseGuard({
     tag: SchemaTag.BigInt
 });
 /**
- * @brief symbol guard.
+ * @brief Shared symbol guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const symbolGuard = new BaseGuard({
     tag: SchemaTag.Symbol
 });
 /**
- * @brief boolean guard.
+ * @brief Shared boolean guard singleton.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export const booleanGuard = new BaseGuard({
     tag: SchemaTag.Boolean
 });
+export const nullGuard = new BaseGuard({
+    tag: SchemaTag.Literal,
+    value: null
+});
+export const undefinedGuard = new BaseGuard({
+    tag: SchemaTag.Literal,
+    value: undefined
+});
+export const voidGuard = undefinedGuard;
 /**
- * @brief literal.
+ * @brief Build a literal guard after rejecting non-literal runtime values.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
+ * @param value Literal value to match with Object.is.
+ * @returns Fresh guard for exactly the supplied literal.
+ * @throws TypeError when the value cannot be represented as a TypeSea literal.
  */
 export function literal(value) {
     if (!isLiteralValue(value)) {
         throw new TypeError("literal value must be a primitive literal");
     }
+    /*
+     * Literal schemas store the runtime value directly. Rejecting compound input
+     * here keeps later equality checks side-effect free and serializable.
+     */
     return new BaseGuard({
         tag: SchemaTag.Literal,
         value
     });
 }
+/**
+ * @brief Build a string literal enum guard.
+ * @param values Non-empty tuple of string literals.
+ * @returns Fresh guard accepting exactly one supplied enum member.
+ * @throws TypeError when values are empty, non-strings, or duplicated.
+ * @details The public export is aliased as `enum`; this internal name avoids
+ * spelling a reserved word as a local binding.
+ */
+export function enumValues(values) {
+    const rawValues = values;
+    if (!Array.isArray(rawValues) || rawValues.length === 0) {
+        throw new TypeError("enum values must be a non-empty string array");
+    }
+    const checkedValues = rawValues;
+    const options = new Array(checkedValues.length);
+    for (let index = 0; index < checkedValues.length; index += 1) {
+        const value = checkedValues[index];
+        if (typeof value !== "string") {
+            throw new TypeError("enum values must be strings");
+        }
+        for (let seen = 0; seen < index; seen += 1) {
+            if (Object.is(checkedValues[seen], value)) {
+                throw new TypeError("enum values must be unique");
+            }
+        }
+        options[index] = {
+            tag: SchemaTag.Literal,
+            value
+        };
+    }
+    return new BaseGuard({
+        tag: SchemaTag.Union,
+        options
+    });
+}

package/dist/builders/table.d.ts

@@ -1,41 +1,71 @@
 /**
  * @file table.ts
  * @brief Frozen public builder table.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 import { asyncDecoder, asyncPipe, asyncRefine, asyncTransform } from "../async/index.js";
-import { decoder, pipe, transform } from "../decoder/index.js";
-import { array, discriminatedUnion, intersect, record, tuple, union } from "./composite.js";
-import { lazy, nullable, optional, refine, undefinedable } from "./modifier.js";
-import { extend, object, omit, partial, pick, strictObject } from "./object/index.js";
-import { literal } from "./scalar.js";
+import { catchValue, codec, decoder, defaultValue, pipe, prefault, transform } from "../decoder/index.js";
+import { array, discriminatedUnion, intersect, map, record, set, tuple, union } from "./composite.js";
+import { lazy, nullable, nullish, optional, refine, undefinedable } from "./modifier.js";
+import { catchall, deepPartial, extend, merge, object, omit, partial, passthrough, pick, required, safeExtend, strict, strictObject, strip } from "./object/index.js";
+import { enumValues, literal } from "./scalar.js";
+import { instanceOf, json, property } from "./runtime.js";
 /**
  * @brief t.
+ * @details Frozen namespace of all public builders. Freezing prevents accidental
+ * mutation of shared singleton guards and helper functions after module load.
  */
 export declare const t: Readonly<{
     readonly unknown: import("../index.js").BaseGuard<unknown, "required">;
     readonly never: import("../index.js").BaseGuard<never, "required">;
     readonly string: import("../index.js").StringGuard<"required">;
     readonly number: import("../index.js").NumberGuard<"required">;
+    readonly date: import("../index.js").DateGuard<"required">;
     readonly bigint: import("../index.js").BaseGuard<bigint, "required">;
     readonly symbol: import("../index.js").BaseGuard<symbol, "required">;
     readonly boolean: import("../index.js").BaseGuard<boolean, "required">;
+    readonly null: import("../index.js").BaseGuard<null, "required">;
+    readonly undefined: import("../index.js").BaseGuard<undefined, "required">;
+    readonly void: import("../index.js").BaseGuard<undefined, "required">;
     readonly literal: typeof literal;
+    readonly enum: typeof enumValues;
+    readonly enumValues: typeof enumValues;
     readonly array: typeof array;
     readonly tuple: typeof tuple;
     readonly record: typeof record;
+    readonly map: typeof map;
+    readonly set: typeof set;
+    readonly instanceOf: typeof instanceOf;
+    readonly property: typeof property;
+    readonly json: typeof json;
     readonly decoder: typeof decoder;
+    readonly default: typeof defaultValue;
+    readonly defaultValue: typeof defaultValue;
+    readonly prefault: typeof prefault;
+    readonly catch: typeof catchValue;
+    readonly codec: typeof codec;
     readonly object: typeof object;
     readonly strictObject: typeof strictObject;
     readonly extend: typeof extend;
+    readonly merge: typeof merge;
     readonly pick: typeof pick;
     readonly omit: typeof omit;
     readonly partial: typeof partial;
+    readonly deepPartial: typeof deepPartial;
+    readonly required: typeof required;
+    readonly safeExtend: typeof safeExtend;
+    readonly strict: typeof strict;
+    readonly passthrough: typeof passthrough;
+    readonly strip: typeof strip;
+    readonly catchall: typeof catchall;
     readonly union: typeof union;
     readonly intersect: typeof intersect;
     readonly discriminatedUnion: typeof discriminatedUnion;
     readonly optional: typeof optional;
     readonly undefinedable: typeof undefinedable;
     readonly nullable: typeof nullable;
+    readonly nullish: typeof nullish;
     readonly lazy: typeof lazy;
     readonly refine: typeof refine;
     readonly transform: typeof transform;

package/dist/builders/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/builders/table.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,EAAU,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EACL,KAAK,EACL,kBAAkB,EAClB,SAAS,EACT,MAAM,EACN,KAAK,EACL,KAAK,EACN,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,MAAM,EACN,MAAM,EACN,IAAI,EACJ,OAAO,EACP,IAAI,EACJ,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAGL,OAAO,EAMR,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCH,CAAC"}
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/builders/table.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACzF,OAAO,EACH,UAAU,EACV,KAAK,EAEL,OAAO,EACP,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,SAAS,EACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACH,KAAK,EACL,kBAAkB,EAClB,SAAS,EACT,GAAG,EACH,MAAM,EACN,GAAG,EACH,KAAK,EACL,KAAK,EACR,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACH,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,MAAM,EACN,aAAa,EAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,QAAQ,EACR,WAAW,EACX,MAAM,EACN,KAAK,EACL,MAAM,EACN,IAAI,EACJ,OAAO,EACP,WAAW,EACX,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,MAAM,EACN,YAAY,EACZ,KAAK,EACR,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAIH,UAAU,EACV,OAAO,EASV,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,UAAU,EACV,IAAI,EACJ,QAAQ,EACX,MAAM,cAAc,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DH,CAAC"}

package/dist/builders/table.js

@@ -1,41 +1,71 @@
 /**
  * @file table.ts
  * @brief Frozen public builder table.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 import { asyncDecoder, asyncPipe, asyncRefine, asyncTransform } from "../async/index.js";
-import { coerce, decoder, pipe, transform } from "../decoder/index.js";
-import { array, discriminatedUnion, intersect, record, tuple, union } from "./composite.js";
-import { lazy, nullable, optional, refine, undefinedable } from "./modifier.js";
-import { extend, object, omit, partial, pick, strictObject } from "./object/index.js";
-import { bigintGuard, booleanGuard, literal, neverGuard, numberGuard, stringGuard, symbolGuard, unknownGuard } from "./scalar.js";
+import { catchValue, codec, coerce, decoder, defaultValue, pipe, prefault, transform } from "../decoder/index.js";
+import { array, discriminatedUnion, intersect, map, record, set, tuple, union } from "./composite.js";
+import { lazy, nullable, nullish, optional, refine, undefinedable } from "./modifier.js";
+import { catchall, deepPartial, extend, merge, object, omit, partial, passthrough, pick, required, safeExtend, strict, strictObject, strip } from "./object/index.js";
+import { bigintGuard, booleanGuard, dateGuard, enumValues, literal, neverGuard, nullGuard, numberGuard, stringGuard, symbolGuard, unknownGuard, undefinedGuard, voidGuard } from "./scalar.js";
+import { instanceOf, json, property } from "./runtime.js";
 /**
  * @brief t.
+ * @details Frozen namespace of all public builders. Freezing prevents accidental
+ * mutation of shared singleton guards and helper functions after module load.
  */
 export const t = Object.freeze({
     unknown: unknownGuard,
     never: neverGuard,
     string: stringGuard,
     number: numberGuard,
+    date: dateGuard,
     bigint: bigintGuard,
     symbol: symbolGuard,
     boolean: booleanGuard,
+    null: nullGuard,
+    undefined: undefinedGuard,
+    void: voidGuard,
     literal,
+    enum: enumValues,
+    enumValues,
     array,
     tuple,
     record,
+    map,
+    set,
+    instanceOf,
+    property,
+    json,
     decoder,
+    default: defaultValue,
+    defaultValue,
+    prefault,
+    catch: catchValue,
+    codec,
     object,
     strictObject,
     extend,
+    merge,
     pick,
     omit,
     partial,
+    deepPartial,
+    required,
+    safeExtend,
+    strict,
+    passthrough,
+    strip,
+    catchall,
     union,
     intersect,
     discriminatedUnion,
     optional,
     undefinedable,
     nullable,
+    nullish,
     lazy,
     refine,
     transform,

package/dist/builders/types.d.ts

@@ -1,24 +1,40 @@
 /**
  * @file types.ts
  * @brief Shared builder type algebra.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 import type { Guard, Infer, Presence } from "../guard/index.js";
 /**
- * @brief tuple shape.
+ * @brief Tuple builder input shape.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export type TupleShape = readonly Guard<unknown, Presence>[];
 /**
- * @brief infer tuple.
+ * @brief Infer tuple runtime value from a tuple guard shape.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export type InferTuple<TShape extends TupleShape> = {
     readonly [TKey in keyof TShape]: Infer<TShape[TKey]>;
 };
+export type InferTupleWithRest<TShape extends TupleShape, TRest extends Guard<unknown, Presence>> = readonly [
+    ...{
+        [TKey in keyof TShape]: Infer<TShape[TKey]>;
+    },
+    ...Infer<TRest>[]
+];
 /**
- * @brief union input.
+ * @brief Non-empty union builder input.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export type UnionInput = readonly [Guard<unknown, Presence>, ...Guard<unknown, Presence>[]];
 /**
- * @brief discriminated union cases.
+ * @brief Compile-time guard that each case owns the requested literal tag.
+ * @details Builder helpers normalize user-facing fluent calls into immutable schema nodes
+ * with stable metadata.
  */
 export type DiscriminatedUnionCases<TKey extends string, TCases extends Readonly<Record<string, Guard<unknown, Presence>>>> = string extends TKey ? TCases : {
     readonly [TCase in keyof TCases]: TCase extends string ? Infer<TCases[TCase]> extends Readonly<Record<TKey, TCase>> ? TCases[TCase] : never : never;

package/dist/builders/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/builders/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,KAAK,EACL,KAAK,EACL,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,UAAU,IAAI;IAClD,QAAQ,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACrD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GACpB,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,uBAAuB,CACjC,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAC/D,MAAM,SAAS,IAAI,GACnB,MAAM,GACN;IACE,QAAQ,EAAE,KAAK,IAAI,MAAM,MAAM,GAAG,KAAK,SAAS,MAAM,GAClD,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,GACxD,MAAM,CAAC,KAAK,CAAC,GACb,KAAK,GACT,KAAK;CACR,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/builders/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,KAAK,EACL,KAAK,EACL,QAAQ,EACX,MAAM,mBAAmB,CAAC;AAE3B;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,UAAU,IAAI;IAChD,QAAQ,EAAE,IAAI,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACvD,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAC1B,MAAM,SAAS,UAAU,EACzB,KAAK,SAAS,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,IACtC,SAAS;IACT,GAAG;SACE,IAAI,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KAC9C;IACD,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE;CACpB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAClB,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;AAEvE;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,CAC/B,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IACjE,MAAM,SAAS,IAAI,GACjB,MAAM,GACN;IACM,QAAQ,EAAE,KAAK,IAAI,MAAM,MAAM,GAAG,KAAK,SAAS,MAAM,GAChD,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,GACtD,MAAM,CAAC,KAAK,CAAC,GACb,KAAK,GACb,KAAK;CACV,CAAC"}