functionalscript 0.24.0 → 0.25.0

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/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 => {

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

@@ -0,0 +1,109 @@
+import type { Ts } from '../../types/rtti/ts/module.f.ts';
+import type { Result } from '../../types/result/module.f.ts';
+import { type Unknown } from '../module.f.ts';
+/** Request/response identifier: a string, a number, or `null`. */
+declare const id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
+/**
+ * A request or notification envelope. `id` present → request (a response is
+ * expected); `id` absent → notification (no response). `params` is optional.
+ */
+export declare const request: {
+    readonly jsonrpc: "2.0";
+    readonly method: import("../../types/rtti/module.f.ts").String;
+    readonly params: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    readonly id: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>, undefined]>;
+};
+/** The JSON-RPC error object. */
+export declare const error: {
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+};
+export type Id = Ts<typeof id>;
+export type Request = Ts<typeof request>;
+export type RpcError = Ts<typeof error>;
+export declare const successResponse: {
+    readonly jsonrpc: "2.0";
+    readonly result: () => 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>];
+    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
+};
+export declare const errorResponse: {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../types/rtti/module.f.ts").Number;
+        readonly message: import("../../types/rtti/module.f.ts").String;
+        readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    };
+    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
+};
+/**
+ * A response envelope: either a success (`result`) or an error (`error`).
+ * Derived from the rtti schema via `Ts<>` — the same declaration is the
+ * runtime decoder and the static type, with no drift. rtti structs are open
+ * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
+ * practice the dispatcher only ever constructs one or the other.
+ */
+export declare const response: import("../../types/rtti/module.f.ts").Or<[{
+    readonly jsonrpc: "2.0";
+    readonly result: () => 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>];
+    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
+}, {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../types/rtti/module.f.ts").Number;
+        readonly message: import("../../types/rtti/module.f.ts").String;
+        readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    };
+    readonly id: import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>;
+}]>;
+export type Response = Ts<typeof response>;
+/** Decodes an untrusted value as a JSON-RPC request / notification. */
+export declare const decodeRequest: import("../../types/rtti/common/module.f.ts").Validate<{
+    readonly jsonrpc: "2.0";
+    readonly method: import("../../types/rtti/module.f.ts").String;
+    readonly params: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    readonly id: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").String, import("../../types/rtti/module.f.ts").Number, null]>, undefined]>;
+}>;
+/** A method implementation: maps `params` to a result or an `RpcError`. */
+export type Handler = (params: Unknown | undefined) => Result<Unknown, RpcError>;
+/** A `method` name → `Handler` map. */
+export type Handlers = {
+    readonly [method: string]: Handler;
+};
+/** Builds an `RpcError` with the given `code` and `message` (no `data`). */
+export declare const rpcError: (code: number) => (message: string) => RpcError;
+export declare const parseError: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+}>;
+export declare const invalidRequest: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+}>;
+export declare const methodNotFound: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+}>;
+export declare const invalidParams: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+}>;
+export declare const internalError: import("../../types/rtti/ts/module.f.ts").StructTs<{
+    readonly code: import("../../types/rtti/module.f.ts").Number;
+    readonly message: import("../../types/rtti/module.f.ts").String;
+    readonly data: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+}>;
+/**
+ * Dispatches an already-parsed JSON-RPC value against `handlers`.
+ *
+ * - invalid envelope → `Invalid Request` (`-32600`) with `id: null`
+ * - notification (no `id`) → `null` (never a response)
+ * - unknown method → `Method not found` (`-32601`)
+ * - otherwise the handler's `ok` / `error` result becomes a success / error response
+ */
+export declare const dispatch: (handlers: Handlers) => (value: Unknown) => Response | null;
+export {};

package/fs/json/rpc/module.f.js

@@ -0,0 +1,84 @@
+/**
+ * JSON-RPC 2.0 envelopes and a pure dispatcher.
+ *
+ * The envelopes are rtti schemas, so one declaration yields both a runtime
+ * decoder (`validate(request)`) and the static type (`Ts<typeof request>`) — no
+ * drift between them. The dispatcher is pure: it maps an already-parsed request
+ * value to a response value (or `null` for a notification) and performs no I/O.
+ *
+ * Out of scope here (follow-ups): transports — stdio / HTTP framing — over
+ * `fs/effects/node`, and concrete method sets such as MCP (i665-mcp), which layer
+ * on top of `dispatch`.
+ *
+ * @module
+ */
+import { number, string, or, option } from "../../types/rtti/module.f.js";
+import { validate } from "../../types/rtti/validate/module.f.js";
+import { unknown } from "../module.f.js";
+const jsonrpc = '2.0';
+/** Request/response identifier: a string, a number, or `null`. */
+const id = or(string, number, null);
+/**
+ * A request or notification envelope. `id` present → request (a response is
+ * expected); `id` absent → notification (no response). `params` is optional.
+ */
+export const request = {
+    jsonrpc,
+    method: string,
+    params: option(unknown),
+    id: option(id),
+};
+/** The JSON-RPC error object. */
+export const error = {
+    code: number,
+    message: string,
+    data: option(unknown),
+};
+export const successResponse = { jsonrpc, result: unknown, id };
+export const errorResponse = { jsonrpc, error, id };
+/**
+ * A response envelope: either a success (`result`) or an error (`error`).
+ * Derived from the rtti schema via `Ts<>` — the same declaration is the
+ * runtime decoder and the static type, with no drift. rtti structs are open
+ * (extra keys allowed), so "result XOR error" is not enforced at runtime; in
+ * practice the dispatcher only ever constructs one or the other.
+ */
+export const response = or(successResponse, errorResponse);
+/** Decodes an untrusted value as a JSON-RPC request / notification. */
+export const decodeRequest = validate(request);
+/** Builds an `RpcError` with the given `code` and `message` (no `data`). */
+export const rpcError = (code) => (message) => ({ code, message });
+// The standard JSON-RPC 2.0 errors.
+export const parseError = rpcError(-32700)('Parse error');
+export const invalidRequest = rpcError(-32600)('Invalid Request');
+export const methodNotFound = rpcError(-32601)('Method not found');
+export const invalidParams = rpcError(-32602)('Invalid params');
+export const internalError = rpcError(-32603)('Internal error');
+const errorResponseOf = (id) => (e) => ({ jsonrpc, error: e, id });
+/**
+ * Dispatches an already-parsed JSON-RPC value against `handlers`.
+ *
+ * - invalid envelope → `Invalid Request` (`-32600`) with `id: null`
+ * - notification (no `id`) → `null` (never a response)
+ * - unknown method → `Method not found` (`-32601`)
+ * - otherwise the handler's `ok` / `error` result becomes a success / error response
+ */
+export const dispatch = (handlers) => (value) => {
+    const decoded = decodeRequest(value);
+    if (decoded[0] === 'error') {
+        return errorResponseOf(null)(invalidRequest);
+    }
+    const message = decoded[1];
+    const id = message.id;
+    if (id === undefined) {
+        return null;
+    }
+    const handler = handlers[message.method];
+    if (handler === undefined) {
+        return errorResponseOf(id)(methodNotFound);
+    }
+    const result = handler(message.params);
+    return result[0] === 'ok'
+        ? { jsonrpc, result: result[1], id }
+        : errorResponseOf(id)(result[1]);
+};

package/fs/json/rpc/proof.f.d.ts

@@ -0,0 +1,35 @@
+export declare const proof: {
+    schema: {
+        request: {
+            full: () => void;
+            notification: () => void;
+            nullId: () => void;
+            stringId: () => void;
+            badVersion: () => void;
+            missingMethod: () => void;
+            badId: () => void;
+            notObject: () => void;
+        };
+        error: {
+            ok: () => void;
+            withData: () => void;
+            missingMessage: () => void;
+        };
+    };
+    errors: {
+        factory: () => void;
+        parseError: () => void;
+        invalidRequest: () => void;
+        methodNotFound: () => void;
+        invalidParams: () => void;
+        internalError: () => void;
+    };
+    dispatch: {
+        success: () => void;
+        paramsPassed: () => void;
+        handlerError: () => void;
+        methodNotFound: () => void;
+        invalidRequest: () => void;
+        notification: () => void;
+    };
+};

package/fs/json/rpc/proof.f.js

@@ -0,0 +1,68 @@
+import { assert, assertEq } from "../../asserts/module.f.js";
+import { ok, error } from "../../types/result/module.f.js";
+import { validate } from "../../types/rtti/validate/module.f.js";
+import { error as errorSchema, decodeRequest, dispatch, rpcError, parseError, invalidRequest, methodNotFound, invalidParams, internalError, } from "./module.f.js";
+const isOk = (r) => r[0] === 'ok';
+const handlers = {
+    ping: () => ok('pong'),
+    echo: params => ok(params ?? null),
+    boom: () => error(invalidParams),
+};
+const d = dispatch(handlers);
+export const proof = {
+    schema: {
+        request: {
+            full: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', params: [1], id: 1 }))),
+            notification: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm' }))),
+            nullId: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: null }))),
+            stringId: () => assert(isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: 'abc' }))),
+            badVersion: () => assert(!isOk(decodeRequest({ jsonrpc: '1.0', method: 'm', id: 1 }))),
+            missingMethod: () => assert(!isOk(decodeRequest({ jsonrpc: '2.0', id: 1 }))),
+            badId: () => assert(!isOk(decodeRequest({ jsonrpc: '2.0', method: 'm', id: true }))),
+            notObject: () => assert(!isOk(decodeRequest(42))),
+        },
+        error: {
+            ok: () => assert(isOk(validate(errorSchema)({ code: -1, message: 'x' }))),
+            withData: () => assert(isOk(validate(errorSchema)({ code: -1, message: 'x', data: [1, 2] }))),
+            missingMessage: () => assert(!isOk(validate(errorSchema)({ code: -1 }))),
+        },
+    },
+    errors: {
+        factory: () => {
+            const e = rpcError(-7)('boom');
+            assertEq(e.code, -7);
+            assertEq(e.message, 'boom');
+        },
+        parseError: () => { assertEq(parseError.code, -32700); assertEq(parseError.message, 'Parse error'); },
+        invalidRequest: () => { assertEq(invalidRequest.code, -32600); assertEq(invalidRequest.message, 'Invalid Request'); },
+        methodNotFound: () => { assertEq(methodNotFound.code, -32601); assertEq(methodNotFound.message, 'Method not found'); },
+        invalidParams: () => { assertEq(invalidParams.code, -32602); assertEq(invalidParams.message, 'Invalid params'); },
+        internalError: () => { assertEq(internalError.code, -32603); assertEq(internalError.message, 'Internal error'); },
+    },
+    dispatch: {
+        success: () => {
+            const r = d({ jsonrpc: '2.0', method: 'ping', id: 1 });
+            assert(r !== null && 'result' in r && r.result === 'pong' && r.id === 1);
+        },
+        paramsPassed: () => {
+            const r = d({ jsonrpc: '2.0', method: 'echo', params: 'hi', id: 2 });
+            assert(r !== null && 'result' in r && r.result === 'hi');
+        },
+        handlerError: () => {
+            const r = d({ jsonrpc: '2.0', method: 'boom', id: 3 });
+            assert(r !== null && 'error' in r && r.error.code === -32602 && r.id === 3);
+        },
+        methodNotFound: () => {
+            const r = d({ jsonrpc: '2.0', method: 'nope', id: 4 });
+            assert(r !== null && 'error' in r && r.error.code === -32601);
+        },
+        invalidRequest: () => {
+            const r = d({ jsonrpc: '1.0', method: 'ping', id: 5 });
+            assert(r !== null && 'error' in r && r.error.code === -32600 && r.id === null);
+        },
+        notification: () => {
+            const r = d({ jsonrpc: '2.0', method: 'ping' });
+            assertEq(r, null);
+        },
+    },
+};

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

@@ -0,0 +1,76 @@
+/**
+ * Converts an rtti schema to a JSON Schema (draft 2020-12) object.
+ *
+ * Mirrors the visitor structure of `fs/types/rtti/ts/module.f.ts` (`printer` / `toTs`),
+ * but emits a JSON Schema object instead of a TypeScript type string.
+ *
+ * @module
+ */
+import { type Type as RttiType } from '../../types/rtti/module.f.ts';
+import type { Ts, WithOut } from '../../types/rtti/ts/module.f.ts';
+declare const unknownThunk: () => readonly ["const", {
+    readonly type: import("../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    readonly not: import("../../types/rtti/module.f.ts").Or<readonly [WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, undefined]>;
+    readonly anyOf: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly items: import("../../types/rtti/module.f.ts").Or<[WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly properties: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly required: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").String>, undefined]>;
+    readonly additionalProperties: import("../../types/rtti/module.f.ts").Or<readonly [WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, undefined]>;
+}];
+/** rtti schema for a JSON Schema (draft 2020-12) document. */
+export declare const unknown: WithOut<typeof unknownThunk, UnknownConst>;
+/** A JSON Schema (draft 2020-12) document — the subset of keywords that `toJsonSchema` emits. */
+export type Unknown = Ts<typeof unknown>;
+declare const unknownConst: {
+    readonly type: import("../../types/rtti/module.f.ts").Or<["boolean", "number", "string", "integer", "array", "object", undefined]>;
+    readonly const: import("../../types/rtti/module.f.ts").Or<readonly [() => 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>], undefined]>;
+    readonly not: import("../../types/rtti/module.f.ts").Or<readonly [WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, undefined]>;
+    readonly anyOf: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly items: import("../../types/rtti/module.f.ts").Or<[WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, false, undefined]>;
+    readonly prefixItems: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly properties: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>>, undefined]>;
+    readonly required: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"array", import("../../types/rtti/module.f.ts").String>, undefined]>;
+    readonly additionalProperties: import("../../types/rtti/module.f.ts").Or<readonly [WithOut<() => readonly ["const", /*elided*/ any], UnknownConst>, undefined]>;
+};
+/**
+ * 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.
+ */
+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…] }`                                                             |
+ */
+export declare const toJsonSchema: (rtti: RttiType) => Unknown;
+export {};