functionalscript 0.24.0 → 0.26.0

package/fs/cli/proof.f.js

@@ -0,0 +1,86 @@
+import { pure } from "../effects/module.f.js";
+import {} from "../effects/node/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { dispatch } from "./module.f.js";
+const makeOptions = (args) => ({
+    args,
+    env: {},
+    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
+    testContext: { test: async () => { } },
+    bunTestContext: { test: async () => { } },
+    playwrightTestContext: { test: async () => { } },
+    engine: 'node',
+});
+const echoCommands = [
+    {
+        names: ['echo', 'e'],
+        description: 'Print the first argument',
+        handler: ({ args: [arg = ''] }) => pure(arg.length),
+    },
+];
+const run = (commands) => (args) => virtual(emptyState)(dispatch(commands)(makeOptions(args)));
+export const proof = {
+    knownCommand: () => {
+        const [, code] = run(echoCommands)(['echo', 'hello']);
+        if (code !== 5) {
+            throw ['expected length 5', code];
+        }
+    },
+    alias: () => {
+        const [, code] = run(echoCommands)(['e', 'hi']);
+        if (code !== 2) {
+            throw ['expected length 2', code];
+        }
+    },
+    noArgs: () => {
+        const [state, code] = run(echoCommands)([]);
+        if (code !== 1) {
+            throw ['expected exit 1', code];
+        }
+        if (state.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    unknownCommand: () => {
+        const [state, code] = run(echoCommands)(['bogus']);
+        if (code !== 1) {
+            throw ['expected exit 1', code];
+        }
+        if (state.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    help: () => {
+        const [state, code] = run(echoCommands)(['help']);
+        if (code !== 0) {
+            throw ['expected exit 0', code];
+        }
+        if (!state.stdout.includes('echo')) {
+            throw 'expected command name in stdout';
+        }
+        if (!state.stdout.includes('help')) {
+            throw 'expected help entry in stdout';
+        }
+    },
+    errorIncludesAvailable: () => {
+        const [state] = run(echoCommands)(['bogus']);
+        if (!state.stderr.includes('echo')) {
+            throw 'expected available commands in error';
+        }
+    },
+    handlerReceivesRemainingArgs: () => {
+        const captured = [];
+        const commands = [{
+                names: ['grab'],
+                description: 'Capture args',
+                handler: ({ args }) => {
+                    captured.push(...args);
+                    return pure(0);
+                },
+            }];
+        run(commands)(['grab', 'a', 'b', 'c']);
+        if (captured.join(',') !== 'a,b,c') {
+            throw ['unexpected args', captured];
+        }
+    },
+};

package/fs/crypto/sha2/module.f.js

@@ -9,47 +9,43 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         const r = bitLength - d;
         return (n) => n >> d | n << r;
     };
-    const bigSigma = ([a, b, c]) => {
+    const sigma = third => (a, b, c) => {
         const ra = rotr(a);
         const rb = rotr(b);
-        const rc = rotr(c);
-        return (x) => ra(x) ^ rb(x) ^ rc(x);
+        const rc = third(c);
+        return x => ra(x) ^ rb(x) ^ rc(x);
     };
-    const bigSigma0 = bigSigma(bs0);
-    const bigSigma1 = bigSigma(bs1);
-    const smallSigma = ([a, b, c]) => {
-        const ra = rotr(a);
-        const rb = rotr(b);
-        return (x) => ra(x) ^ rb(x) ^ (x >> c);
-    };
-    const smallSigma0 = smallSigma(ss0);
-    const smallSigma1 = smallSigma(ss1);
+    const bigSigma = sigma(rotr);
+    const smallSigma = sigma(c => x => x >> c);
+    const bigSigma0 = bigSigma(...bs0);
+    const bigSigma1 = bigSigma(...bs1);
+    const smallSigma0 = smallSigma(...ss0);
+    const smallSigma1 = smallSigma(...ss1);
     const ch = (x, y, z) => x & y ^ ~x & z;
     const maj = (x, y, z) => x & y ^ x & z ^ y & z;
     const m = mask(bitLength);
-    const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) & m;
-    const nextW = ([w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]) => {
-        w0 = wi([wE, w9, w1, w0]);
-        w1 = wi([wF, wA, w2, w1]);
-        w2 = wi([w0, wB, w3, w2]);
-        w3 = wi([w1, wC, w4, w3]);
-        w4 = wi([w2, wD, w5, w4]);
-        w5 = wi([w3, wE, w6, w5]);
-        w6 = wi([w4, wF, w7, w6]);
-        w7 = wi([w5, w0, w8, w7]);
-        w8 = wi([w6, w1, w9, w8]);
-        w9 = wi([w7, w2, wA, w9]);
-        wA = wi([w8, w3, wB, wA]);
-        wB = wi([w9, w4, wC, wB]);
-        wC = wi([wA, w5, wD, wC]);
-        wD = wi([wB, w6, wE, wD]);
-        wE = wi([wC, w7, wF, wE]);
-        wF = wi([wD, w8, w0, wF]);
+    const wi = (a0, a1, a2, a3) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) & m;
+    const nextW = (w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF) => {
+        w0 = wi(wE, w9, w1, w0);
+        w1 = wi(wF, wA, w2, w1);
+        w2 = wi(w0, wB, w3, w2);
+        w3 = wi(w1, wC, w4, w3);
+        w4 = wi(w2, wD, w5, w4);
+        w5 = wi(w3, wE, w6, w5);
+        w6 = wi(w4, wF, w7, w6);
+        w7 = wi(w5, w0, w8, w7);
+        w8 = wi(w6, w1, w9, w8);
+        w9 = wi(w7, w2, wA, w9);
+        wA = wi(w8, w3, wB, wA);
+        wB = wi(w9, w4, wC, wB);
+        wC = wi(wA, w5, wD, wC);
+        wD = wi(wB, w6, wE, wD);
+        wE = wi(wC, w7, wF, wE);
+        wF = wi(wD, w8, w0, wF);
         return [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF];
     };
     const kLength = k.length;
-    const compressV16 = ([a0, b0, c0, d0, e0, f0, g0, h0]) => (data) => {
-        let w = data;
+    const compressV16 = (a0, b0, c0, d0, e0, f0, g0, h0) => w => {
         let a = a0;
         let b = b0;
         let c = c0;
@@ -77,7 +73,7 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
             if (i === kLength) {
                 break;
             }
-            w = nextW(w);
+            w = nextW(...w);
         }
         return [
             (a0 + a) & m,
@@ -90,10 +86,10 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
             (h0 + h) & m,
         ];
     };
-    const at = (u) => (i) => (u >> (i << logBitLen)) & m;
-    const compress = (i) => (u) => {
+    const at = u => i => (u >> (i << logBitLen)) & m;
+    const compress = i => u => {
         const a = at(u);
-        return compressV16(i)([
+        return compressV16(...i)([
             a(15n),
             a(14n),
             a(13n),

package/fs/crypto/vdf/module.f.d.ts

@@ -0,0 +1,21 @@
+import type { Nullable } from '../../types/nullable/module.f.ts';
+/** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
+export declare const p = 170082004324204494273811327264862981553264701145937538369570764779791492622392118654022654452947093285873855529044371650895045691292912712699015605832276411308653107069798639938826015099738961427172366594187783204437869906954750443653318078358839409699824714551430573905637228307966826784684174483831608534979n;
+/**
+ * Sloth VDF over prime `modulus` (`p ≡ 3 (mod 4)`).
+ */
+export type Sloth = {
+    readonly p: bigint;
+    readonly quadRes: (x: bigint) => boolean;
+    readonly modSqrt: (x: bigint) => bigint;
+    /** Sequential Sloth permutation; `null` when `steps < 0`. */
+    readonly eval: (steps: bigint) => (x: bigint) => Nullable<bigint>;
+    /** Fast verification of {@link Sloth.eval}; `false` when `steps < 0`. */
+    readonly verify: (steps: bigint) => (x: bigint) => (y: bigint) => boolean;
+};
+/**
+ * Builds Sloth VDF operations over `modulus`.
+ */
+export declare const sloth_vdf: (modulus: bigint) => Sloth;
+/** Sloth VDF over {@link p}. */
+export declare const sloth: Sloth;

package/fs/crypto/vdf/module.f.js

@@ -0,0 +1,57 @@
+/**
+ * Sloth verifiable delay function over a fixed 3072-bit safe prime.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { sloth } from './module.f.ts'
+ *
+ * const steps = 4n
+ * const x = 42n
+ * const y = sloth.eval(steps)(x)
+ * if (y === null || !sloth.verify(steps)(x)(y)) { throw y }
+ * ```
+ */
+import { modSqrt, prime_field } from "../../types/prime_field/module.f.js";
+/** Sloth VDF modulus (3072-bit safe prime, same as reference implementations). */
+export const p = 0xf2346eae06a233882814ff16f6a076d3b8f2161c5c92171c0b7b84eed4e9475bcce0c13bde34512afdf90f41ab9b86dcf834f85e04b27fadee712eed23a1d4e58cd1b09d9bfb10696d614f119179a40c49dc8762edc29e8115263913237e14718cbcd4dc6b35bace13f8cdb1b5156c50c47b4aaee0820c874e2864cb854367c3n;
+const repeatSeq = (steps) => (f) => (value) => {
+    let v = value;
+    let i = 0n;
+    while (i < steps) {
+        v = f(v);
+        i = i + 1n;
+    }
+    return v;
+};
+/**
+ * Builds Sloth VDF operations over `modulus`.
+ */
+export const sloth_vdf = (modulus) => {
+    const field = prime_field(modulus);
+    const { neg, pow2, reduce, quadRes } = field;
+    const root = modSqrt(field);
+    const squareLoop = (steps) => (value) => repeatSeq(steps)(pow2)(reduce(value));
+    const modSqrtLoop = (steps) => (value) => repeatSeq(steps)(root)(reduce(value));
+    const evalSteps = (steps) => (x) => steps < 0n ? null : modSqrtLoop(steps)(x);
+    const verifySteps = (steps) => (x) => (y) => {
+        if (steps < 0n) {
+            return false;
+        }
+        const input = reduce(x);
+        const squared = squareLoop(steps)(y);
+        const value = quadRes(squared) ? squared : neg(squared);
+        return input === value || neg(input) === value;
+    };
+    return {
+        p: modulus,
+        quadRes,
+        modSqrt: root,
+        eval: evalSteps,
+        verify: verifySteps,
+    };
+};
+/** Sloth VDF over {@link p}. */
+export const sloth = sloth_vdf(p);

package/fs/crypto/vdf/proof.f.d.ts

@@ -0,0 +1,32 @@
+export declare const proof: {
+    p: {
+        matchesField: () => void;
+    };
+    eval: {
+        steps100: () => void;
+        steps10: () => void;
+        steps6: () => void;
+        steps4: () => void;
+        zeroSteps: () => void;
+        negativeSteps: () => void;
+    };
+    verify: {
+        steps100: () => void;
+        steps10: () => void;
+        steps6: () => void;
+        steps4: () => void;
+        tampered: () => void;
+        wrongY: () => void;
+        zeroSteps: () => void;
+        negativeSteps: () => void;
+        invalidY: () => void;
+    };
+    modSqrt: {
+        roundTrip: () => void;
+        nonResidue: () => void;
+    };
+    quadRes: {
+        one: () => void;
+        nonResidue: () => void;
+    };
+};

package/fs/crypto/vdf/proof.f.js

@@ -0,0 +1,135 @@
+import { sloth, p } from "./module.f.js";
+const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
+// `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
+// https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
+// https://github.com/jose-compu/dignity.js/blob/main/src/security/sloth-vdf.js
+const sampleX = 123456789n;
+const largeX = 12345678901234567890n;
+const smallX = 42n;
+const nonResidue = 2n;
+const sampleY = 72412151236937799598582816305571618206681207952550127764586725290711141789888684237028784568532880529360450375677852568362636821341317217048062977639333459511661887862128325859969604061461913896412260750881385045152117694320409864730924775539555636460819549547999218170813228857928921642957426089461925313163n;
+const smallY = 145151597037272685697451525487035431973338817762329243361437778785747534269376083577375382484815474368317818719265551745910148543423765263685177263740373969289084400977118144482329577335929842301331443392042760708529572252015473334998752211959790788326970269713683808382892472572910797612141527200051803670965n;
+const y6 = 116287514643100261336025249676072556421566393377742705567032370320583145555855278910304225489766306768040386612082033279417845047304479679877515174322332386599890348932893235091525789175564701751964775040887336849457197662999383850490808701700264064812615988837073981567599117932005435532913423970502774287312n;
+const y4 = 64401150265223443694244964595084197237814157534040219819342647664782563317539559768554855806938965782018778040933157632467146168153951260465261118025222264314070274636967492909984790708532033331622332323767105919809000393624013423095812833452440384602112677364631962445309757177309466319657219548312354433189n;
+export const proof = {
+    p: {
+        matchesField: () => {
+            if (sloth.p !== p) {
+                throw [sloth.p, p];
+            }
+        },
+    },
+    eval: {
+        steps100: () => {
+            const y = evalVdf(100n)(sampleX);
+            if (y !== sampleY) {
+                throw [y, sampleY];
+            }
+        },
+        steps10: () => {
+            const y = evalVdf(10n)(smallX);
+            if (y !== smallY) {
+                throw [y, smallY];
+            }
+        },
+        steps6: () => {
+            const y = evalVdf(6n)(largeX);
+            if (y !== y6) {
+                throw [y, y6];
+            }
+        },
+        steps4: () => {
+            const y = evalVdf(4n)(smallX);
+            if (y !== y4) {
+                throw [y, y4];
+            }
+        },
+        zeroSteps: () => {
+            const y = evalVdf(0n)(sampleX);
+            if (y !== sampleX % p) {
+                throw [y, sampleX % p];
+            }
+        },
+        negativeSteps: () => {
+            const y = evalVdf(-1n)(sampleX);
+            if (y !== null) {
+                throw y;
+            }
+        },
+    },
+    verify: {
+        steps100: () => {
+            if (!verify(100n)(sampleX)(sampleY)) {
+                throw false;
+            }
+        },
+        steps10: () => {
+            if (!verify(10n)(smallX)(smallY)) {
+                throw false;
+            }
+        },
+        steps6: () => {
+            if (!verify(6n)(largeX)(y6)) {
+                throw false;
+            }
+        },
+        steps4: () => {
+            if (!verify(4n)(smallX)(y4)) {
+                throw false;
+            }
+        },
+        tampered: () => {
+            if (verify(4n)(smallX)((y4 + 1n) % p)) {
+                throw (y4 + 1n) % p;
+            }
+        },
+        wrongY: () => {
+            if (verify(100n)(sampleX)(sampleY + 1n)) {
+                throw sampleY + 1n;
+            }
+        },
+        zeroSteps: () => {
+            if (!verify(0n)(sampleX)(sampleX % p)) {
+                throw [sampleX % p];
+            }
+        },
+        negativeSteps: () => {
+            if (verify(-1n)(sampleX)(sampleY)) {
+                throw sampleY;
+            }
+        },
+        invalidY: () => {
+            if (verify(100n)(sampleX)(0n)) {
+                throw 0n;
+            }
+        },
+    },
+    modSqrt: {
+        roundTrip: () => {
+            const x = 999n;
+            if (!verify(1n)(x)(modSqrt(x))) {
+                throw modSqrt(x);
+            }
+        },
+        nonResidue: () => {
+            if (quadRes(nonResidue)) {
+                throw nonResidue;
+            }
+            if (!verify(1n)(nonResidue)(modSqrt(nonResidue))) {
+                throw modSqrt(nonResidue);
+            }
+        },
+    },
+    quadRes: {
+        one: () => {
+            if (!quadRes(1n)) {
+                throw 1n;
+            }
+        },
+        nonResidue: () => {
+            if (quadRes(nonResidue)) {
+                throw nonResidue;
+            }
+        },
+    },
+};

package/fs/dev/index/module.f.d.ts

@@ -1,8 +1 @@
-/**
- * Entry point for the `index` developer program: re-exports `index4` from the
- * parent `dev` module as the default `NodeProgram`.
- *
- * @module
- */
-import { index4 } from '../module.f.ts';
-export default index4;
+export declare const main: import("../../effects/node/module.f.ts").NodeProgram;

package/fs/dev/index/module.f.js

@@ -5,4 +5,4 @@
  * @module
  */
 import { index4 } from "../module.f.js";
-export default index4;
+export const main = index4;

package/fs/effects/node/module.f.d.ts

@@ -166,7 +166,7 @@ export type NodeEffect<T> = Effect<NodeOp, T>;
  * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
  * compose `error(s).step(() => pure(n))` directly.
  */
-export declare const errorExit: (s: string) => Effect<NodeOp, number>;
+export declare const errorExit: (s: string) => Effect<Write, number>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
  * The environment variables.

package/fs/emergent_testing/module.f.d.ts

@@ -117,7 +117,7 @@ export declare const defaultTest: (file: string, path: Path, { fn, throws }: Tes
 /**
  * The terminal/GitHub reporter used by `fjs t`. Output goes through
  * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
- * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * `GITHUB_ACTIONS` is set, failures are emitted as `::error` workflow
  * annotations instead of colored lines. Exported as a factory so the
  * GitHub format path can be exercised directly from tests.
  */

package/fs/emergent_testing/module.f.js

@@ -220,7 +220,7 @@ const fmtResultLine = (file, path, color, label, duration) => `${fmtImport(file,
 /**
  * The terminal/GitHub reporter used by `fjs t`. Output goes through
  * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
- * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * `GITHUB_ACTIONS` is set, failures are emitted as `::error` workflow
  * annotations instead of colored lines. Exported as a factory so the
  * GitHub format path can be exercised directly from tests.
  */
@@ -232,7 +232,7 @@ export const defaultReporter = (options) => {
     };
     const csiLog = line('stdout');
     const csiError = line('stderr');
-    const isGitHub = options.env['GITHUB_ACTION'] !== undefined;
+    const isGitHub = options.env['GITHUB_ACTIONS'] !== undefined;
     return {
         // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
         result: (file, path, { result: [s, v], duration }, throws) => s === 'ok'

package/fs/emergent_testing/proof.f.js

@@ -17,7 +17,7 @@ const makeReporter = () => {
 const noopTestContext = { test: todo };
 const options = (initCwd, github = false) => ({
     args: [],
-    env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTION: 'true' } : {}) },
+    env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTIONS: 'true' } : {}) },
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
     testContext: noopTestContext,
     bunTestContext: noopTestContext,

package/fs/fjs/module.f.js

@@ -6,32 +6,42 @@
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
-import { import_, errorExit } from "../effects/node/module.f.js";
-export const main = options => {
-    const [command, ...rest] = options.args;
-    switch (command) {
-        case 'test':
-        case 't':
-            return testMain({ ...options, args: rest });
-        case 'compile':
-        case 'c':
-            return compile(rest);
-        case 'cas':
-        case 's':
-            return casMain(rest);
-        case 'run':
-        case 'r': {
-            const [file, ...args] = rest;
+import { main as ciMain } from "../ci/module.f.js";
+import { import_ } from "../effects/node/module.f.js";
+import { dispatch } from "../cli/module.f.js";
+const commands = [
+    {
+        names: ['test', 't'],
+        description: 'Run the FunctionalScript test suite',
+        handler: testMain,
+    },
+    {
+        names: ['compile', 'c'],
+        description: 'Compile a FunctionalScript module to JavaScript',
+        handler: ({ args }) => compile(args),
+    },
+    {
+        names: ['cas', 's'],
+        description: 'Content-addressable storage operations',
+        handler: casMain,
+    },
+    {
+        names: ['ci', 'i'],
+        description: 'Generate the GitHub Actions CI workflow',
+        handler: ciMain,
+    },
+    {
+        names: ['run', 'r'],
+        description: 'Run a FunctionalScript module as a NodeProgram',
+        handler: options => {
+            const [file, ...args] = options.args;
             return import_(file).step(([s, v]) => {
                 if (s === 'error') {
                     throw v;
                 }
-                return v.default({ ...options, args });
+                return v.main({ ...options, args });
             });
-        }
-        case undefined:
-            return errorExit('Error: command is required');
-        default:
-            return errorExit(`Error: Unknown command "${command}"`);
-    }
-};
+        },
+    },
+];
+export const main = dispatch(commands);

package/fs/json/module.f.d.ts

@@ -1,18 +1,34 @@
 /**
- * JSON tree types and utilities: `Primitive`/`Unknown` value shapes,
- * `setProperty` for immutable nested updates, and a `stringify` built from the
- * serializer wraps.
+ * JSON value types, rtti schemas, and utilities: `serialize`, `stringify`,
+ * `parse`, and `setProperty` for immutable nested updates.
+ *
+ * The JSON value types (`Unknown`, `Primitive`) are derived from the rtti
+ * schemas defined here, so the schema is the single source of truth — no
+ * hand-written types to keep in sync.
  *
  * @module
  */
 import { type List } from '../types/list/module.f.ts';
 import { type Entry as ObjectEntry } from '../types/object/module.f.ts';
-type Object = {
-    readonly [k in string]: Unknown;
-};
-type Array = readonly Unknown[];
-export type Primitive = boolean | string | number | null;
-export type Unknown = Primitive | Object | Array;
+import type { Ts } from '../types/rtti/ts/module.f.ts';
+/** rtti schema matching any JSON primitive: `null`, `boolean`, `number`, or `string`. */
+export declare const primitive: import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").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`.
+ */
+export declare const unknown: () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>, import("../types/rtti/module.f.ts").Type1<"array", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>];
+/** rtti schema matching a JSON object: `{ readonly [k: string]: Unknown }`. */
+export declare const object: import("../types/rtti/module.f.ts").Type1<"record", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>;
+/** rtti schema matching a JSON array: `readonly Unknown[]`. */
+export declare const array: import("../types/rtti/module.f.ts").Type1<"array", () => readonly ["or", import("../types/rtti/module.f.ts").Or<[null, import("../types/rtti/module.f.ts").Boolean, import("../types/rtti/module.f.ts").Number, import("../types/rtti/module.f.ts").String]>, import("../types/rtti/module.f.ts").Type1<"record", /*elided*/ any>, import("../types/rtti/module.f.ts").Type1<"array", /*elided*/ any>]>;
+export type Primitive = Ts<typeof primitive>;
+export type Unknown = Ts<typeof unknown>;
 export declare const setProperty: (value: Unknown) => (path: List<string>) => (src: Unknown) => Unknown;
 export type Entry = ObjectEntry<Unknown>;
 type Entries = List<Entry>;

package/fs/json/module.f.js

@@ -1,7 +1,10 @@
 /**
- * JSON tree types and utilities: `Primitive`/`Unknown` value shapes,
- * `setProperty` for immutable nested updates, and a `stringify` built from the
- * serializer wraps.
+ * JSON value types, rtti schemas, and utilities: `serialize`, `stringify`,
+ * `parse`, and `setProperty` for immutable nested updates.
+ *
+ * The JSON value types (`Unknown`, `Primitive`) are derived from the rtti
+ * schemas defined here, so the schema is the single source of truth — no
+ * hand-written types to keep in sync.
  *
  * @module
  */
@@ -10,6 +13,25 @@ import { concat } from "../types/string/module.f.js";
 import { at } from "../types/object/module.f.js";
 import { compose, fn } from "../types/function/module.f.js";
 import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "./serializer/module.f.js";
+import { boolean as rttiBoolean, number as rttiNumber, string as rttiString, or, record, array as rttiArray } from "../types/rtti/module.f.js";
+// ── rtti schemas ──────────────────────────────────────────────────────────────
+/** 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`.
+ */
+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);
+// ── JSON utilities ────────────────────────────────────────────────────────────
 const { entries } = Object;
 export const setProperty = value => {
     const f = path => src => {