functionalscript 0.43.0 → 0.44.0

package/fjs/media/json/rtti/module.f.d.mts

@@ -0,0 +1,38 @@
+/**
+ * rtti schemas describing the JSON data model: `primitive`, `unknown`,
+ * `object`, and `array`.
+ *
+ * The three composite schemas are mutually recursive — `unknown` names
+ * `object` and `array`, both of which are built from `unknown` — so `unknown`
+ * carries an explicit `@type` that cross-references its neighbours through
+ * `typeof`. That spelling is deliberate: `@type {const}` also type-checks here,
+ * but leaves declaration emit no name for the recursive positions, so it
+ * inlines the structure, gives up at depth, and degrades the emitted `.d.mts`
+ * to `any`. See AGENTS.md §6.2.
+ *
+ * The TypeScript counterparts live in the sibling
+ * [`../types.ts`](../types.ts), which pins them against these schemas with
+ * `Assert<Equal<Unknown, Ts<typeof unknown>>>`.
+ *
+ * @module
+ */
+/** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
+export declare const primitive: import("../../../types/rtti/types.ts").Or<[null, import("../../../types/rtti/types.ts")._Type0<"boolean">, import("../../../types/rtti/types.ts")._Type0<"number">, import("../../../types/rtti/types.ts")._Type0<"string">]>;
+/**
+ * rtti schema matching any JSON value: a primitive, an array of JSON values,
+ * or an object whose values are JSON values. Self-referential via a thunk;
+ * rtti instantiates array/record item validators lazily so recursion terminates
+ * on acyclic input.
+ *
+ * A struct field typed `unknown` is **required when present** — unlike rtti
+ * core's `unknown`, the JSON `unknown` excludes `undefined`.
+ *
+ * @type {() => readonly['or', typeof primitive, typeof object, typeof array]}
+ */
+export declare const unknown: () => readonly ['or', typeof primitive, typeof object, typeof array];
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
+export declare const object: import("../../../types/rtti/types.ts").Type1<"record", () => readonly ['or', typeof primitive, typeof object, typeof array]>;
+/** rtti schema matching a JSON array: `readonly Unknown[]`. */
+export declare const array: import("../../../types/rtti/types.ts").Type1<"array", () => readonly ['or', typeof primitive, typeof object, typeof array]>;

package/fjs/media/json/rtti/module.f.mjs

@@ -0,0 +1,51 @@
+/**
+ * rtti schemas describing the JSON data model: `primitive`, `unknown`,
+ * `object`, and `array`.
+ *
+ * The three composite schemas are mutually recursive — `unknown` names
+ * `object` and `array`, both of which are built from `unknown` — so `unknown`
+ * carries an explicit `@type` that cross-references its neighbours through
+ * `typeof`. That spelling is deliberate: `@type {const}` also type-checks here,
+ * but leaves declaration emit no name for the recursive positions, so it
+ * inlines the structure, gives up at depth, and degrades the emitted `.d.mts`
+ * to `any`. See AGENTS.md §6.2.
+ *
+ * The TypeScript counterparts live in the sibling
+ * [`../types.ts`](../types.ts), which pins them against these schemas with
+ * `Assert<Equal<Unknown, Ts<typeof unknown>>>`.
+ *
+ * @module
+ */
+
+import {
+    boolean as rttiBoolean,
+    number as rttiNumber,
+    string as rttiString,
+    or,
+    record,
+    array as rttiArray
+} from '../../../types/rtti/module.f.mjs'
+
+/** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
+export const primitive = or(null, rttiBoolean, rttiNumber, rttiString)
+
+/**
+ * rtti schema matching any JSON value: a primitive, an array of JSON values,
+ * or an object whose values are JSON values. Self-referential via a thunk;
+ * rtti instantiates array/record item validators lazily so recursion terminates
+ * on acyclic input.
+ *
+ * A struct field typed `unknown` is **required when present** — unlike rtti
+ * core's `unknown`, the JSON `unknown` excludes `undefined`.
+ *
+ * @type {() => readonly['or', typeof primitive, typeof object, typeof array]}
+ */
+export const unknown = () => ['or', primitive, object, array]
+
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
+export const object = record(unknown)
+
+/** rtti schema matching a JSON array: `readonly Unknown[]`. */
+export const array = rttiArray(unknown)

package/fjs/media/json/rtti/proof.f.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Proof for the JSON rtti schemas.
+ *
+ * @module
+ */
+export declare const proof: {
+    primitive: {
+        accepts: () => void;
+        rejectsComposite: () => void;
+    };
+    object: {
+        accepts: () => void;
+        nested: () => void;
+        rejectsNonObject: () => void;
+    };
+    array: {
+        accepts: () => void;
+        nested: () => void;
+        rejectsNonArray: () => void;
+    };
+    unknown: {
+        acceptsEveryArm: () => void;
+        recurses: () => void;
+        rejectsUndefined: () => void;
+    };
+};

package/fjs/media/json/rtti/proof.f.mjs

@@ -0,0 +1,86 @@
+/**
+ * Proof for the JSON rtti schemas.
+ *
+ * @module
+ */
+
+import { assertEq } from '../../../asserts/module.f.mjs'
+import { validate } from '../../../types/rtti/validate/module.f.mjs'
+import { primitive, unknown, object, array } from './module.f.mjs'
+
+/** @import { ValidateE } from '../../../types/rtti/common/types.ts' */
+/** @import { Unknown } from '../../../types/rtti/ts/types.ts' */
+
+// Reduces a validation to its `ok`/`error` tag: these schemas are about what is
+// accepted, not about the payload, which validation returns unchanged. The
+// erased `ValidateE` keeps the shared helper from re-instantiating each
+// schema's deep recursive result type (TS2589).
+/** @type {(v: ValidateE) => (value: Unknown) => string} */
+const tag = v => value => v(value)[0]
+
+const primitiveAccepts = tag(validate(primitive))
+const unknownAccepts = tag(validate(unknown))
+const objectAccepts = tag(validate(object))
+const arrayAccepts = tag(validate(array))
+
+export const proof = {
+    primitive: {
+        accepts: () => {
+            assertEq(primitiveAccepts(null), 'ok')
+            assertEq(primitiveAccepts(true), 'ok')
+            assertEq(primitiveAccepts(0), 'ok')
+            assertEq(primitiveAccepts(''), 'ok')
+        },
+        rejectsComposite: () => {
+            assertEq(primitiveAccepts([]), 'error')
+            assertEq(primitiveAccepts({}), 'error')
+        },
+    },
+    object: {
+        accepts: () => {
+            assertEq(objectAccepts({}), 'ok')
+            assertEq(objectAccepts({ a: 1, b: 'two', c: null }), 'ok')
+        },
+        // A record schema descends into its values, so a bad leaf anywhere in
+        // the tree fails the whole object.
+        nested: () => {
+            assertEq(objectAccepts({ a: { b: [1, { c: null }] } }), 'ok')
+        },
+        rejectsNonObject: () => {
+            assertEq(objectAccepts(1), 'error')
+            assertEq(objectAccepts([]), 'error')
+        },
+    },
+    array: {
+        accepts: () => {
+            assertEq(arrayAccepts([]), 'ok')
+            assertEq(arrayAccepts([null, true, 2, 'three']), 'ok')
+        },
+        nested: () => {
+            assertEq(arrayAccepts([[{ a: [] }]]), 'ok')
+        },
+        rejectsNonArray: () => {
+            assertEq(arrayAccepts(1), 'error')
+            assertEq(arrayAccepts({}), 'error')
+        },
+    },
+    unknown: {
+        // `unknown` is the union of the three above, so it accepts every arm.
+        acceptsEveryArm: () => {
+            assertEq(unknownAccepts(null), 'ok')
+            assertEq(unknownAccepts(false), 'ok')
+            assertEq(unknownAccepts(1), 'ok')
+            assertEq(unknownAccepts('s'), 'ok')
+            assertEq(unknownAccepts([]), 'ok')
+            assertEq(unknownAccepts({}), 'ok')
+        },
+        // The thunk closes the recursion: an arbitrarily deep acyclic value
+        // terminates because array/record item validators instantiate lazily.
+        recurses: () => {
+            assertEq(unknownAccepts({ a: [{ b: [[{ c: 'd' }]] }] }), 'ok')
+        },
+        rejectsUndefined: () => {
+            assertEq(unknownAccepts(undefined), 'error')
+        },
+    },
+}

package/fjs/media/json/schema/module.f.d.mts

@@ -0,0 +1,79 @@
+/**
+ * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
+ *
+ * Driven by `fjs/types/rtti/common/module.f.mjs`'s `visit`, the same shared
+ * `Type`-ADT walker used by `validate` and `parse`.
+ *
+ * @module
+ *
+ * @import { Struct, Tuple, Type as RttiType } from '../../../types/rtti/types.ts'
+ * @import { Visitor } from '../../../types/rtti/common/types.ts'
+ * @import { Primitive } from '../../../djs/types.ts'
+ * @import { Ts } from '../../../types/rtti/ts/types.ts'
+ * @import { Phantom } from '../../../types/phantom/types.ts'
+ */
+import type { Type as RttiType } from '../../../types/rtti/types.ts';
+import type { Ts } from '../../../types/rtti/ts/types.ts';
+import type { Phantom } from '../../../types/phantom/types.ts';
+declare const unknownThunk: () => readonly ['const', {
+    readonly type: import("../../../types/rtti/types.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../rtti/module.f.mjs").primitive, typeof import("../rtti/module.f.mjs").object, typeof import("../rtti/module.f.mjs").array], undefined]>;
+    readonly not: import("../../../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['const', /*elided*/ any], _UnknownConst>, undefined]>;
+    readonly anyOf: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['const', any], _UnknownConst>>, undefined]>;
+    readonly items: import("../../../types/rtti/types.ts").Or<[Phantom<() => readonly ['const', any], _UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<() => readonly ['const', any], _UnknownConst>>, undefined]>;
+    readonly properties: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"record", Phantom<() => readonly ['const', any], _UnknownConst>>, undefined]>;
+    readonly required: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", import("../../../types/rtti/types.ts")._Type0<"string">>, undefined]>;
+    readonly additionalProperties: import("../../../types/rtti/types.ts").Or<readonly [Phantom<() => readonly ['const', any], _UnknownConst>, undefined]>;
+}];
+/**
+ * rtti schema for a JSON Schema (draft 2020-12) document.
+ * @type {Phantom<typeof unknownThunk, _UnknownConst>}
+ */
+export declare const unknown: Phantom<typeof unknownThunk, _UnknownConst>;
+export type Unknown = Ts<typeof unknown>;
+/** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
+/** @typedef {Ts<typeof unknown>} Unknown */
+declare const unknownConst: {
+    readonly type: import("../../../types/rtti/types.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../rtti/module.f.mjs").primitive, typeof import("../rtti/module.f.mjs").object, typeof import("../rtti/module.f.mjs").array], undefined]>;
+    readonly not: import("../../../types/rtti/types.ts").Or<readonly [Phantom<typeof unknownThunk, _UnknownConst>, undefined]>;
+    readonly anyOf: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<typeof unknownThunk, _UnknownConst>>, undefined]>;
+    readonly items: import("../../../types/rtti/types.ts").Or<[Phantom<typeof unknownThunk, _UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", Phantom<typeof unknownThunk, _UnknownConst>>, undefined]>;
+    readonly properties: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"record", Phantom<typeof unknownThunk, _UnknownConst>>, undefined]>;
+    readonly required: import("../../../types/rtti/types.ts").Or<readonly [import("../../../types/rtti/types.ts").Type1<"array", import("../../../types/rtti/types.ts")._Type0<"string">>, undefined]>;
+    readonly additionalProperties: import("../../../types/rtti/types.ts").Or<readonly [Phantom<typeof unknownThunk, _UnknownConst>, undefined]>;
+};
+export type _UnknownConst = {
+    readonly type?: Ts<typeof unknownConst.type>;
+    readonly const?: Ts<typeof unknownConst.const>;
+    readonly not?: Ts<typeof unknownConst.not>;
+    readonly anyOf?: Ts<typeof unknownConst.anyOf>;
+    readonly items?: Ts<typeof unknownConst.items>;
+    readonly prefixItems?: Ts<typeof unknownConst.prefixItems>;
+    readonly properties?: Ts<typeof unknownConst.properties>;
+    readonly required?: Ts<typeof unknownConst.required>;
+    readonly additionalProperties?: Ts<typeof unknownConst.additionalProperties>;
+};
+/**
+ * Converts an rtti `Type` to a JSON Schema (draft 2020-12) object.
+ *
+ * | rtti                                          | JSON Schema                                                                         |
+ * |-----------------------------------------------|-------------------------------------------------------------------------------------|
+ * | `boolean` / `number` / `string`               | `{ "type": "..." }`                                                                 |
+ * | `bigint`                                      | `{ "type": "integer" }` (lossy; JSON integers are IEEE-754 doubles)                 |
+ * | `unknown`                                     | `{}` (always-true schema)                                                           |
+ * | primitive const (`42`, `'x'`, `true`, `null`) | `{ "const": <value> }`                                                              |
+ * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
+ * | `undefined` const                             | `{ "not": {} }` (no JSON value satisfies this)                                      |
+ * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
+ * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "items": false }`                    |
+ * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
+ * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
+ * | `or(...types)`                                | `{ "anyOf": […each…] }`                                                             |
+ *
+ * @type {(rtti: RttiType) => Unknown}
+ */
+export declare const toJsonSchema: (rtti: RttiType) => Unknown;
+export {};

package/fjs/media/json/schema/module.f.mjs

@@ -0,0 +1,144 @@
+/**
+ * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
+ *
+ * Driven by `fjs/types/rtti/common/module.f.mjs`'s `visit`, the same shared
+ * `Type`-ADT walker used by `validate` and `parse`.
+ *
+ * @module
+ *
+ * @import { Struct, Tuple, Type as RttiType } from '../../../types/rtti/types.ts'
+ * @import { Visitor } from '../../../types/rtti/common/types.ts'
+ * @import { Primitive } from '../../../djs/types.ts'
+ * @import { Ts } from '../../../types/rtti/ts/types.ts'
+ * @import { Phantom } from '../../../types/phantom/types.ts'
+ */
+
+import { array, option, or, record, string } from '../../../types/rtti/module.f.mjs'
+import { visit } from '../../../types/rtti/common/module.f.mjs'
+import { unknown as jsonUnknown } from '../rtti/module.f.mjs'
+
+const unknownThunk = () => /** @type {const} */ (['const', unknownConst])
+
+/**
+ * rtti schema for a JSON Schema (draft 2020-12) document.
+ * @type {Phantom<typeof unknownThunk, _UnknownConst>}
+ */
+export const unknown = unknownThunk
+
+/** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
+/** @typedef {Ts<typeof unknown>} Unknown */
+
+const unknownConst = /** @type {const} */ ({
+    type: or('boolean', 'number', 'string', 'integer', 'array', 'object', undefined),
+    const: option(jsonUnknown),
+    not: option(unknown),
+    anyOf: option(array(unknown)),
+    items: or(unknown, false, undefined),
+    prefixItems: option(array(unknown)),
+    properties: option(record(unknown)),
+    required: option(array(string)),
+    additionalProperties: option(unknown),
+})
+
+/**
+ * Hand-written base type used as the `$out` annotation on `unknown`.
+ *
+ * The `?` markers are required even though `Ts<>` already includes `undefined`
+ * in each field type. Without `?`, `Unknown = _UnknownConst` would require all
+ * 9 fields to be present in every object literal returned by `toJsonSchema`,
+ * because TypeScript distinguishes "field absent" (`?`) from "field present but
+ * undefined" (`T | undefined`). JSON Schema objects only include the fields
+ * they need, so all fields must be optional.
+ * @typedef {{
+ *   readonly type?: Ts<typeof unknownConst.type>
+ *   readonly const?: Ts<typeof unknownConst.const>
+ *   readonly not?: Ts<typeof unknownConst.not>
+ *   readonly anyOf?: Ts<typeof unknownConst.anyOf>
+ *   readonly items?: Ts<typeof unknownConst.items>
+ *   readonly prefixItems?: Ts<typeof unknownConst.prefixItems>
+ *   readonly properties?: Ts<typeof unknownConst.properties>
+ *   readonly required?: Ts<typeof unknownConst.required>
+ *   readonly additionalProperties?: Ts<typeof unknownConst.additionalProperties>
+ * }} _UnknownConst
+ */
+
+/** Returns true if the rtti schema admits the value `undefined`.
+ * @type {(rtti: RttiType) => boolean}
+ */
+const admitsUndefined = rtti => {
+    if (rtti === undefined) { return true }
+    if (typeof rtti !== 'function') { return false }
+    const [t, ...r] = rtti()
+    return t === 'or' ? r.some(admitsUndefined) : false
+}
+
+/** Returns the schema with `undefined` removed from any top-level `or`.
+ * @type {(rtti: RttiType) => RttiType}
+ */
+const stripUndefined = rtti => {
+    if (typeof rtti !== 'function') { return rtti }
+    const [t, ...r] = rtti()
+    if (t !== 'or') { return rtti }
+    const rest = r.flatMap(t => t !== undefined ? [t] : [])
+    return rest.length === 1 ? rest[0] : or(...rest)
+}
+
+// Struct: keys not admitting undefined go into `required`; optional keys have
+// undefined stripped from their property schema. additionalProperties is omitted
+// (lenient), matching rtti's open-struct validation semantics.
+/** @type {(rtti: Struct) => Unknown} */
+const structSchema = rtti => {
+    const ents = Object.entries(rtti)
+    const properties = Object.fromEntries(
+        ents.map(([k, v]) => [k, toJsonSchema(stripUndefined(v))])
+    )
+    const required = ents
+        .filter(([, v]) => !admitsUndefined(v))
+        .map(([k]) => k)
+    return {
+        type: 'object',
+        properties,
+        ...(required.length > 0 ? { required } : {}),
+    }
+}
+
+/** @type {(rtti: Primitive) => Unknown} */
+const constPrimitiveSchema = rtti =>
+    rtti === undefined
+        ? { not: {} }
+        // bigint consts are represented as numbers (lossy for |value| > MAX_SAFE_INTEGER)
+        : { const: typeof rtti === 'bigint' ? Number(rtti) : rtti }
+
+/** @type {Visitor<Unknown>} */
+const visitor = {
+    tuple: (/** @type {Tuple} */ t) => ({ type: 'array', prefixItems: t.map(toJsonSchema), items: false }),
+    struct: structSchema,
+    array: item => ({ type: 'array', items: toJsonSchema(item) }),
+    record: item => ({ type: 'object', additionalProperties: toJsonSchema(item) }),
+    or: variants => ({ anyOf: variants.map(toJsonSchema) }),
+    constPrimitive: constPrimitiveSchema,
+    // bigint is not representable in JSON Schema; 'integer' is the closest approximation
+    primitive0: tag => ({ type: tag === 'bigint' ? 'integer' : tag }),
+    unknown: () => ({}),
+}
+
+/**
+ * Converts an rtti `Type` to a JSON Schema (draft 2020-12) object.
+ *
+ * | rtti                                          | JSON Schema                                                                         |
+ * |-----------------------------------------------|-------------------------------------------------------------------------------------|
+ * | `boolean` / `number` / `string`               | `{ "type": "..." }`                                                                 |
+ * | `bigint`                                      | `{ "type": "integer" }` (lossy; JSON integers are IEEE-754 doubles)                 |
+ * | `unknown`                                     | `{}` (always-true schema)                                                           |
+ * | primitive const (`42`, `'x'`, `true`, `null`) | `{ "const": <value> }`                                                              |
+ * | `bigint` const                                | `{ "const": Number(value) }` (lossy for \|value\| > MAX_SAFE_INTEGER)               |
+ * | `undefined` const                             | `{ "not": {} }` (no JSON value satisfies this)                                      |
+ * | struct `{ a: T, … }`                          | `{ "type": "object", "properties": { "a": …T… }, "required": [non-optional keys] }` |
+ * | tuple `[A, B]`                                | `{ "type": "array", "prefixItems": […A…, …B…], "items": false }`                    |
+ * | `array(T)`                                    | `{ "type": "array", "items": …T… }`                                                 |
+ * | `record(T)`                                   | `{ "type": "object", "additionalProperties": …T… }`                                 |
+ * | `or(...types)`                                | `{ "anyOf": […each…] }`                                                             |
+ *
+ * @type {(rtti: RttiType) => Unknown}
+ */
+export const toJsonSchema = visit(visitor)

package/fjs/media/json/schema/proof.f.d.mts

@@ -0,0 +1,40 @@
+/**
+ * @import { Unknown as JsonValue } from '../types.ts'
+ * @import { Unknown } from './module.f.mjs'
+ */
+export declare const proof: {
+    tag0: {
+        boolean: () => void;
+        number: () => void;
+        string: () => void;
+        bigint: () => void;
+        unknown: () => void;
+    };
+    const: {
+        null: () => void;
+        true: () => void;
+        false: () => void;
+        number: () => void;
+        string: () => void;
+        undefined: () => void;
+        bigint: () => void;
+    };
+    array: () => void;
+    record: () => void;
+    or: () => void;
+    tuple: () => void;
+    struct: {
+        allRequired: () => void;
+        withOptional: () => void;
+        allOptional: () => void;
+        empty: () => void;
+        orOptional: () => void;
+        withConst: () => void;
+    };
+    schemaUnknownTag: () => void;
+    nested: {
+        arrayOfRecords: () => void;
+        orWithConst: () => void;
+        structWithOr: () => void;
+    };
+};

package/fjs/media/json/schema/proof.f.mjs

@@ -0,0 +1,93 @@
+/**
+ * @import { Unknown as JsonValue } from '../types.ts'
+ * @import { Unknown } from './module.f.mjs'
+ */
+
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../../../types/rtti/module.f.mjs'
+import { stringify } from '../module.f.mjs'
+import { toJsonSchema, unknown as schemaUnknown } from './module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(v: Unknown) => string} */
+const serialize = v => stringify(e => e)(/** @type {JsonValue} */ (/** @type {unknown} */ (v)))
+
+/** @type {(rtti: Parameters<typeof toJsonSchema>[0], expected: Unknown) => () => void} */
+const eq = (rtti, expected) => () => {
+    const result = serialize(toJsonSchema(rtti))
+    const exp = serialize(expected)
+    assertEq(result, exp, [result, exp])
+}
+
+export const proof = {
+    tag0: {
+        boolean: eq(boolean, { type: 'boolean' }),
+        number: eq(number, { type: 'number' }),
+        string: eq(string, { type: 'string' }),
+        bigint: eq(bigint, { type: 'integer' }),
+        unknown: eq(unknown, {}),
+    },
+    const: {
+        null: eq(null, { const: null }),
+        true: eq(true, { const: true }),
+        false: eq(false, { const: false }),
+        number: eq(/** @type {const} */ (42), { const: 42 }),
+        string: eq(/** @type {const} */ ('hello'), { const: 'hello' }),
+        undefined: eq(undefined, { not: {} }),
+        bigint: eq(/** @type {const} */ (7n), { const: 7 }),
+    },
+    array: eq(array(number), { type: 'array', items: { type: 'number' } }),
+    record: eq(record(string), { type: 'object', additionalProperties: { type: 'string' } }),
+    or: eq(or(string, number), { anyOf: [{ type: 'string' }, { type: 'number' }] }),
+    tuple: eq(/** @type {const} */ ([number, string]), {
+        type: 'array',
+        prefixItems: [{ type: 'number' }, { type: 'string' }],
+        items: false,
+    }),
+    struct: {
+        allRequired: eq(/** @type {const} */ ({ x: number, y: string }), {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'string' } },
+            required: ['x', 'y'],
+        }),
+        withOptional: eq(/** @type {const} */ ({ x: number, y: option(string) }), {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'string' } },
+            required: ['x'],
+        }),
+        allOptional: eq(/** @type {const} */ ({ x: option(number) }), {
+            type: 'object',
+            properties: { x: { type: 'number' } },
+        }),
+        empty: eq(/** @type {const} */ ({}), { type: 'object', properties: {} }),
+        orOptional: eq(/** @type {const} */ ({ x: or(string, number, undefined) }), {
+            type: 'object',
+            properties: { x: { anyOf: [{ type: 'string' }, { type: 'number' }] } },
+        }),
+        withConst: eq(/** @type {const} */ ({ x: null, y: string }), {
+            type: 'object',
+            properties: { x: { const: null }, y: { type: 'string' } },
+            required: ['x', 'y'],
+        }),
+    },
+    schemaUnknownTag: () => {
+        const r = schemaUnknown()
+        assert(r[0] === 'const')
+    },
+    nested: {
+        arrayOfRecords: eq(array(record(boolean)), {
+            type: 'array',
+            items: { type: 'object', additionalProperties: { type: 'boolean' } },
+        }),
+        orWithConst: eq(or(null, string, /** @type {const} */ (42)), {
+            anyOf: [{ const: null }, { type: 'string' }, { const: 42 }],
+        }),
+        structWithOr: eq(/** @type {const} */ ({ id: or(string, number), name: option(string) }), {
+            type: 'object',
+            properties: {
+                id: { anyOf: [{ type: 'string' }, { type: 'number' }] },
+                name: { type: 'string' },
+            },
+            required: ['id'],
+        }),
+    },
+}

package/fjs/media/json/serializer/module.f.d.mts

@@ -0,0 +1,27 @@
+import type { List } from '../../../types/list/types.ts';
+/**
+ * Serializes a string as a JSON string literal.
+ *
+ * @type {(_: string) => List<string>}
+ */
+export declare const stringSerialize: (_: string) => List<string>;
+/**
+ * Serializes a number as a JSON number literal.
+ *
+ * @type {(_: number) => List<string>}
+ */
+export declare const numberSerialize: (_: number) => List<string>;
+/**
+ * Shared serialized representation for `null`.
+ */
+export declare const nullSerialize: string[];
+/** @type {(_: boolean) => List<string>} */
+export declare const boolSerialize: (_: boolean) => List<string>;
+/** @type {(input: List<List<string>>) => List<string>} */
+export declare const objectWrap: (input: List<List<string>>) => List<string>;
+/**
+ * Wraps serialized entries into a JSON array.
+ *
+ * @type {(input: List<List<string>>) => List<string>}
+ */
+export declare const arrayWrap: (input: List<List<string>>) => List<string>;