functionalscript 0.43.1 → 0.45.0

package/fjs/types/result/proof.f.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @import { Result } from './types.ts'
+ */
+declare const example: () => void;
+declare const invertTest: () => void;
+declare const mapOkTest: () => void;
+declare const okThenTest: () => void;
+export declare const proof: {
+    example: typeof example;
+    invertTest: typeof invertTest;
+    mapOkTest: typeof mapOkTest;
+    okThenTest: typeof okThenTest;
+    throw: {
+        unwrapError: () => string;
+    };
+};
+export {};

package/fjs/types/result/proof.f.mjs

@@ -0,0 +1,61 @@
+/**
+ * @import { Result } from './types.ts'
+ */
+
+import { error, ok, unwrap, invert, mapOk, okThen } from './module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+const example = () => {
+    /** @type {Result<number, string>} */
+    const success = ok(42)
+    /** @type {Result<number, string>} */
+    const failure = error('Something went wrong')
+
+    assertEq(unwrap(success), 42, 'error')
+    const [kind, v] = failure
+    assertEq(kind, 'error')
+    // `v` is inferred as `string` here
+    assertEq(v, 'Something went wrong', 'error')
+}
+
+const invertTest = () => {
+    const [k0, v0] = invert(ok(42))
+    assert(!(k0 !== 'error' || v0 !== 42), [k0, v0])
+    const [k1, v1] = invert(error('oops'))
+    assert(!(k1 !== 'ok' || v1 !== 'oops'), [k1, v1])
+}
+
+const mapOkTest = () => {
+    /** @type {(n: number) => number} */
+    const inc = n => n + 1
+    const [k0, v0] = mapOk(inc)(ok(41))
+    assert(!(k0 !== 'ok' || v0 !== 42), [k0, v0])
+    const [k1, v1] = mapOk(inc)(error('oops'))
+    assert(!(k1 !== 'error' || v1 !== 'oops'), [k1, v1])
+}
+
+const okThenTest = () => {
+    /** @type {(n: number) => Result<string, string>} */
+    const half = n => n % 2 === 0 ? ok(`${n / 2}`) : error('odd')
+    const [k0, v0] = okThen(half)(ok(42))
+    assert(!(k0 !== 'ok' || v0 !== '21'), [k0, v0])
+    // `f` itself failing: the chain reports `f`'s own error.
+    const [k1, v1] = okThen(half)(ok(41))
+    assert(!(k1 !== 'error' || v1 !== 'odd'), [k1, v1])
+    // An incoming `error` skips `f` and passes through unchanged, keeping its
+    // own error type: the result is `Result<string, string | number>`.
+    /** @type {Result<number, number>} */
+    const incoming = error(7)
+    const [k2, v2] = okThen(half)(incoming)
+    assert(!(k2 !== 'error' || v2 !== 7), [k2, v2])
+}
+
+export const proof = {
+    example,
+    invertTest,
+    mapOkTest,
+    okThenTest,
+    throw: {
+        unwrapError: () => unwrap(error('oops')),
+    },
+}

package/fjs/types/result/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Types for representing operations that can succeed or fail.
+ *
+ * @module
+ */
+/**
+ * Represents a successful result.
+ */
+export type Ok<T> = readonly ['ok', T];
+/**
+ * Represents a failed result.
+ */
+export type Error<E> = readonly ['error', E];
+/**
+ * Represents a result that can be either successful or failed.
+ */
+export type Result<T, E> = Ok<T> | Error<E>;

package/fjs/types/rtti/common/module.f.d.mts

@@ -0,0 +1,119 @@
+/**
+ * Shared kernel for RTTI consumers (`validate`, `parse`).
+ *
+ * Both consumers traverse the same schema shape and produce the same
+ * `Result<T, ValidationError>` outcome. Only the per-variant handling differs
+ * — `validate` keeps the original value, `parse` constructs a fresh one.
+ *
+ * This module hosts the parts that do not differ:
+ *
+ * - The error shape (`ValidationError`, `Path`) and path bookkeeping
+ *   (`verror`, `prependPath`).
+ * - Primitive checks (`primitive0Validate`, `constPrimitiveValidate`).
+ * - The `Validate<T>`/`Result<T>` signatures — `parse` uses the same shape.
+ * - `visit`: a visitor over the `Type` ADT. Callers supply a `Visitor<R>`
+ *   with one handler per variant; `visit(v)(rtti)` recognizes `rtti` and
+ *   calls the matching handler. Both consumers compose their top-level
+ *   function from a visitor.
+ * - `eachEntry`: the container entry loop (array/record/tuple/struct), shared
+ *   by both consumers' container builders. Callers choose what (if anything)
+ *   to accumulate, so `validate`'s pure pass/fail check pays no allocation.
+ * - `orVisit`: the shared `or` handler — try each variant's recursive walker,
+ *   return the first match.
+ *
+ * Keeping the kernel here also removes `parse`'s incidental dependency on
+ * `validate` and gives schema-driven consumers (e.g. the data form in
+ * `../data/module.f.mjs`) a stable shared base.
+ *
+ * @module
+ *
+ * @import { Primitive, Unknown } from '../ts/types.ts'
+ * @import { Const, Info0, Primitive0, Struct, Tag1, Tuple, Type } from '../types.ts'
+ * @import { Error, Result as CommonResult } from '../../result/types.ts'
+ * @import { StringMap } from '../../object/types.ts'
+ * @import { Validate, Visitor, IsContainer, Container, ResultE, ValidateE, ValidationError } from './types.ts'
+ */
+import type { Primitive, Unknown } from '../ts/types.ts';
+import type { Info0, Primitive0, Type } from '../types.ts';
+import type { Error, Result as CommonResult } from '../../result/types.ts';
+import type { StringMap } from '../../object/types.ts';
+import type { Validate, Visitor, IsContainer, ResultE, ValidateE, ValidationError } from './types.ts';
+/** Builds an error result with empty path and the given message. */
+/** @type {(message: string) => Error<ValidationError>} */
+export declare const verror: (message: string) => Error<ValidationError>;
+/** Prepends `key` to the error's path, used to build the path bottom-up. */
+/** @type {(key: string, error: Error<ValidationError>) => Error<ValidationError>} */
+export declare const prependPath: (key: string, error: Error<ValidationError>) => Error<ValidationError>;
+/** Validates a `Tag0` primitive schema using `typeof`. */
+export declare const primitive0Validate: <K extends Primitive0, T extends Info0<K>>(
+/**
+ * @template {Primitive0} K
+ * @template {Info0<K>} T
+ * @param {K} tag
+ * @returns {Validate<T>}
+ */
+tag: K) => Validate<T>;
+/**
+ * Validates a primitive `Const` schema using `Object.is` (SameValue).
+ *
+ * `Object.is` is used instead of `===` so that:
+ * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
+ * - `+0` and `-0` are treated as distinct const values.
+ */
+export declare const constPrimitiveValidate: <T extends Primitive>(
+/**
+ * @template {Primitive} T
+ * @param {T} rtti
+ * @returns {Validate<T>}
+ */
+rtti: T) => Validate<T>;
+/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
+/** @type {IsContainer<ReadonlyArray<Unknown>>} */
+export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
+/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
+/** @type {IsContainer<StringMap<Unknown>>} */
+export declare const isObject: IsContainer<StringMap<Unknown>>;
+/**
+ * Runs `item` over each `[key, value]` entry, bailing out with the first
+ * error, path-prefixed with that entry's key. On success, folds each item's
+ * result into `acc` (starting from `init`) with `accumulate` and returns the
+ * final accumulator.
+ *
+ * Shared by `validate` and `parse`'s container builders (array/record/tuple/
+ * struct), which differ only in what `item` does with the value and what
+ * they accumulate: `validate` has nothing to collect — its entire schema is
+ * "did every entry succeed?" — so it passes `undefined`/`(acc) => acc` and
+ * pays no allocation per entry; `parse` needs the rebuilt `[key, value]`
+ * pairs, so it folds them into a `List` (see its call site) and converts to
+ * an array once at the end.
+ */
+export declare const eachEntry: <V, R, A>(entries: ReadonlyArray<readonly [string, V]>, item: (k: string, v: V) => CommonResult<R, ValidationError>, init: A, accumulate: (acc: A, k: string, value: R) => A) => CommonResult<A, ValidationError>;
+/**
+ * First variant in `variants` that `recurse` accepts, else `verror('no match')`.
+ *
+ * Shared `or` handler for `validate` and `parse`: both try each variant
+ * against the value and return the first `'ok'` verbatim, differing only in
+ * which recursive function (`validate` or `parse`) walks each variant. `recurse`
+ * is typed over the erased `ValidateE` alias — annotating it as `(t: Type) =>
+ * Validate<Type>` would itself instantiate `Validate<Type>` and hit TS2589 —
+ * so each caller passes its recursive function through one boundary cast.
+ *
+ * @type {(recurse: (t: Type) => ValidateE) => (variants: readonly Type[]) => (value: Unknown) => ResultE}
+ */
+export declare const orVisit: (recurse: (t: Type) => ValidateE) => (variants: readonly Type[]) => (value: Unknown) => ResultE;
+/**
+ * Visits a schema `Type` by dispatching to the matching handler in `v`.
+ *
+ * - `Thunk` schemas are evaluated once to read the `Info` descriptor, then
+ *   routed by tag (`'const'`, `'array'`, `'record'`, `'unknown'`, `'or'`,
+ *   or a `Tag0` primitive).
+ * - `Const` schemas (primitives, tuples, structs) are routed directly to
+ *   `tuple`, `struct`, or `constPrimitive`.
+ */
+export declare const visit: <R>(
+/**
+ * @template R
+ * @param {Visitor<R>} v
+ * @returns {(rtti: Type) => R}
+ */
+v: Visitor<R>) => (rtti: Type) => R;

package/fjs/types/rtti/common/module.f.mjs

@@ -0,0 +1,185 @@
+/**
+ * Shared kernel for RTTI consumers (`validate`, `parse`).
+ *
+ * Both consumers traverse the same schema shape and produce the same
+ * `Result<T, ValidationError>` outcome. Only the per-variant handling differs
+ * — `validate` keeps the original value, `parse` constructs a fresh one.
+ *
+ * This module hosts the parts that do not differ:
+ *
+ * - The error shape (`ValidationError`, `Path`) and path bookkeeping
+ *   (`verror`, `prependPath`).
+ * - Primitive checks (`primitive0Validate`, `constPrimitiveValidate`).
+ * - The `Validate<T>`/`Result<T>` signatures — `parse` uses the same shape.
+ * - `visit`: a visitor over the `Type` ADT. Callers supply a `Visitor<R>`
+ *   with one handler per variant; `visit(v)(rtti)` recognizes `rtti` and
+ *   calls the matching handler. Both consumers compose their top-level
+ *   function from a visitor.
+ * - `eachEntry`: the container entry loop (array/record/tuple/struct), shared
+ *   by both consumers' container builders. Callers choose what (if anything)
+ *   to accumulate, so `validate`'s pure pass/fail check pays no allocation.
+ * - `orVisit`: the shared `or` handler — try each variant's recursive walker,
+ *   return the first match.
+ *
+ * Keeping the kernel here also removes `parse`'s incidental dependency on
+ * `validate` and gives schema-driven consumers (e.g. the data form in
+ * `../data/module.f.mjs`) a stable shared base.
+ *
+ * @module
+ *
+ * @import { Primitive, Unknown } from '../ts/types.ts'
+ * @import { Const, Info0, Primitive0, Struct, Tag1, Tuple, Type } from '../types.ts'
+ * @import { Error, Result as CommonResult } from '../../result/types.ts'
+ * @import { StringMap } from '../../object/types.ts'
+ * @import { Validate, Visitor, IsContainer, Container, ResultE, ValidateE, ValidationError } from './types.ts'
+ */
+
+import { error, ok } from '../../result/module.f.mjs'
+import { isArray as commonIsArray } from '../../array/module.f.mjs'
+import { isObject as commonIsObject } from '../../object/module.f.mjs'
+
+/** Builds an error result with empty path and the given message. */
+/** @type {(message: string) => Error<ValidationError>} */
+export const verror = message =>
+    error({ path: [], message })
+
+/** Prepends `key` to the error's path, used to build the path bottom-up. */
+/** @type {(key: string, error: Error<ValidationError>) => Error<ValidationError>} */
+export const prependPath = (key, [,r]) =>
+    error({ path: [key, ...r.path], message: r.message })
+
+/** Validates a `Tag0` primitive schema using `typeof`. */
+export const primitive0Validate =
+    /**
+     * @template {Primitive0} K
+     * @template {Info0<K>} T
+     * @param {K} tag
+     * @returns {Validate<T>}
+     */
+    tag =>
+        value => typeof value === tag ? /** @type {any} */ (ok(value)) : verror('unexpected value')
+
+/**
+ * Validates a primitive `Const` schema using `Object.is` (SameValue).
+ *
+ * `Object.is` is used instead of `===` so that:
+ * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
+ * - `+0` and `-0` are treated as distinct const values.
+ */
+export const constPrimitiveValidate =
+    /**
+     * @template {Primitive} T
+     * @param {T} rtti
+     * @returns {Validate<T>}
+     */
+    rtti =>
+        value => Object.is(rtti, value)
+            ? /** @type {any} */ (ok(value))
+            : verror('unexpected value')
+
+/** @type {<R>(v: Visitor<R>) => (c: Const) => R} */
+const visitConst = v => c =>
+    typeof c === 'object' && c !== null
+        ? (commonIsArray(c) ? v.tuple(c) : v.struct(/** @type {Struct} */ (c)))
+        : v.constPrimitive(/** @type {Primitive} */ (c))
+
+/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
+/** @type {IsContainer<ReadonlyArray<Unknown>>} */
+export const isArray =
+    value => commonIsArray(value)
+
+/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
+/** @type {IsContainer<StringMap<Unknown>>} */
+export const isObject =
+    value => commonIsObject(value)
+
+/**
+ * Runs `item` over each `[key, value]` entry, bailing out with the first
+ * error, path-prefixed with that entry's key. On success, folds each item's
+ * result into `acc` (starting from `init`) with `accumulate` and returns the
+ * final accumulator.
+ *
+ * Shared by `validate` and `parse`'s container builders (array/record/tuple/
+ * struct), which differ only in what `item` does with the value and what
+ * they accumulate: `validate` has nothing to collect — its entire schema is
+ * "did every entry succeed?" — so it passes `undefined`/`(acc) => acc` and
+ * pays no allocation per entry; `parse` needs the rebuilt `[key, value]`
+ * pairs, so it folds them into a `List` (see its call site) and converts to
+ * an array once at the end.
+ */
+export const eachEntry =
+    /**
+     * @template V
+     * @template R
+     * @template A
+     * @param {ReadonlyArray<readonly [string, V]>} entries
+     * @param {(k: string, v: V) => CommonResult<R, ValidationError>} item
+     * @param {A} init
+     * @param {(acc: A, k: string, value: R) => A} accumulate
+     * @returns {CommonResult<A, ValidationError>}
+     */
+    (entries, item, init, accumulate) => {
+        let acc = init
+        for (const [k, v] of entries) {
+            const r = item(k, v)
+            if (r[0] === 'error') {
+                return prependPath(k, r)
+            }
+            acc = accumulate(acc, k, r[1])
+        }
+        return ok(acc)
+    }
+
+/**
+ * First variant in `variants` that `recurse` accepts, else `verror('no match')`.
+ *
+ * Shared `or` handler for `validate` and `parse`: both try each variant
+ * against the value and return the first `'ok'` verbatim, differing only in
+ * which recursive function (`validate` or `parse`) walks each variant. `recurse`
+ * is typed over the erased `ValidateE` alias — annotating it as `(t: Type) =>
+ * Validate<Type>` would itself instantiate `Validate<Type>` and hit TS2589 —
+ * so each caller passes its recursive function through one boundary cast.
+ *
+ * @type {(recurse: (t: Type) => ValidateE) => (variants: readonly Type[]) => (value: Unknown) => ResultE}
+ */
+export const orVisit =
+    recurse =>
+    variants => value => {
+        for (const t of variants) {
+            const r = recurse(t)(value)
+            if (r[0] === 'ok') {
+                return r
+            }
+        }
+        return verror('no match')
+    }
+
+/**
+ * Visits a schema `Type` by dispatching to the matching handler in `v`.
+ *
+ * - `Thunk` schemas are evaluated once to read the `Info` descriptor, then
+ *   routed by tag (`'const'`, `'array'`, `'record'`, `'unknown'`, `'or'`,
+ *   or a `Tag0` primitive).
+ * - `Const` schemas (primitives, tuples, structs) are routed directly to
+ *   `tuple`, `struct`, or `constPrimitive`.
+ */
+export const visit =
+    /**
+     * @template R
+     * @param {Visitor<R>} v
+     * @returns {(rtti: Type) => R}
+     */
+    v => rtti => {
+        if (typeof rtti === 'function') {
+            const [tag, ...value] = rtti()
+            switch (tag) {
+                case 'const': return visitConst(v)(/** @type {Const} */ (value[0]))
+                case 'array': return v.array(value[0])
+                case 'record': return v.record(value[0])
+                case 'unknown': return v.unknown()
+                case 'or': return v.or(value)
+            }
+            return v.primitive0(/** @type {Primitive0} */ (tag))
+        }
+        return visitConst(v)(rtti)
+    }

package/fjs/types/rtti/common/proof.f.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @import { Result } from '../../result/types.ts'
+ * @import { ValidationError } from './types.ts'
+ */
+export type _Entries = ReadonlyArray<readonly [string, number]>;
+export declare const proof: {
+    empty: () => void;
+    allOk: () => void;
+    noAccumulate: () => void;
+    firstErrorWins: () => void;
+    shortCircuits: () => void;
+    pathPrefixed: () => void;
+};

package/fjs/types/rtti/common/proof.f.mjs

@@ -0,0 +1,67 @@
+/**
+ * @import { Result } from '../../result/types.ts'
+ * @import { ValidationError } from './types.ts'
+ */
+
+import { eachEntry } from './module.f.mjs'
+import { error, ok } from '../../result/module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
+
+/** @typedef {ReadonlyArray<readonly [string, number]>} _Entries */
+
+/** @type {(k: string, v: number) => Result<number, ValidationError>} */
+const item = (k, v) =>
+    v < 0 ? error({ path: [], message: `negative at ${k}` }) : ok(v * 2)
+
+/** Mirrors `parse`'s accumulate step, kept simple (a small test list, not a `List`). */
+/** @type {(acc: _Entries, k: string, v: number) => _Entries} */
+const collect = (acc, k, v) => [...acc, [k, v]]
+
+export const proof = {
+    empty: () => {
+        const r = eachEntry(/** @type {_Entries} */ ([]), item, /** @type {_Entries} */ ([]), collect)
+        assert(r[0] === 'ok')
+        assertEq(r[1].length, 0)
+    },
+    allOk: () => {
+        const r = eachEntry([['a', 1], ['b', 2]], item, /** @type {_Entries} */ ([]), collect)
+        assert(r[0] === 'ok')
+        assertEq(r[1].length, 2)
+        assertEq(r[1][0][0], 'a')
+        assertEq(r[1][0][1], 2)
+        assertEq(r[1][1][0], 'b')
+        assertEq(r[1][1][1], 4)
+    },
+    // Mirrors `validate`'s usage: nothing is collected, only pass/fail matters.
+    noAccumulate: () => {
+        const r = eachEntry([['a', 1]], item, undefined, () => undefined)
+        assert(r[0] === 'ok')
+        assertEq(r[1], undefined)
+    },
+    firstErrorWins: () => {
+        const r = eachEntry([['a', -1], ['b', -2]], item, /** @type {_Entries} */ ([]), collect)
+        assert(r[0] === 'error')
+        assertEq(r[1].message, 'negative at a')
+    },
+    shortCircuits: () => {
+        let calls = 0
+        /** @type {(k: string, v: number) => Result<number, ValidationError>} */
+        const counting = (k, v) => {
+            calls++
+            return item(k, v)
+        }
+        const r = eachEntry([['a', -1], ['b', -2], ['c', -3]], counting, /** @type {_Entries} */ ([]), collect)
+        assert(r[0] === 'error')
+        assertEq(calls, 1)
+    },
+    pathPrefixed: () => {
+        /** @type {(k: string, v: number) => Result<number, ValidationError>} */
+        const nested = (k, v) =>
+            v < 0 ? error({ path: ['inner'], message: 'bad' }) : ok(v)
+        const r = eachEntry([['outer', -1]], nested, /** @type {_Entries} */ ([]), collect)
+        assert(r[0] === 'error')
+        assertEq(r[1].path.length, 2)
+        assertEq(r[1].path[0], 'outer')
+        assertEq(r[1].path[1], 'inner')
+    },
+}

package/fjs/types/rtti/common/types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Type-level API shared by RTTI consumers (`validate`, `parse`).
+ *
+ * @module
+ */
+import type { Primitive, Unknown } from '../ts/types.ts';
+import type { Primitive0, Struct, Tag1, Tuple, Type } from '../types.ts';
+import type { Result as CommonResult } from '../../result/types.ts';
+import type { Ts } from '../ts/types.ts';
+import type { StringMap } from '../../object/types.ts';
+/** A path to a sub-value within the validated structure. Each step is an object key or stringified array index. */
+export type Path = readonly string[];
+/** Detailed validation failure: the offending `path` plus a short `message`. */
+export type ValidationError = {
+    readonly path: Path;
+    readonly message: string;
+};
+/** Validation/parse result: either the typed value or a `ValidationError`. */
+export type Result<T extends Type> = CommonResult<Ts<T>, ValidationError>;
+/** A function that checks an unknown value against schema `T`. Shared by `validate` and `parse`. */
+export type Validate<T extends Type> = (value: Unknown) => Result<T>;
+/**
+ * One handler per `Type` variant. Both `validate` and `parse` provide a
+ * `Visitor<R>` where `R` is the per-variant output (e.g. a `Validate` function).
+ */
+export type Visitor<R> = {
+    readonly tuple: (rtti: Tuple) => R;
+    readonly struct: (rtti: Struct) => R;
+    readonly array: (item: Type) => R;
+    readonly record: (item: Type) => R;
+    readonly or: (variants: readonly Type[]) => R;
+    readonly constPrimitive: (p: Primitive) => R;
+    readonly primitive0: (tag: Primitive0) => R;
+    readonly unknown: () => R;
+};
+/** Type guard narrowing `Unknown` to a specific container type `C`. */
+export type IsContainer<C extends Unknown> = (value: Unknown) => value is C;
+/** Maps a `Tag1` to its runtime container type. */
+export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : StringMap<Unknown>;
+/** `Result` with the payload type erased; avoids instantiating `Ts<Type>`. */
+export type ResultE = CommonResult<Unknown, ValidationError>;
+/** A `Validate`-shaped function with the payload type erased. */
+export type ValidateE = (value: Unknown) => ResultE;

package/fjs/types/rtti/data/module.f.d.mts

@@ -0,0 +1,120 @@
+/**
+ * The serializable RTTI data form and the {@link toData} conversion from the
+ * thunk form.
+ *
+ * A schema denotes a set of values. The data form partitions that set into
+ * six disjoint kinds — unit values (`null`, `undefined`, `false`, `true`),
+ * numbers, strings, bigints, arrays and objects — so that all schema algebra
+ * (union normalization, coverage collapse, {@link equal}, {@link subset},
+ * canonical ordering via {@link cmp}) reduces to kind-wise set operations.
+ * {@link toData} is the single bridge from the thunk form; {@link validate}
+ * is the data-driven counterpart of `../validate`. The form serializes as
+ * DJS — plain JSON when no `bigint` literals are involved. See `./README.md`
+ * for the design rationale and serialization notes, and `./types.ts` for the
+ * type-level API.
+ *
+ * @module
+ *
+ * @import { Const, ConstObject, Type } from '../types.ts'
+ * @import { Primitive, Unknown } from '../ts/types.ts'
+ * @import { ResultE } from '../common/types.ts'
+ * @import { StringMap } from '../../object/types.ts'
+ * @import { ArraySet, Data, KindSet, Node, ObjectSet, RuleSet, UnionSet } from './types.ts'
+ */
+import type { Const, Type } from '../types.ts';
+import type { Primitive, Unknown } from '../ts/types.ts';
+import type { ResultE } from '../common/types.ts';
+import type { StringMap } from '../../object/types.ts';
+import type { Data, Node, RuleSet, UnionSet } from './types.ts';
+/**
+ * The unit kind's enumeration: bit `1 << i` of a {@link UnionSet}'s `unit`
+ * bitset stands for `unitList[i]`.
+ */
+export declare const unitList: readonly ['null', 'undefined', 'false', 'true'];
+/**
+ * The `unit` bit of one unit value.
+ *
+ * @type {(v: null | undefined | boolean) => number}
+ */
+export declare const unitBit: (v: null | undefined | boolean) => number;
+/**
+ * The data form of the empty set — rtti `never`.
+ *
+ * @type {UnionSet}
+ */
+export declare const never: UnionSet;
+/**
+ * The data form of the set of all values — rtti `unknown`.
+ *
+ * @type {UnionSet}
+ */
+export declare const unknown: UnionSet;
+/**
+ * Total order over the data form: negative, zero or positive, with zero
+ * exactly on structural identity. {@link toData} output is canonical, so two
+ * conversions of equivalent thunk schemas compare equal — this is what makes
+ * the data form comparable and sortable.
+ *
+ * @type {(a: Data) => (b: Data) => number}
+ */
+export declare const cmp: (a: Data) => (b: Data) => number;
+/**
+ * Structural equality of canonical forms: `equal(toData(a))(toData(b))`
+ * holds exactly when `a` and `b` normalize to the same data — e.g.
+ * `or(a, b)` and `or(b, a)` are equal. Recursive definitions compare by
+ * their rule names, which are derived from the defining functions' names.
+ *
+ * @type {(a: Data) => (b: Data) => boolean}
+ */
+export declare const equal: (a: Data) => (b: Data) => boolean;
+export type _Ctx = readonly [RuleSet, RuleSet];
+export type _Assumed = StringMap<StringMap<true>>;
+export type _Keyed = readonly [Node, string | undefined];
+/**
+ * Sound subset test: `true` means every value of `a` is a value of `b`.
+ * Kind-wise on unions, pattern-wise on arrays/objects, coinductive on
+ * reference cycles. Incomplete in the known-hard corners of semantic
+ * subtyping (see `./README.md`): it may answer `false` for an inclusion
+ * that only holds by distributing a union across positions, or one whose
+ * left side is a non-syntactic empty set — never `true` for a non-inclusion.
+ *
+ * @type {(a: Data) => (b: Data) => boolean}
+ */
+export declare const subset: (a: Data) => (b: Data) => boolean;
+export type _NodeMap = (n: Node) => Node;
+export type _Thunk = Exclude<Type, Const>;
+export type _Key = Exclude<Type, Primitive>;
+export type _State = {
+    readonly converting: readonly _Thunk[];
+    readonly names: readonly (readonly [_Thunk, string])[];
+    readonly done: readonly (readonly [_Key, UnionSet])[];
+    readonly deferred: readonly (readonly [_Thunk, _Thunk])[];
+};
+/**
+ * Converts a thunk-form schema into its canonical data form.
+ *
+ * Runs once per consumer need; schemas that are built but never consumed pay
+ * nothing. The output is normalized — unions are flattened and merged
+ * kind-wise, literals are sorted and deduplicated, subsumed array/object
+ * patterns are dropped, rules are pruned to the reachable set and sorted,
+ * and a union equal to a rule's body reads back as a reference — so schema
+ * identity is a property of this form: `toData(or(a, b))` and
+ * `toData(or(b, a))` are structurally identical even though the two thunks
+ * are distinct, and `or` is idempotent on recursive schemas.
+ *
+ * Only recursive definitions become named rules (named after their defining
+ * functions), everything else is inlined; a schema with no reference cycles
+ * converts to `[{}, unionSet]`.
+ *
+ * @type {(t: Type) => Data}
+ */
+export declare const toData: (t: Type) => Data;
+/**
+ * Data-driven validation — the counterpart of `../validate` that consumes a
+ * {@link Data} produced by {@link toData} instead of walking the thunk
+ * graph. Returns the original value on success, or the first
+ * `{ path, message }` error.
+ *
+ * @type {(data: Data) => (value: Unknown) => ResultE}
+ */
+export declare const validate: (data: Data) => (value: Unknown) => ResultE;