functionalscript 0.43.0 → 0.44.0

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

@@ -0,0 +1,196 @@
+/**
+ * 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.mjs`; only container construction differs.
+ *
+ * See `./types.ts` for the `Result`/`Parse` type-level API.
+ *
+ * @module
+ */
+/** @import { Info1, Struct, Tag1, Tuple, Type } from '../types.ts' */
+/** @import { Result as CommonResult } from '../../result/types.ts' */
+import { ok } from '../../result/module.f.mjs'
+/** @import { StringMap } from '../../object/types.ts' */
+/** @import { List } from '../../list/types.ts' */
+import { reverse, toArray } from '../../list/module.f.mjs'
+import {
+    constPrimitiveValidate,
+    eachEntry,
+    isArray,
+    isObject,
+    orVisit,
+    primitive0Validate,
+    verror,
+    visit,
+} from '../common/module.f.mjs'
+/** @import { Container, IsContainer, ValidateE, ValidationError, Visitor } from '../common/types.ts' */
+/** @import { Unknown } from '../ts/types.ts' */
+/** @import { Parse } from './types.ts' */
+
+const { entries } = Object
+
+/** @typedef {CommonResult<Unknown, ValidationError>} _ItemResult */
+
+/** Rebuilds a parsed container from its `[key, parsedValue]` entries. */
+/** @typedef {(entries: ReadonlyArray<readonly [string, Unknown]>) => Unknown} _Rebuild */
+
+/** @type {_Rebuild} */
+const arrayRebuild = entries => entries.map(([, v]) => v)
+
+/** @type {_Rebuild} */
+const recordRebuild = entries => Object.fromEntries(entries)
+
+/** `eachEntry`'s accumulator seed: entries are consed on in reverse as they parse. */
+/** @type {List<readonly [string, Unknown]>} */
+const emptyEntries = null
+
+/** `eachEntry`'s accumulate step: an O(1) prepend, unlike rebuilding an array on every entry. */
+/** @type {(acc: List<readonly [string, Unknown]>, k: string, v: Unknown) => List<readonly [string, Unknown]>} */
+const consEntry = (acc, k, v) =>
+    ({ first: [k, v], tail: acc })
+
+/** Restores forward order from `consEntry`'s reverse-order list, in one linear pass. */
+/** @type {(list: List<readonly [string, Unknown]>) => ReadonlyArray<readonly [string, Unknown]>} */
+const orderedEntries = list =>
+    toArray(reverse(list))
+
+/**
+ * Builds a parser for `array` or `record` schemas. Mirrors `validate`'s
+ * `containerValidate`, but rebuilds a fresh container from each item's parsed
+ * result instead of returning the value unchanged. The inner item parser is
+ * instantiated lazily (only when the container is non-empty) so recursive
+ * schemas don't recurse forever on empty containers.
+ */
+const containerParse =
+    /**
+     * @template {Tag1} K
+     * @param {IsContainer<Container<K>>} isContainer
+     * @param {_Rebuild} rebuild
+     * @returns {<I extends Type>(item: I) => Parse<Info1<K, I>>}
+     */
+    (isContainer, rebuild) =>
+    item => value => {
+        if (!isContainer(value)) {
+            return verror('unexpected value')
+        }
+        const e = entries(value)
+        if (e.length === 0) {
+            return /** @type {any} */ (ok(rebuild([])))
+        }
+        const itemParse = /** @type {(v: Unknown) => _ItemResult} */ (/** @type {any} */ (parse(item)))
+        const r = eachEntry(e, (_k, v) => itemParse(v), emptyEntries, consEntry)
+        return r[0] === 'error' ? r : /** @type {any} */ (ok(rebuild(orderedEntries(r[1]))))
+    }
+
+const arrayParse = containerParse(isArray, arrayRebuild)
+
+const recordParse = containerParse(isObject, recordRebuild)
+
+/**
+ * Builds a parser for `Tuple` or `Struct` const schemas. Mirrors `validate`'s
+ * `constContainerValidate`: it iterates the schema's entries (so extra tuple
+ * elements and undeclared struct keys are dropped) and rebuilds the result
+ * from each parsed item.
+ */
+const constContainerParse =
+    /**
+     * @template {Unknown} C
+     * @param {IsContainer<C>} isContainer
+     * @param {(value: C, k: string) => Unknown} getItem
+     * @param {_Rebuild} rebuild
+     * @returns {<T extends Tuple | Struct>(rtti: T) => Parse<T>}
+     */
+    (isContainer, getItem, rebuild) =>
+    rtti => value => {
+        if (!isContainer(value)) {
+            return verror('unexpected value')
+        }
+        const r = eachEntry(
+            entries(rtti),
+            (k, t) => /** @type {_ItemResult} */ (/** @type {any} */ (parse(t))(getItem(value, k))),
+            emptyEntries,
+            consEntry,
+        )
+        return r[0] === 'error' ? r : /** @type {any} */ (ok(rebuild(orderedEntries(r[1]))))
+    }
+
+const tupleParse = constContainerParse(
+    isArray,
+    (value, k) => value[Number(k)],
+    arrayRebuild,
+)
+
+const structParse = constContainerParse(
+    isObject,
+    (value, k) => value[k],
+    recordRebuild,
+)
+
+const orParse =
+    /**
+     * @template {readonly Type[]} T
+     * @param {T} rtti
+     * @returns {Parse<() => readonly ['or', ...T]>}
+     */
+    rtti =>
+        /** @type {any} */ (orVisit(/** @type {(t: Type) => ValidateE} */ (/** @type {any} */ (parse)))(rtti))
+
+/**
+ * Creates a parser function for the given RTTI schema.
+ *
+ * The returned function takes an unknown value and returns either
+ * `['ok', newValue]` containing a freshly constructed value matching the schema,
+ * or `['error', { path, message }]` describing the failure location.
+ *
+ * @param rtti - A schema `Type`: a `Thunk` for tag-based schemas, or a `Const`
+ *   (primitive literal, tuple, or struct) for exact-value schemas.
+ * @returns A `Parse<T>` function.
+ *
+ * @example
+ * ```js
+ * const p = parse(array(number))
+ * p([1, 2, 3])         // ['ok', [1, 2, 3]]   (a new array)
+ * p([1, 'two'])        // ['error', { path: ['1'], message: 'unexpected value' }]
+ *
+ * // tuples are closed: extra elements are dropped
+ * parse([number, number])([1, 2, 3]) // ['ok', [1, 2]]
+ *
+ * // structs drop undeclared keys
+ * parse({ a: number })({ a: 1, b: 2 }) // ['ok', { a: 1 }]
+ * ```
+ */
+const parseVisitor = /** @type {any} */ ({
+    tuple: tupleParse,
+    struct: structParse,
+    array: arrayParse,
+    record: recordParse,
+    or: orParse,
+    constPrimitive: constPrimitiveValidate,
+    primitive0: primitive0Validate,
+    unknown: () => ok,
+})
+
+/** @type {<T extends Type>(rtti: T) => Parse<T>} */
+export const parse = rtti =>
+    /** @type {any} */ (visit(parseVisitor)(rtti))

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

@@ -0,0 +1,122 @@
+/**
+ * @import { ValidationError } from '../common/types.ts'
+ * @import { Equal } from '../../ts/types.ts'
+ * @import { Ts } from '../ts/types.ts'
+ * @import { Unknown as DjsUnknown } from '../../../djs/types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
+ */
+export declare const proof: {
+    boolean: {
+        ok: () => void;
+        error: () => void;
+    };
+    number: {
+        ok: () => void;
+        error: () => void;
+    };
+    string: {
+        ok: () => void;
+        error: () => void;
+    };
+    bigint: {
+        ok: () => void;
+        error: () => void;
+    };
+    unknown: {
+        ok: () => void;
+    };
+    const: {
+        null: {
+            ok: () => void;
+            error: () => void;
+        };
+        undefined: {
+            ok: () => void;
+            error: () => void;
+        };
+        number: {
+            ok: () => void;
+            error: () => void;
+        };
+        nan: {
+            ok: () => void;
+            error: () => void;
+        };
+        infinity: {
+            ok: () => void;
+            error: () => void;
+        };
+        signedZero: {
+            distinct: () => void;
+            self: () => void;
+        };
+        string: {
+            ok: () => void;
+            error: () => void;
+        };
+        bigint: {
+            ok: () => void;
+            error: () => void;
+        };
+        boolean: {
+            ok: () => void;
+            error: () => void;
+        };
+        tuple: {
+            ok: () => void;
+            extraItemsDropped: () => void;
+            error: () => void;
+        };
+        struct: {
+            ok: () => void;
+            extraKeysDropped: () => void;
+            error: () => void;
+        };
+    };
+    array: {
+        empty: () => void;
+        ok: () => void;
+        freshArray: () => void;
+        error: () => void;
+        nested: () => void;
+    };
+    record: {
+        empty: () => void;
+        ok: () => void;
+        freshRecord: () => void;
+        error: () => void;
+    };
+    constThunk: {
+        primitive: () => void;
+    };
+    or: {
+        consts: {
+            ok: () => void;
+            error: () => void;
+        };
+        thunks: {
+            ok: () => void;
+            error: () => void;
+        };
+        firstMatchWins: () => void;
+    };
+    option: {
+        ok: () => void;
+        error: () => void;
+    };
+    path: {
+        rootMismatch: () => void;
+        arrayIndex: () => void;
+        recordKey: () => void;
+        nestedArray: () => void;
+        tupleIndex: () => void;
+        structKey: () => void;
+        deepStruct: () => void;
+        recursiveSchema: () => void;
+        orRoot: () => void;
+    };
+    recursive: {
+        arrayOfArrays: () => void;
+        recordOfRecords: () => void;
+    };
+};

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

@@ -0,0 +1,363 @@
+/**
+ * @import { ValidationError } from '../common/types.ts'
+ * @import { Equal } from '../../ts/types.ts'
+ * @import { Ts } from '../ts/types.ts'
+ * @import { Unknown as DjsUnknown } from '../../../djs/types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
+ */
+
+import { parse } from './module.f.mjs'
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(r: readonly [string, unknown]) => void} */
+const assertOk = ([k]) => { assertEq(k, 'ok', 'expected ok') }
+
+/** @type {(r: readonly [string, unknown]) => void} */
+const assertError = ([k]) => { assertEq(k, 'error', 'expected error') }
+
+/**
+ * @template T
+ * @param {readonly [string, unknown]} r
+ * @returns {T}
+ */
+const unwrap = r => {
+    assert(r[0] === 'ok', 'expected ok')
+    return /** @type {T} */ (r[1])
+}
+
+/** @type {(expected: readonly string[]) => (r: readonly [string, unknown]) => void} */
+const assertErrorPath = expected =>
+    r => {
+        assert(r[0] === 'error', 'expected error')
+        const e = /** @type {ValidationError} */ (r[1])
+        if (e.path.length !== expected.length) { throw `path length ${e.path.length} != ${expected.length}` }
+        for (let i = 0; i < expected.length; i++) {
+            if (e.path[i] !== expected[i]) { throw `path[${i}] ${e.path[i]} != ${expected[i]}` }
+        }
+    }
+
+/** @type {(a: unknown, b: unknown) => void} */
+const assertDeepEqual = (a, b) => {
+    if (a === b) { return }
+    if (a instanceof Array && b instanceof Array) {
+        if (a.length !== b.length) { throw `array length ${a.length} != ${b.length}` }
+        for (let i = 0; i < a.length; i++) { assertDeepEqual(a[i], b[i]) }
+        return
+    }
+    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+        const ka = Object.keys(a).sort()
+        const kb = Object.keys(b).sort()
+        if (ka.length !== kb.length) { throw `key count ${ka.length} != ${kb.length}` }
+        for (let i = 0; i < ka.length; i++) {
+            if (ka[i] !== kb[i]) { throw `key ${ka[i]} != ${kb[i]}` }
+            assertDeepEqual((/** @type {any} */ (a))[ka[i]], (/** @type {any} */ (b))[kb[i]])
+        }
+        return
+    }
+    throw `not deep-equal: ${String(a)} vs ${String(b)}`
+}
+
+export const proof = {
+    boolean: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof boolean>, boolean>>} _RoundTrip */
+            assertOk(parse(boolean)(true))
+            assertOk(parse(boolean)(false))
+        },
+        error: () => {
+            assertError(parse(boolean)(0))
+            assertError(parse(boolean)('true'))
+            assertError(parse(boolean)(null))
+        },
+    },
+    number: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof number>, number>>} _RoundTrip */
+            assertOk(parse(number)(42))
+        },
+        error: () => {
+            assertError(parse(number)('42'))
+            assertError(parse(number)(42n))
+        },
+    },
+    string: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof string>, string>>} _RoundTrip */
+            assertOk(parse(string)('hello'))
+        },
+        error: () => {
+            assertError(parse(string)(42))
+            assertError(parse(string)(null))
+        },
+    },
+    bigint: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof bigint>, bigint>>} _RoundTrip */
+            assertOk(parse(bigint)(4n))
+        },
+        error: () => {
+            assertError(parse(bigint)(4))
+            assertError(parse(bigint)('4'))
+        },
+    },
+    unknown: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof unknown>, DjsUnknown>>} _RoundTrip */
+            assertOk(parse(unknown)(null))
+            assertOk(parse(unknown)(42))
+            assertOk(parse(unknown)('hello'))
+            assertOk(parse(unknown)(true))
+            assertOk(parse(unknown)({}))
+            assertOk(parse(unknown)([]))
+        },
+    },
+    const: {
+        null: {
+            ok: () => assertOk(parse(null)(null)),
+            error: () => {
+                assertError(parse(null)(undefined))
+                assertError(parse(null)(0))
+            },
+        },
+        undefined: {
+            ok: () => assertOk(parse(undefined)(undefined)),
+            error: () => assertError(parse(undefined)(null)),
+        },
+        number: {
+            ok: () => assertOk(parse(/** @type {const} */ (42))(42)),
+            error: () => assertError(parse(/** @type {const} */ (42))(43)),
+        },
+        nan: {
+            ok: () => assertOk(parse(/** @type {number} */ (NaN))(NaN)),
+            error: () => {
+                assertError(parse(/** @type {number} */ (NaN))(0))
+                assertError(parse(/** @type {const} */ (0))(NaN))
+                assertError(parse(/** @type {const} */ (42))(NaN))
+            },
+        },
+        infinity: {
+            ok: () => {
+                assertOk(parse(/** @type {number} */ (Infinity))(Infinity))
+                assertOk(parse(/** @type {number} */ (-Infinity))(-Infinity))
+            },
+            error: () => {
+                assertError(parse(/** @type {number} */ (Infinity))(-Infinity))
+                assertError(parse(/** @type {number} */ (Infinity))(0))
+            },
+        },
+        signedZero: {
+            // `Object.is` distinguishes +0 and -0; `===` treats them equal.
+            distinct: () => {
+                assertError(parse(/** @type {const} */ (0))(-0))
+                assertError(parse(/** @type {number} */ (-0))(0))
+            },
+            self: () => {
+                assertOk(parse(/** @type {const} */ (0))(0))
+                assertOk(parse(/** @type {number} */ (-0))(-0))
+            },
+        },
+        string: {
+            ok: () => assertOk(parse(/** @type {const} */ ('hello'))('hello')),
+            error: () => assertError(parse(/** @type {const} */ ('hello'))('world')),
+        },
+        bigint: {
+            ok: () => assertOk(parse(/** @type {const} */ (7n))(7n)),
+            error: () => assertError(parse(/** @type {const} */ (7n))(8n)),
+        },
+        boolean: {
+            ok: () => assertOk(parse(/** @type {const} */ (true))(true)),
+            error: () => assertError(parse(/** @type {const} */ (true))(false)),
+        },
+        tuple: {
+            ok: () => {
+                const t = /** @type {const} */ ([42, 'hello'])
+                const r = parse(t)([42, 'hello'])
+                assertDeepEqual(unwrap(r), [42, 'hello'])
+            },
+            // The key behavior change vs `validate`: extra tuple elements are dropped.
+            extraItemsDropped: () => {
+                const r = parse(/** @type {const} */ ([42]))([42, 'extra'])
+                assertDeepEqual(unwrap(r), [42])
+            },
+            error: () => {
+                assertError(parse(/** @type {const} */ ([42]))([99]))
+                assertError(parse(/** @type {const} */ ([42]))({}))
+            },
+        },
+        struct: {
+            ok: () => {
+                const t = /** @type {const} */ ({ a: 42, b: 'hello' })
+                const r = parse(t)({ a: 42, b: 'hello' })
+                assertDeepEqual(unwrap(r), { a: 42, b: 'hello' })
+            },
+            // Undeclared properties are dropped from the constructed value.
+            extraKeysDropped: () => {
+                const r = parse(/** @type {const} */ ({ a: /** @type {const} */ (42) }))({ a: 42, b: 'extra' })
+                assertDeepEqual(unwrap(r), { a: 42 })
+            },
+            error: () => {
+                assertError(parse(/** @type {const} */ ({ a: 42 }))({ a: 99 }))
+                assertError(parse(/** @type {const} */ ({ a: 42 }))([]))
+            },
+        },
+    },
+    array: {
+        empty: () => {
+            const r = parse(array(number))([])
+            assertDeepEqual(unwrap(r), [])
+        },
+        ok: () => {
+            const r = parse(array(number))([1, 2, 3])
+            assertDeepEqual(unwrap(r), [1, 2, 3])
+        },
+        // `parse` always constructs a new array, even when the inner type is a primitive.
+        freshArray: () => {
+            const input = [1, 2, 3]
+            /** @type {readonly number[]} */
+            const out = unwrap(parse(array(number))(input))
+            assert(out !== /** @type {unknown} */ (input), 'expected a fresh array')
+            assertDeepEqual(out, [1, 2, 3])
+        },
+        error: () => {
+            assertError(parse(array(number))([1, 'two', 3]))
+            assertError(parse(array(number))({}))
+            assertError(parse(array(number))(null))
+        },
+        nested: () => {
+            const r = parse(array(array(boolean)))([[true, false], [false]])
+            assertDeepEqual(unwrap(r), [[true, false], [false]])
+            assertError(parse(array(array(boolean)))([[true, 42]]))
+        },
+    },
+    record: {
+        empty: () => {
+            const r = parse(record(number))({})
+            assertDeepEqual(unwrap(r), {})
+        },
+        ok: () => {
+            const r = parse(record(string))({ a: 'hello', b: 'world' })
+            assertDeepEqual(unwrap(r), { a: 'hello', b: 'world' })
+        },
+        // `parse` always constructs a new record.
+        freshRecord: () => {
+            const input = { a: 1, b: 2 }
+            /** @type {Record<string, number>} */
+            const out = unwrap(parse(record(number))(input))
+            assert(out !== /** @type {unknown} */ (input), 'expected a fresh record')
+            assertDeepEqual(out, { a: 1, b: 2 })
+        },
+        error: () => {
+            assertError(parse(record(number))({ a: 1, b: 'two' }))
+            assertError(parse(record(number))(null))
+            assertError(parse(record(number))([]))
+        },
+    },
+    constThunk: {
+        primitive: () => {
+            const t = () => /** @type {const} */ (['const', 7n])
+            assertOk(parse(t)(7n))
+            assertError(parse(t)(8n))
+        },
+    },
+    or: {
+        consts: {
+            ok: () => {
+                const t = or(.../** @type {const} */ ([false, 42, 'hello']))
+                assertOk(parse(t)(false))
+                assertOk(parse(t)(42))
+                assertOk(parse(t)('hello'))
+            },
+            error: () => {
+                const t = or(.../** @type {const} */ ([false, 42, 'hello']))
+                assertError(parse(t)(true))
+                assertError(parse(t)(43))
+                assertError(parse(t)('world'))
+                assertError(parse(t)(null))
+            },
+        },
+        thunks: {
+            ok: () => {
+                const t = or(number, string)
+                assertOk(parse(t)(42))
+                assertOk(parse(t)('hello'))
+            },
+            error: () => {
+                const t = or(number, string)
+                assertError(parse(t)(true))
+                assertError(parse(t)(null))
+            },
+        },
+        // First matching variant wins; the freshly-constructed value comes from that variant.
+        firstMatchWins: () => {
+            const t = or(/** @type {const} */ ([number]), array(number))
+            /** @type {readonly number[]} */
+            const out = unwrap(parse(t)([1, 2, 3]))
+            // The const tuple `[number]` matches first and returns a length-1 result.
+            assertDeepEqual(out, [1])
+        },
+    },
+    option: {
+        ok: () => {
+            const t = option(number)
+            assertOk(parse(t)(42))
+            assertOk(parse(t)(undefined))
+        },
+        error: () => {
+            const t = option(number)
+            assertError(parse(t)(null))
+            assertError(parse(t)('42'))
+        },
+    },
+    path: {
+        rootMismatch: () => assertErrorPath([])(parse(number)('not a number')),
+        arrayIndex: () => assertErrorPath(['1'])(parse(array(number))([1, 'two', 3])),
+        recordKey: () => {
+            const r = parse(record(number))({ a: 1, b: 'two', c: 3 })
+            assertErrorPath(['b'])(r)
+        },
+        nestedArray: () => assertErrorPath(['0', '1'])(
+            parse(array(array(number)))([[1, 'x'], [2, 3]])
+        ),
+        tupleIndex: () => assertErrorPath(['1'])(
+            parse(/** @type {const} */ ([number, number]))([1, 'two'])
+        ),
+        structKey: () => assertErrorPath(['b'])(
+            parse(/** @type {const} */ ({ a: number, b: number }))({ a: 1, b: 'two' })
+        ),
+        deepStruct: () => {
+            const schema = /** @type {const} */ ({ user: { name: string, age: number } })
+            const r = parse(schema)({ user: { name: 'A', age: 'old' } })
+            assertErrorPath(['user', 'age'])(r)
+        },
+        recursiveSchema: () => {
+            /** @typedef {readonly _A[]} _A */
+            const list = () => /** @type {const} */ (['array', list])
+            const r = parse(list)([/** @type {_A} */ (/** @type {unknown} */ ([[42]]))])
+            assertErrorPath(['0', '0', '0'])(r)
+        },
+        orRoot: () => assertErrorPath([])(parse(or(number, string))(true)),
+    },
+    recursive: {
+        arrayOfArrays: () => {
+            /** @typedef {readonly _A[]} _A */
+            const list = () => /** @type {const} */ (['array', list])
+            /** @typedef {Assert<Equal<_A, Ts<typeof list>>>} _ListRoundTrip */
+            const v = parse(list)
+            assertOk(v([]))
+            assertOk(v([[], []]))
+            assertOk(v([[[], []], []]))
+            assertError(v([42]))
+            assertError(v(null))
+        },
+        recordOfRecords: () => {
+            const tree = () => /** @type {const} */ (['record', tree])
+            /** @typedef {{ readonly[K in string]?: _A }} _A */
+            /** @typedef {Assert<Equal<_A, Ts<typeof tree>>>} _TreeRoundTrip */
+            const v = parse(tree)
+            assertOk(v({}))
+            assertOk(v({ a: {}, b: { c: {} } }))
+            assertError(v({ a: 42 }))
+        },
+    },
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Type-level API for RTTI deserialization.
+ *
+ * @module
+ */
+import type { Type } from '../types.ts';
+import type { Result as CommonValidateResult, Validate } from '../common/types.ts';
+export type { Path, ValidationError } from '../common/types.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>;

package/fjs/types/rtti/parse/types.js

@@ -0,0 +1 @@
+export {};