functionalscript 0.43.1 → 0.45.0

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

@@ -1,61 +0,0 @@
-/**
- * A module for representing and handling operations that can succeed or fail.
- *
- * @module
- *
- * @example
- *
- * ```ts
- * import { error, ok, unwrap, type Result } from './module.f.ts'
- *
- * const success: Result<number, string> = ok(42)
- * const failure: Result<number, string> = error('Something went wrong')
- *
- * if (unwrap(success) !== 42) { throw 'error' }
- * const [kind, v] = failure
- * if (kind !== 'error') { throw 'error' }
- * // `v` is inferred as `string` here
- * if (v !== 'Something went wrong') { throw 'error' }
- * ```
- */
-/**
- * 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>;
-/**
- * Creates a successful result.
- *
- * @param value - The value to wrap.
- * @returns A successful result containing the value.
- */
-export declare const ok: <T>(value: T) => Ok<T>;
-/**
- * Creates a failed result.
- *
- * @param e - The error to wrap.
- * @returns A failed result containing the error.
- */
-export declare const error: <E>(e: E) => Error<E>;
-/**
- * Unwraps a result, returning the value if successful or throwing the error if failed.
- *
- * @param param0 - The result to unwrap.
- * @returns The value if the result is successful. Otherwise, throws the error.
- */
-export declare const unwrap: <T, E>([kind, v]: Result<T, E>) => T;
-/**
- * Swaps the `ok` and `error` cases of a result.
- */
-export declare const invert: <T, E>([k, v]: Result<T, E>) => Result<E, T>;
-/**
- * Maps the `ok` case of a result, passing an `error` through unchanged.
- */
-export declare const mapOk: <T, R>(f: (value: T) => R) => <E>(r: Result<T, E>) => Result<R, E>;

package/fjs/types/result/module.f.js

@@ -1,54 +0,0 @@
-/**
- * A module for representing and handling operations that can succeed or fail.
- *
- * @module
- *
- * @example
- *
- * ```ts
- * import { error, ok, unwrap, type Result } from './module.f.ts'
- *
- * const success: Result<number, string> = ok(42)
- * const failure: Result<number, string> = error('Something went wrong')
- *
- * if (unwrap(success) !== 42) { throw 'error' }
- * const [kind, v] = failure
- * if (kind !== 'error') { throw 'error' }
- * // `v` is inferred as `string` here
- * if (v !== 'Something went wrong') { throw 'error' }
- * ```
- */
-/**
- * Creates a successful result.
- *
- * @param value - The value to wrap.
- * @returns A successful result containing the value.
- */
-export const ok = (value) => ['ok', value];
-/**
- * Creates a failed result.
- *
- * @param e - The error to wrap.
- * @returns A failed result containing the error.
- */
-export const error = (e) => ['error', e];
-/**
- * Unwraps a result, returning the value if successful or throwing the error if failed.
- *
- * @param param0 - The result to unwrap.
- * @returns The value if the result is successful. Otherwise, throws the error.
- */
-export const unwrap = ([kind, v]) => {
-    if (kind === 'error') {
-        throw v;
-    }
-    return v;
-};
-/**
- * Swaps the `ok` and `error` cases of a result.
- */
-export const invert = ([k, v]) => k === 'ok' ? error(v) : ok(v);
-/**
- * Maps the `ok` case of a result, passing an `error` through unchanged.
- */
-export const mapOk = (f) => (r) => r[0] === 'ok' ? ok(f(r[1])) : r;

package/fjs/types/result/module.js

@@ -1,19 +0,0 @@
-import { ok, error } from './module.f.js';
-export const tryCatch = f => {
-    // Side effect: `try catch` is not allowed in FunctionalScript.
-    try {
-        return ok(f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-export const asyncTryCatch = async (f) => {
-    // Side effect: `try catch` is not allowed in FunctionalScript.
-    try {
-        return ok(await f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};

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

@@ -1,12 +0,0 @@
-declare const example: () => void;
-declare const invertTest: () => void;
-declare const mapOkTest: () => void;
-export declare const proof: {
-    example: typeof example;
-    invertTest: typeof invertTest;
-    mapOkTest: typeof mapOkTest;
-    throw: {
-        unwrapError: () => string;
-    };
-};
-export {};

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

@@ -1,31 +0,0 @@
-import { error, ok, unwrap, invert, mapOk } from "./module.f.js";
-import { assert, assertEq } from '../../asserts/module.f.js';
-const example = () => {
-    const success = ok(42);
-    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 = () => {
-    const [k0, v0] = mapOk((n) => n + 1)(ok(41));
-    assert(!(k0 !== 'ok' || v0 !== 42), [k0, v0]);
-    const [k1, v1] = mapOk((n) => n + 1)(error('oops'));
-    assert(!(k1 !== 'error' || v1 !== 'oops'), [k1, v1]);
-};
-export const proof = {
-    example,
-    invertTest,
-    mapOkTest,
-    throw: {
-        unwrapError: () => unwrap(error('oops')),
-    },
-};

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

@@ -1,121 +0,0 @@
-/**
- * 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 future schema-driven consumers (e.g. the data form
- * sketched in [i143](../../../../issues/README.md)) a stable shared base.
- *
- * @module
- */
-import type { Primitive, Unknown } from '../ts/module.f.ts';
-import { type Info0, type Primitive0, type Struct, type Tag1, type Tuple, type Type } from '../module.f.ts';
-import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
-import type { Ts } from '../ts/module.f.ts';
-import { type StringMap } from '../../object/module.f.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>;
-/** Builds an error result with empty path and the given message. */
-export declare const verror: (message: string) => Error<ValidationError>;
-/** Prepends `key` to the error's path, used to build the path bottom-up. */
-export declare const prependPath: (key: string, [, r]: Error<ValidationError>) => Error<ValidationError>;
-/** Validates a `Tag0` primitive schema using `typeof`. */
-export declare const primitive0Validate: <K extends Primitive0, T extends Info0<K>>(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>(rtti: T) => Validate<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>;
-/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
-export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
-/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
-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>;
-/** `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;
-/**
- * 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.
- */
-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>(v: Visitor<R>) => (rtti: Type) => R;

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

@@ -1,94 +0,0 @@
-import {} from '../module.f.js';
-import { error, ok } from '../../result/module.f.js';
-import { isArray as commonIsArray } from '../../array/module.f.js';
-import { isObject as commonIsObject } from '../../object/module.f.js';
-/** Builds an error result with empty path and the given message. */
-export const verror = (message) => error({ path: [], message });
-/** Prepends `key` to the error's path, used to build the path bottom-up. */
-export const prependPath = (key, [, r]) => error({ path: [key, ...r.path], message: r.message });
-/** Validates a `Tag0` primitive schema using `typeof`. */
-export const primitive0Validate = (tag) => value => typeof value === tag ? 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 = (rtti) => value => Object.is(rtti, value)
-    ? ok(value)
-    : verror('unexpected value');
-const visitConst = (v) => (c) => typeof c === 'object' && c !== null
-    ? (commonIsArray(c) ? v.tuple(c) : v.struct(c))
-    : v.constPrimitive(c);
-/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
-export const isArray = value => commonIsArray(value);
-/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
-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 = (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.
- */
-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 = (v) => (rtti) => {
-    if (typeof rtti === 'function') {
-        const [tag, ...value] = rtti();
-        switch (tag) {
-            case 'const': return visitConst(v)(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(tag);
-    }
-    return visitConst(v)(rtti);
-};

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

@@ -1,8 +0,0 @@
-export declare const proof: {
-    empty: () => void;
-    allOk: () => void;
-    noAccumulate: () => void;
-    firstErrorWins: () => void;
-    shortCircuits: () => void;
-    pathPrefixed: () => void;
-};

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

@@ -1,51 +0,0 @@
-import { eachEntry } from './module.f.js';
-import { error, ok } from '../../result/module.f.js';
-import { assert, assertEq } from '../../../asserts/module.f.js';
-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`). */
-const collect = (acc, k, v) => [...acc, [k, v]];
-export const proof = {
-    empty: () => {
-        const r = eachEntry([], item, [], collect);
-        assert(r[0] === 'ok');
-        assertEq(r[1].length, 0);
-    },
-    allOk: () => {
-        const r = eachEntry([['a', 1], ['b', 2]], item, [], 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, [], collect);
-        assert(r[0] === 'error');
-        assertEq(r[1].message, 'negative at a');
-    },
-    shortCircuits: () => {
-        let calls = 0;
-        const counting = (k, v) => {
-            calls++;
-            return item(k, v);
-        };
-        const r = eachEntry([['a', -1], ['b', -2], ['c', -3]], counting, [], collect);
-        assert(r[0] === 'error');
-        assertEq(calls, 1);
-    },
-    pathPrefixed: () => {
-        const nested = (k, v) => v < 0 ? error({ path: ['inner'], message: 'bad' }) : ok(v);
-        const r = eachEntry([['outer', -1]], nested, [], 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/module.f.d.ts

@@ -1,75 +0,0 @@
-import { type Includes } from '../array/module.f.ts';
-import type { StringMap } from '../object/module.f.ts';
-/** A constant schema: a primitive literal, a struct object, or a tuple. */
-export type Const = null | boolean | number | string | undefined | bigint | {
-    readonly [K in string]: Type;
-} | readonly Type[];
-export type ConstObject = Struct | Tuple;
-/** A struct schema: plain object whose values are nested `Type`s. */
-export type Struct = StringMap<Type>;
-/** A tuple schema: readonly array whose elements are nested `Type`s. */
-export type Tuple = readonly Type[];
-declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];
-export type Primitive0 = typeof primitive0List[number];
-export declare const tag0List: readonly ["bigint", "boolean", "number", "string", "unknown"];
-/** Tags for nullary (zero-parameter) type schemas. */
-export type Tag0 = typeof tag0List[number];
-/** Info tuple for a nullary tag: `readonly[tag]`. */
-export type Info0<T extends Tag0> = T extends Tag0 ? readonly [T] : never;
-/** Any schema: a `Const` used directly, or a `Thunk` for tag-based/recursive schemas. */
-export type Type = (() => (readonly ['const', Const] | readonly ['bigint'] | readonly ['boolean'] | readonly ['number'] | readonly ['string'] | readonly ['unknown'] | readonly ['array', Type] | readonly ['record', Type] | readonly ['or', ...readonly Type[]])) | Const;
-/** The type of a nullary thunk for `Tag0`. */
-type Type0<T extends Tag0> = () => Info0<T>;
-/** Schema type for `boolean`. */
-export type Boolean = Type0<'boolean'>;
-/** Schema that validates `boolean` values. */
-export declare const boolean: Boolean;
-/** Schema type for `number`. */
-export type Number = Type0<'number'>;
-/** Schema that validates `number` values. */
-export declare const number: Number;
-/** Schema type for `string`. */
-export type String = Type0<'string'>;
-/** Schema that validates `string` values. */
-export declare const string: String;
-/** Schema type for `bigint`. */
-export type Bigint = Type0<'bigint'>;
-/** Schema that validates `bigint` values. */
-export declare const bigint: Bigint;
-/** Schema type for any DJS value (`Primitive | UnknownRecord | UnknownArray`). */
-export type Unknown = Type0<'unknown'>;
-/** Schema that validates any DJS-compatible value. */
-export declare const unknown: Unknown;
-declare const tag1List: readonly ['array', 'record'];
-export declare const isTag1: Includes<string, typeof tag1List>;
-/** Tags for unary (one-parameter) type schemas. */
-export type Tag1 = typeof tag1List[number];
-/** Info tuple for a unary tag: `readonly[tag, innerType]`. */
-export type Info1<K extends Tag1, T extends Type> = K extends Tag1 ? readonly [K, T] : never;
-/** The type of a unary thunk for `Tag1` with inner type `T`. */
-export type Type1<K extends Tag1, T extends Type> = () => Info1<K, T>;
-type MakeType1<K extends Tag1> = <T extends Type>(t: T) => Type1<K, T>;
-/** Schema type for a readonly array with element type `T`. */
-export type Array<T extends Type> = Type1<'array', T>;
-/** Constructs a schema that validates `readonly Ts<T>[]`. */
-export declare const array: MakeType1<'array'>;
-/** Schema type for a record (index signature) with value type `T`. */
-export type Record<T extends Type> = Type1<'record', T>;
-/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
-export declare const record: MakeType1<'record'>;
-/** Schema type for a union of types `T`. */
-export type Or<T extends readonly Type[]> = () => readonly ['or', ...T];
-/**
- * Constructs a schema that validates a value matching any of the given schemas.
- *
- * `or` is intentionally a lazy, allocation-free constructor: it captures its
- * arguments in a thunk and does no flattening, deduplication, subset analysis,
- * or canonical-form work. All such algebra lives on the serializable data form
- * — see `issues/143-rtti-data.md`.
- */
-export declare const or: <T extends readonly Type[]>(...types: T) => Or<T>;
-/** Constructs a schema that validates a value matching `T` or `undefined`. */
-export declare const option: <T extends Type>(t: T) => Or<readonly [T, undefined]>;
-/** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */
-export declare const never: Or<readonly []>;
-export {};

package/fjs/types/rtti/module.f.js

@@ -1,34 +0,0 @@
-import { includes } from '../array/module.f.js';
-const primitive0List = ['bigint', 'boolean', 'number', 'string'];
-export const tag0List = [...primitive0List, 'unknown'];
-const type0 = (tag) => () => [tag];
-/** Schema that validates `boolean` values. */
-export const boolean = type0('boolean');
-/** Schema that validates `number` values. */
-export const number = type0('number');
-/** Schema that validates `string` values. */
-export const string = type0('string');
-/** Schema that validates `bigint` values. */
-export const bigint = type0('bigint');
-/** Schema that validates any DJS-compatible value. */
-export const unknown = type0('unknown');
-const tag1List = ['array', 'record'];
-export const isTag1 = includes(tag1List);
-const type1 = (key) => t => () => [key, t];
-/** Constructs a schema that validates `readonly Ts<T>[]`. */
-export const array = type1('array');
-/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
-export const record = type1('record');
-/**
- * Constructs a schema that validates a value matching any of the given schemas.
- *
- * `or` is intentionally a lazy, allocation-free constructor: it captures its
- * arguments in a thunk and does no flattening, deduplication, subset analysis,
- * or canonical-form work. All such algebra lives on the serializable data form
- * — see `issues/143-rtti-data.md`.
- */
-export const or = (...types) => () => ['or', ...types];
-/** Constructs a schema that validates a value matching `T` or `undefined`. */
-export const option = (t) => or(t, undefined);
-/** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */
-export const never = or();

package/fjs/types/rtti/parse/module.f.d.ts

@@ -1,36 +0,0 @@
-/**
- * Runtime deserialization of unknown values against RTTI schemas.
- *
- * The main entry point is `parse(rtti)`, which takes a schema `Type` and returns
- * a `Parse<T>` function. When called with an unknown value, it returns a `Result`
- * that is either `['ok', newValue]` or `['error', { path, message }]`.
- *
- * Unlike `validate`, which checks an existing value in-place and returns it
- * unchanged on success, `parse` always returns a freshly constructed value that
- * contains only the fields/elements declared by the schema. This makes both
- * structs and tuples effectively closed at runtime, matching the TypeScript
- * type produced by `Ts<T>`:
- *
- * - Tuples: the result has exactly the schema's length; extra elements are dropped.
- * - Structs: the result contains only the schema's keys; extra properties are dropped.
- * - Arrays/records: every element/value is itself parsed, so a fresh container is
- *   always returned even if the inner type is a primitive.
- *
- * This also provides forward compatibility with extended serialization formats:
- * a schema-based parser keeps working when newer versions of the format add
- * extra fields or tuple elements.
- *
- * The error shape, path bookkeeping, primitive checks, and schema
- * recognition (`visit`) are shared with `validate` through
- * `../common/module.f.ts`; only container construction differs.
- *
- * @module
- */
-import { type Type } from '../module.f.ts';
-import { type Result as CommonValidateResult, type Validate } from '../common/module.f.ts';
-export { type Path, type ValidationError } from '../common/module.f.ts';
-/** Parse result: either the freshly constructed typed value or a `ValidationError`. */
-export type Result<T extends Type> = CommonValidateResult<T>;
-/** A function that parses an unknown value into the schema `T`. */
-export type Parse<T extends Type> = Validate<T>;
-export declare const parse: <T extends Type>(rtti: T) => Parse<T>;