functionalscript 0.36.0 → 0.38.0

package/fjs/media/json/module.f.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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';
+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", any>, import("../../types/rtti/module.f.ts").Type1<"array", any>]>];
+/**
+ * rtti schema matching a JSON object: `{ readonly [k: string]?: Unknown }`.
+ */
+export declare const object: import("../../types/rtti/module.f.ts").Type1<"record", typeof unknown>;
+/** rtti schema matching a JSON array: `readonly Unknown[]`. */
+export declare const array: import("../../types/rtti/module.f.ts").Type1<"array", typeof unknown>;
+export type Primitive = Ts<typeof primitive>;
+export type Unknown = Object | Array | Primitive;
+export type Object = {
+    readonly [k in string]?: Unknown;
+};
+export type Array = readonly Unknown[];
+export declare const setProperty: (value: Unknown) => (path: List<string>) => (src: Unknown) => Unknown;
+export type Entry = ObjectEntry<Unknown>;
+type Entries = List<Entry>;
+type MapEntries = (entries: Entries) => Entries;
+export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ * https://tc39.es/ecma262/#sec-serializejsonproperty
+ */
+export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+export declare const parse: (value: string) => Unknown;
+export {};

package/{fs → fjs/media}/json/module.f.js

@@ -8,12 +8,12 @@
  *
  * @module
  */
-import { next, flat, map } from "../types/list/module.f.js";
-import { concat } from "../types/string/module.f.js";
-import { at, definedEntries } 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";
+import { next, flat, map } from '../../types/list/module.f.js';
+import { concat } from '../../types/string/module.f.js';
+import { at, definedEntries } 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);
@@ -54,7 +54,7 @@ export const serialize = sort => {
         f(v)
     ]);
     const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn((definedEntries))
+    const objectSerialize = fn(definedEntries)
         .map(sort)
         .map(mapPropertySerialize)
         .map(objectWrap)

package/{fs → fjs/media}/json/parser/module.f.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { type Result } from '../../types/result/module.f.ts';
-import { type List } from '../../types/list/module.f.ts';
+import { type Result } from '../../../types/result/module.f.ts';
+import { type List } from '../../../types/list/module.f.ts';
 import { type JsonToken } from '../tokenizer/module.f.ts';
 import { type Unknown } from '../module.f.ts';
 /**
@@ -14,3 +14,8 @@ import { type Unknown } from '../module.f.ts';
  * when the token sequence is invalid or incomplete.
  */
 export declare const parse: (tokenList: List<JsonToken>) => Result<Unknown, string>;
+export declare const proof: {
+    pushKey: {
+        nonObjectTop: () => void;
+    };
+};

package/{fs → fjs/media}/json/parser/module.f.js

@@ -3,13 +3,14 @@
  *
  * @module
  */
-import { error, ok } from "../../types/result/module.f.js";
-import { fold, first, drop, toArray, concat } from "../../types/list/module.f.js";
-import {} from "../../types/function/operator/module.f.js";
-import {} from "../tokenizer/module.f.js";
-import { setReplace } from "../../types/ordered_map/module.f.js";
-import {} from "../module.f.js";
-import { fromMap } from "../../types/object/module.f.js";
+import { error, ok } from '../../../types/result/module.f.js';
+import { fold, first, drop, toArray, concat } from '../../../types/list/module.f.js';
+import {} from '../../../types/function/operator/module.f.js';
+import {} from '../tokenizer/module.f.js';
+import { setReplace } from '../../../types/ordered_map/module.f.js';
+import {} from '../module.f.js';
+import { fromMap } from '../../../types/object/module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
 const addToArray = array => value => ({ kind: 'array', values: concat(array.values)([value]) });
@@ -168,3 +169,16 @@ export const parse = tokenList => {
         default: return error('unexpected end');
     }
 };
+export const proof = {
+    pushKey: {
+        // `pushKey` is only ever invoked while `state.top` is an object (the
+        // state machine's `'{'`/`'{,'` statuses guarantee it), so its
+        // non-object guard is a defensive branch unreachable through `parse`.
+        // Call it directly to cover that branch.
+        nonObjectTop: () => {
+            const state = { status: '[', top: { kind: 'array', values: null }, stack: null };
+            const result = pushKey(state)('key');
+            assertEq(result.status, 'error');
+        },
+    },
+};

package/{fs → fjs/media}/json/parser/proof.f.js

@@ -1,9 +1,10 @@
-import { parse } from "./module.f.js";
-import { tokenize } from "../tokenizer/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { stringify as jsonStringify } from "../module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { stringToList } from "../../text/utf16/module.f.js";
+import { parse } from './module.f.js';
+import { tokenize } from '../tokenizer/module.f.js';
+import { toArray } from '../../../types/list/module.f.js';
+import { stringify as jsonStringify } from '../module.f.js';
+import { sort } from '../../../types/object/module.f.js';
+import { stringToList } from '../../../text/utf16/module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
 const tokenizeString = s => toArray(tokenize(stringToList(s)));
 const stringify = jsonStringify(sort);
 export const proof = {
@@ -12,81 +13,61 @@ export const proof = {
             const tokenList = tokenizeString('null');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",null]') {
-                throw result;
-            }
+            assertEq(result, '["ok",null]');
         },
         () => {
             const tokenList = tokenizeString('true');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",true]') {
-                throw result;
-            }
+            assertEq(result, '["ok",true]');
         },
         () => {
             const tokenList = tokenizeString('false');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",false]') {
-                throw result;
-            }
+            assertEq(result, '["ok",false]');
         },
         () => {
             const tokenList = tokenizeString('0.1');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",0.1]') {
-                throw result;
-            }
+            assertEq(result, '["ok",0.1]');
         },
         () => {
             const tokenList = tokenizeString('1.1e+2');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",110]') {
-                throw result;
-            }
+            assertEq(result, '["ok",110]');
         },
         () => {
             const tokenList = tokenizeString('"abc"');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok","abc"]') {
-                throw result;
-            }
+            assertEq(result, '["ok","abc"]');
         },
         () => {
             const tokenList = tokenizeString('[]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",[]]') {
-                throw result;
-            }
+            assertEq(result, '["ok",[]]');
         },
         () => {
             const tokenList = tokenizeString('[1]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",[1]]') {
-                throw result;
-            }
+            assertEq(result, '["ok",[1]]');
         },
         () => {
             const tokenList = tokenizeString('[[]]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",[[]]]') {
-                throw result;
-            }
+            assertEq(result, '["ok",[[]]]');
         },
         () => {
             const tokenList = tokenizeString('[0,[1,[2,[]]],3]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["ok",[0,[1,[2,[]]],3]]') {
-                throw result;
-            }
+            assertEq(result, '["ok",[0,[1,[2,[]]],3]]');
         },
         () => {
             const tokenList = tokenizeString('{}');
@@ -126,34 +107,26 @@ export const proof = {
             const tokenList = tokenizeString('');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected end"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected end"]');
         },
         // Trailing commas are not valid JSON — strict parser rejects them.
         () => {
             const tokenList = tokenizeString('[1,]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"a":1,}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('"123');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         // A literal control character inside a string is not valid JSON (RFC
         // 8259 §7) even though the shared tokenizer would otherwise accept it.
@@ -161,193 +134,145 @@ export const proof = {
             const tokenList = tokenizeString('"\t"');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"a":"\t"}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[,]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[1 2]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[1,,2]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[]]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('["a"');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected end"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected end"]');
         },
         () => {
             const tokenList = tokenizeString('[,1]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[:]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString(']');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{,}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{1:2}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"1"2}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"1"::2}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"1":2,,"3":4');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{}}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"1":2');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected end"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected end"]');
         },
         () => {
             const tokenList = tokenizeString('{,"1":2}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{"a":1 "b":2}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('[{]}');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('{[}]');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('10-5');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
         () => {
             const tokenList = tokenizeString('undefined');
             const obj = parse(tokenList);
             const result = stringify(obj);
-            if (result !== '["error","unexpected token"]') {
-                throw result;
-            }
+            assertEq(result, '["error","unexpected token"]');
         },
     ]
 };

package/{fs → fjs/media}/json/proof.f.js

@@ -1,7 +1,7 @@
-import { setProperty, stringify } from "./module.f.js";
-import { sort } from "../types/object/module.f.js";
-import { identity } from "../types/function/module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { setProperty, stringify } from './module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { identity } from '../../types/function/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     setProperty: [
         () => {

package/fjs/media/json/rpc/module.f.d.ts

@@ -0,0 +1,114 @@
+import type { Ts } from '../../../types/rtti/ts/module.f.ts';
+import type { Result } from '../../../types/result/module.f.ts';
+import { unknown, type Unknown } from '../module.f.ts';
+export declare const jsonrpc: '2.0';
+/** 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.
+ *
+ * https://www.jsonrpc.org/specification#request_object
+ */
+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 [typeof unknown, 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 [typeof unknown, 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: typeof unknown;
+    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 [typeof unknown, 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.
+ *
+ * https://www.jsonrpc.org/specification#response_object
+ */
+export declare const response: import("../../../types/rtti/module.f.ts").Or<[{
+    readonly jsonrpc: "2.0";
+    readonly result: typeof unknown;
+    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 [typeof unknown, 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 [typeof unknown, 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 [typeof unknown, 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 [typeof unknown, 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 [typeof unknown, 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 [typeof unknown, 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 [typeof unknown, 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 {};