functionalscript 0.43.0 → 0.44.0

package/fjs/media/type/proof.f.js

@@ -1,213 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { msb, u8ListToVec, vec8, repeat, empty } from '../../types/bit_vec/module.f.js';
-import { runPure } from '../../effects/module.f.js';
-import { nonEmpty, empty as emptyList } from '../../effects/list/module.f.js';
-import { ok } from '../../types/result/module.f.js';
-import { detect, detectStream, detectVec } from './module.f.js';
-// Builds a big-endian `Vec` from a list of byte values — mirrors how the CAS
-// store would hold the leading bytes of a stored blob.
-const bytes = (...b) => u8ListToVec(msb)(b);
-// ── Streaming detector helpers ──────────────────────────────────────────────────
-// Builds a CAS-style read stream from a sequence of ok(chunk) items.
-const stream = (...chunks) => chunks.reduceRight((tail, c) => nonEmpty(ok(c), tail), emptyList());
-// Runs the streaming detector over the given chunks and unwraps the metadata.
-const detectChunks = (...chunks) => {
-    const o = runPure(detectStream(stream(...chunks)));
-    assert(o.length === 1, 'effect is not pure');
-    const [r] = o;
-    assert(r[0] !== 'error', r[1]);
-    return r[1];
-};
-export const proof = {
-    png: () => assertEq(detect(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a)), 'image/png'),
-    jpeg: () => assertEq(detect(bytes(0xff, 0xd8, 0xff, 0xe0)), 'image/jpeg'),
-    gif89a: () => assertEq(detect(bytes(0x47, 0x49, 0x46, 0x38, 0x39, 0x61)), 'image/gif'),
-    gif87a: () => assertEq(detect(bytes(0x47, 0x49, 0x46, 0x38, 0x37, 0x61)), 'image/gif'),
-    // "GIF8" alone, without a valid version suffix, is not a GIF.
-    gif8NotGif: () => assertEq(detect(bytes(0x47, 0x49, 0x46, 0x38, 0x30, 0x30)), null),
-    pdf: () => 
-    // "%PDF-1.4"
-    assertEq(detect(bytes(0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x34)), 'application/pdf'),
-    zip: () => assertEq(detect(bytes(0x50, 0x4b, 0x03, 0x04, 0x14, 0x00)), 'application/zip'),
-    // An empty ZIP archive starts with the end-of-central-directory record.
-    emptyZip: () => assertEq(detect(bytes(0x50, 0x4b, 0x05, 0x06, 0x00, 0x00)), 'application/zip'),
-    webp: () => 
-    // "RIFF" + 4-byte size + "WEBP"
-    assertEq(detect(bytes(0x52, 0x49, 0x46, 0x46, 0x1a, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42, 0x50)), 'image/webp'),
-    // "RIFF…" without the "WEBP" marker (e.g. a WAV) is not WebP.
-    riffNotWebp: () => assertEq(detect(bytes(0x52, 0x49, 0x46, 0x46, 0x1a, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45)), null),
-    // Plain ASCII text matches no signature.
-    textIsNull: () => assertEq(detect(bytes(0x68, 0x65, 0x6c, 0x6c, 0x6f)), null),
-    // A prefix shorter than any signature falls through to null, not a partial match.
-    shortIsNull: () => assertEq(detect(bytes(0x89, 0x50)), null),
-    emptyIsNull: () => assertEq(detect(empty), null),
-    // ── Streaming detector (detectStream) ───────────────────────────────────────
-    stream: {
-        // Plain UTF-8 text classifies as text/plain with the correct byte length.
-        text: () => {
-            const m = detectChunks(bytes(0x68, 0x65, 0x6c, 0x6c, 0x6f)); // "hello"
-            assertEq(m.type, 'text');
-            assertEq(m.mime_type, 'text/plain');
-            assertEq(m.length, 5n);
-        },
-        // A magic-byte signature classifies as base64 with the detected mime type.
-        png: () => {
-            const m = detectChunks(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x01));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'image/png');
-            assertEq(m.length, 10n);
-        },
-        // Unknown binary (no signature, not UTF-8) falls back to octet-stream/base64.
-        octetStream: () => {
-            const m = detectChunks(bytes(0xff, 0xfe, 0x00, 0x01));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 4n);
-        },
-        // A NUL-byte blob is valid single-byte UTF-8 (all U+0000) but is binary:
-        // NUL is the sharpest binary marker, so it classifies as octet-stream.
-        nul: () => {
-            const m = detectChunks(bytes(0x00, 0x00, 0x00));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 3n);
-        },
-        // A control byte embedded in otherwise-valid ASCII (here ESC) is still
-        // binary — text/plain must not imply terminal escapes.
-        controlByte: () => {
-            const m = detectChunks(bytes(0x68, 0x69, 0x1b, 0x5b, 0x30, 0x6d)); // "hi\x1b[0m"
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 6n);
-        },
-        // A C1 control arrives as 2-byte UTF-8 (C2 85 = U+0085, NEL); invisible at
-        // the byte level, it is caught at the code-point level and reads as binary.
-        c1Control: () => {
-            const m = detectChunks(bytes(0x41, 0xc2, 0x85)); // "A" + U+0085
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 3n);
-        },
-        // The text whitespace controls (TAB, LF, VT, FF, CR) are legitimate in text.
-        whitespaceControlsStayText: () => {
-            const m = detectChunks(bytes(0x61, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x62)); // "a\t\n\v\f\rb"
-            assertEq(m.type, 'text');
-            assertEq(m.mime_type, 'text/plain');
-            assertEq(m.length, 7n);
-        },
-        // Magic-byte detection threads across a chunk boundary mid-signature.
-        magicAcrossChunks: () => {
-            const m = detectChunks(bytes(0x89, 0x50, 0x4e), // first 3 bytes of the PNG signature
-            bytes(0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00)); // the rest, in a second chunk
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'image/png');
-            assertEq(m.length, 9n);
-        },
-        // WebP's wildcard size gap is handled in the streaming form too.
-        webp: () => {
-            const m = detectChunks(bytes(0x52, 0x49, 0x46, 0x46), // "RIFF"
-            bytes(0x1a, 0x00, 0x00, 0x00), // 4-byte size (wildcards)
-            bytes(0x57, 0x45, 0x42, 0x50)); // "WEBP"
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'image/webp');
-            assertEq(m.length, 12n);
-        },
-        // A multi-byte UTF-8 sequence split across chunks stays valid text.
-        utf8AcrossChunks: () => {
-            const m = detectChunks(bytes(0xc3), bytes(0xa9)); // "é" = C3 A9
-            assertEq(m.type, 'text');
-            assertEq(m.mime_type, 'text/plain');
-            assertEq(m.length, 2n);
-        },
-        // The decisive case: valid UTF-8 for every chunk but the last, which adds a
-        // lone invalid byte. A leading-bytes buffer would wrongly say "text"; the
-        // streaming validator sees the whole blob and classifies it as base64.
-        validUntilTrailingInvalidByte: () => {
-            const m = detectChunks(bytes(0x68, 0x65, 0x6c, 0x6c, 0x6f), // "hello" — valid UTF-8
-            bytes(0xff)); // trailing invalid byte
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 6n);
-        },
-        // A truncated multi-byte sequence at EOF is invalid UTF-8, hence base64.
-        truncatedSequence: () => {
-            const m = detectChunks(bytes(0xc3)); // lead byte with no continuation
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 1n);
-        },
-        // A blob larger than `maxLength` (1,048,576 bits) split across chunks — the
-        // exact case where `collectRead` would error — returns correct metadata.
-        largeMultiChunkBlob: () => {
-            const a = repeat(70000n)(vec8(0x61n)); // 70,000 bytes of 'a' (560,000 bits)
-            const m = detectChunks(a, a); // 140,000 bytes = 1,120,000 bits > maxLength
-            assertEq(m.type, 'text');
-            assertEq(m.mime_type, 'text/plain');
-            assertEq(m.length, 140000n);
-        },
-        // A magic match settles the verdict on its own: a large magic-matched blob
-        // whose tail stays valid UTF-8 (an ASCII PDF) classifies by the signature.
-        // `push` stops decoding the tail once `magic` is matched — `finish` ignores
-        // the utf8 verdict here — so this is the magic-matched fast path.
-        pdfThenLargeTextTail: () => {
-            const header = bytes(0x25, 0x50, 0x44, 0x46, 0x2d); // "%PDF-"
-            const tail = repeat(70000n)(vec8(0x61n)); // valid ASCII, never invalidates utf8
-            const m = detectChunks(header, tail);
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/pdf');
-            assertEq(m.length, 70005n);
-        },
-        // A magic match wins regardless of the tail: a binary (non-UTF-8) tail
-        // after the signature is still classified by the signature.
-        pdfThenBinaryTail: () => {
-            const header = bytes(0x25, 0x50, 0x44, 0x46, 0x2d); // "%PDF-"
-            const m = detectChunks(header, bytes(0xff, 0xfe, 0x00));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/pdf');
-            assertEq(m.length, 8n);
-        },
-        // A read `error` item short-circuits into the IoResult error.
-        readErrorSurfaces: () => {
-            const errStream = nonEmpty(['error', 'boom'], emptyList());
-            const o = runPure(detectStream(errStream));
-            assert(o.length === 1, 'effect is not pure');
-            assert(o[0][0] === 'error');
-        },
-        // Empty stream: zero-length text/plain.
-        empty: () => {
-            const m = detectChunks();
-            assertEq(m.type, 'text');
-            assertEq(m.length, 0n);
-        },
-    },
-    // ── Single-Vec detector (detectVec) ─────────────────────────────────────────
-    // The whole-Vec form used by the `cas_get` content:true path; same machine,
-    // same three-way verdict as the streaming form.
-    vec: {
-        text: () => {
-            const m = detectVec(bytes(0x68, 0x65, 0x6c, 0x6c, 0x6f)); // "hello"
-            assertEq(m.type, 'text');
-            assertEq(m.mime_type, 'text/plain');
-            assertEq(m.length, 5n);
-        },
-        png: () => {
-            const m = detectVec(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x01));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'image/png');
-            assertEq(m.length, 10n);
-        },
-        octetStream: () => {
-            const m = detectVec(bytes(0xff, 0xfe, 0x00, 0x01));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 4n);
-        },
-        // Valid UTF-8 NUL run is binary in the single-Vec path too.
-        nul: () => {
-            const m = detectVec(bytes(0x00, 0x00, 0x00));
-            assertEq(m.type, 'base64');
-            assertEq(m.mime_type, 'application/octet-stream');
-            assertEq(m.length, 3n);
-        },
-    },
-};

package/fjs/module.f.d.ts

@@ -1,2 +0,0 @@
-import { type NodeProgram } from './effects/node/module.f.ts';
-export declare const main: NodeProgram;

package/fjs/module.f.js

@@ -1,50 +0,0 @@
-/**
- * FunctionalScript compiler entry points and command handlers.
- *
- * @module
- */
-import { compile } from './djs/module.f.js';
-import { main as testMain } from './emergent_testing/module.f.js';
-import { commands as casCommands } from './cas/cli/module.f.js';
-import { main as ciMain } from './ci/module.f.js';
-import { import_ } from './effects/node/module.f.js';
-import { dispatch } from './cli/module.f.js';
-import { casMcpServer } from './mcp/module.f.js';
-import { pure, step } from './effects/module.f.js';
-import { unwrap } from './types/result/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: casCommands,
-    },
-    {
-        names: ['mcp', 'm'],
-        description: 'Run an MCP server over stdio exposing the CAS and Evo (subjects/heads) as tools',
-        handler: ({ home }) => step(casMcpServer(home), () => pure(0)),
-    },
-    {
-        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 step(import_(file), x => unwrap(x).main({ ...options, args }));
-        },
-    },
-];
-export const main = dispatch(commands);

package/fjs/module.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import { main } from './module.f.js';
-import { run } from './effects/node/module.js';
-await run(main);

package/fjs/path/module.f.d.ts

@@ -1,46 +0,0 @@
-/**
- * Path parsing and normalization helpers for portable module paths.
- *
- * @module
- */
-import type { Reduce, Unary } from '../types/function/operator/module.f.ts';
-/**
- * Converts Windows separators (`\`) to POSIX separators (`/`).
- */
-export declare const toPosix: (path: string) => string;
-/**
- * Splits a path into normalized segments.
- *
- * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
- * (`".."`) segments collapse the previous segment when possible, and Windows
- * separators are converted to POSIX separators.
- */
-export declare const parse: (path: string) => readonly string[];
-/**
- * Normalizes a path string by parsing and rejoining it with POSIX separators.
- */
-export declare const normalize: Unary<string, string>;
-/**
- * Concatenates two path fragments and returns a normalized path.
- */
-export declare const concat: Reduce<string>;
-/**
- * Joins path segments with single POSIX `/` separators, without
- * normalization. Unlike {@link concat}, the result is not parsed/collapsed,
- * so absolute roots and `.`/`..` segments are preserved verbatim. Use this
- * for building paths from already-clean segments (directory walks, store
- * layouts); use {@link concat} when normalization is desired.
- */
-export declare const join: (...list: readonly string[]) => string;
-/**
- * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
- * if it does not start with `base` or `base` is empty.
- * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
- */
-export declare const relativize: (base: string, path: string) => string;
-/**
- * Returns `true` when `prefix` is a strict ancestor of `path` in segment space:
- * every segment of `prefix` matches the corresponding segment of `path`, and
- * `path` has at least one additional segment.
- */
-export declare const isProperPrefix: (prefix: readonly string[], path: readonly string[]) => boolean;

package/fjs/path/module.f.js

@@ -1,71 +0,0 @@
-import { fold, last, take, length, concat as listConcat, toArray } from '../types/list/module.f.js';
-import { join as listJoin, concat as stringConcat } from '../types/string/module.f.js';
-const foldNormalizeOp = input => state => {
-    switch (input) {
-        case '':
-        case '.': {
-            return state;
-        }
-        case '..': {
-            switch (last(undefined)(state)) {
-                case undefined:
-                case '..': {
-                    return listConcat(state)([input]);
-                }
-            }
-            return take(length(state) - 1)(state);
-        }
-        default: {
-            return listConcat(state)([input]);
-        }
-    }
-};
-/**
- * Converts Windows separators (`\`) to POSIX separators (`/`).
- */
-export const toPosix = (path) => path.replaceAll('\\', '/');
-/**
- * Splits a path into normalized segments.
- *
- * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
- * (`".."`) segments collapse the previous segment when possible, and Windows
- * separators are converted to POSIX separators.
- */
-export const parse = (path) => {
-    const split = toPosix(path).split('/');
-    return toArray(fold(foldNormalizeOp)([])(split));
-};
-/**
- * Normalizes a path string by parsing and rejoining it with POSIX separators.
- */
-export const normalize = path => {
-    const foldResult = parse(path);
-    return listJoin('/')(foldResult);
-};
-/**
- * Concatenates two path fragments and returns a normalized path.
- */
-export const concat = a => b => {
-    const s = stringConcat([a, '/', b]);
-    return normalize(s);
-};
-/**
- * Joins path segments with single POSIX `/` separators, without
- * normalization. Unlike {@link concat}, the result is not parsed/collapsed,
- * so absolute roots and `.`/`..` segments are preserved verbatim. Use this
- * for building paths from already-clean segments (directory walks, store
- * layouts); use {@link concat} when normalization is desired.
- */
-export const join = (...list) => list.join('/');
-/**
- * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
- * if it does not start with `base` or `base` is empty.
- * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
- */
-export const relativize = (base, path) => base !== '' && path.startsWith(base) ? `.${path.slice(base.length)}` : path;
-/**
- * Returns `true` when `prefix` is a strict ancestor of `path` in segment space:
- * every segment of `prefix` matches the corresponding segment of `path`, and
- * `path` has at least one additional segment.
- */
-export const isProperPrefix = (prefix, path) => prefix.length < path.length && prefix.every((seg, i) => seg === path[i]);

package/fjs/path/proof.f.js

@@ -1,119 +0,0 @@
-import { concat, isProperPrefix, join, normalize, relativize, toPosix } from "./module.f.js";
-import { assertEq } from '../asserts/module.f.js';
-const normalizeTest = [
-    () => {
-        const norm = normalize("dir/file.json");
-        assertEq(norm, "dir/file.json");
-    },
-    () => {
-        const norm = normalize("dir//file.json");
-        assertEq(norm, "dir/file.json");
-    },
-    () => {
-        const norm = normalize("../../dir/file.json");
-        assertEq(norm, "../../dir/file.json");
-    },
-    () => {
-        const norm = normalize("../../dir/../file.json");
-        assertEq(norm, "../../file.json");
-    },
-];
-const concatTest = [
-    () => {
-        const c = concat("a")("b");
-        assertEq(c, "a/b");
-    },
-    () => {
-        const c = concat("a///b/")("c");
-        assertEq(c, "a/b/c");
-    },
-    () => {
-        const c = concat("a/../b/..")("c");
-        assertEq(c, "c");
-    },
-];
-const joinTest = [
-    () => {
-        const r = join('a', 'b');
-        assertEq(r, 'a/b');
-    },
-    () => {
-        const r = join('/abs/root', 'x');
-        assertEq(r, '/abs/root/x');
-    },
-    () => {
-        const r = join('a', 'b', 'c', 'd');
-        assertEq(r, 'a/b/c/d');
-    },
-    () => {
-        const r = join('', 'x');
-        assertEq(r, '/x');
-    },
-    () => {
-        const r = join();
-        assertEq(r, '');
-    },
-    () => {
-        const r = join('only');
-        assertEq(r, 'only');
-    },
-];
-const relativizeTest = [
-    () => {
-        const r = relativize('/repo', '/repo/fs/a.ts');
-        assertEq(r, './fs/a.ts');
-    },
-    () => {
-        const r = relativize('/repo', '/other/a.ts');
-        assertEq(r, '/other/a.ts');
-    },
-    () => {
-        const r = relativize('', './fs/a.ts');
-        assertEq(r, './fs/a.ts');
-    },
-];
-const toPosixTest = [
-    () => {
-        const p = toPosix('a\\b\\c');
-        assertEq(p, 'a/b/c');
-    },
-    () => {
-        const p = toPosix('a/b/c');
-        assertEq(p, 'a/b/c');
-    },
-    () => {
-        const p = toPosix('C:\\Users\\x');
-        assertEq(p, 'C:/Users/x');
-    },
-    () => {
-        const p = toPosix('');
-        assertEq(p, '');
-    },
-];
-const isProperPrefixTest = [
-    () => {
-        const r = isProperPrefix(['a', 'b'], ['a', 'b', 'c']);
-        assertEq(r, true);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'b'], ['a', 'b']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'x'], ['a', 'b', 'c']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix(['a', 'b', 'c'], ['a', 'b']);
-        assertEq(r, false);
-    },
-    () => {
-        const r = isProperPrefix([], ['a']);
-        assertEq(r, true);
-    },
-    () => {
-        const r = isProperPrefix([], []);
-        assertEq(r, false);
-    },
-];
-export const proof = { normalizeTest, concatTest, joinTest, relativizeTest, toPosixTest, isProperPrefixTest };

package/fjs/proof.f.js

@@ -1,38 +0,0 @@
-import { assert, assertEq } from './asserts/module.f.js';
-import { pure } from './effects/module.f.js';
-import { defaultNodeProgramOptions, emptyState, virtual } from './effects/node/virtual/module.f.js';
-import { main } from './module.f.js';
-const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
-const run = (root) => (args) => virtual({ ...emptyState, root })(main(makeOptions(args)));
-const appMain = ({ args }) => pure(args.length);
-export const proof = {
-    help: () => {
-        const [state, code] = run({})(['help']);
-        assertEq(code, 0);
-        assert(state.stdout.includes('compile'), 'expected command list in stdout');
-    },
-    compileRequiresArgs: () => {
-        const [state, code] = run({})(['compile']);
-        assertEq(code, 1);
-        assert(state.stderr.length !== 0, 'expected error in stderr');
-    },
-    runModule: () => {
-        const root = { 'app.f.ts': () => ({ main: appMain }) };
-        const [, code] = run(root)(['run', 'app.f.ts', 'x', 'y']);
-        // `run` strips the command and file name, so `main` sees two arguments
-        assertEq(code, 2);
-    },
-    mcp: () => {
-        // stdin is empty in the virtual environment, so the server sees EOF
-        // immediately and shuts down cleanly, exercising the `mcp` handler.
-        // The store is empty too, so `casMcpServer`'s Evo cache scan
-        // (`initEvo`) also runs and finds nothing.
-        const [, code] = run({})(['mcp']);
-        assertEq(code, 0);
-    },
-    throw: {
-        runImportError: () => {
-            run({})(['run', 'missing.f.ts']);
-        },
-    },
-};

package/fjs/protocol/json_rpc/module.f.d.ts

@@ -1,114 +0,0 @@
-import type { Ts } from '../../types/rtti/ts/module.f.ts';
-import type { Result } from '../../types/result/module.f.ts';
-import { unknown, type Unknown } from '../../media/json/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 {};