functionalscript 0.43.1 → 0.45.0

package/fjs/nanvm/update/module.f.mjs

@@ -0,0 +1,33 @@
+/**
+ * Writes the generated Rust operator tests.
+ *
+ * The printer in [`../rust/module.f.mjs`](../rust/module.f.mjs) is pure; this
+ * module is the thin effectful shell around it, invoked from `ci-update` so
+ * the CI drift check regenerates the file on every pull request and fails
+ * when the committed copy is stale.
+ *
+ * @module
+ *
+ * @import { Effect } from '../../effects/types.ts'
+ * @import { Mkdir, NodeProgram, WriteFile } from '../../effects/node/types.ts'
+ */
+
+import { mapStep, step } from '../../effects/module.f.mjs'
+import { mkdir, writeUtf8File } from '../../effects/node/module.f.mjs'
+import { unwrap } from '../../types/result/module.f.mjs'
+import { data } from '../module.f.mjs'
+import { directory, generate, path } from '../rust/module.f.mjs'
+
+/**
+ * Regenerates `nanvm-lib/tests/test/generated.rs` from the shared test data.
+ *
+ * @type {() => Effect<Mkdir | WriteFile, void>}
+ */
+export const generateRustTests = () => {
+    const directoryReady = mapStep(mkdir(directory, { recursive: true }), unwrap)
+    const written = step(directoryReady, () => writeUtf8File(path, generate(data)))
+    return mapStep(written, unwrap)
+}
+
+/** @type {NodeProgram} */
+export const main = () => mapStep(generateRustTests(), () => 0)

package/fjs/nanvm/update/proof.f.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Proofs for the generated-Rust writer.
+ *
+ * @module
+ */
+export declare const proof: {
+    generateRustTests: () => void;
+    main: () => void;
+};

package/fjs/nanvm/update/proof.f.mjs

@@ -0,0 +1,32 @@
+/**
+ * Proofs for the generated-Rust writer.
+ *
+ * @module
+ */
+
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { step } from '../../effects/module.f.mjs'
+import { readUtf8File } from '../../effects/node/module.f.mjs'
+import {
+    defaultNodeProgramOptions,
+    emptyState,
+    virtual,
+} from '../../effects/node/virtual/module.f.mjs'
+import { data } from '../module.f.mjs'
+import { generate, path } from '../rust/module.f.mjs'
+import { generateRustTests, main } from './module.f.mjs'
+
+export const proof = {
+    generateRustTests: () => {
+        // The target directory does not exist in `emptyState`, so this also
+        // covers the `mkdir` the writer does before the file write.
+        const written = step(generateRustTests(), () => readUtf8File(path))
+        const [, [tag, result]] = virtual(emptyState)(written)
+        assert(tag === 'ok', result)
+        assertEq(result, generate(data))
+    },
+    main: () => {
+        const [, result] = virtual(emptyState)(main(defaultNodeProgramOptions))
+        assertEq(result, 0)
+    },
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Path parsing and normalization helpers for portable module paths.
+ *
+ * @module
+ *
+ * @import { Fold, Reduce, Unary } from '../types/function/operator/types.ts'
+ * @import { List } from '../types/list/types.ts'
+ */
+import type { Reduce, Unary } from '../types/function/operator/types.ts';
+/**
+ * Converts Windows separators (`\`) to POSIX separators (`/`).
+ *
+ * @type {(path: string) => string}
+ */
+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.
+ *
+ * @type {(path: string) => readonly string[]}
+ */
+export declare const parse: (path: string) => readonly string[];
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ *
+ * @type {Unary<string, string>}
+ */
+export declare const normalize: Unary<string, string>;
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ *
+ * @type {Reduce<string>}
+ */
+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.
+ *
+ * @type {(...list: readonly string[]) => string}
+ */
+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'`.
+ *
+ * @type {(base: string, path: string) => string}
+ */
+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.
+ *
+ * @type {(prefix: readonly string[], path: readonly string[]) => boolean}
+ */
+export declare const isProperPrefix: (prefix: readonly string[], path: readonly string[]) => boolean;

package/fjs/path/module.f.mjs

@@ -0,0 +1,98 @@
+/**
+ * Path parsing and normalization helpers for portable module paths.
+ *
+ * @module
+ *
+ * @import { Fold, Reduce, Unary } from '../types/function/operator/types.ts'
+ * @import { List } from '../types/list/types.ts'
+ */
+
+import { fold, last, take, length, concat as listConcat, toArray } from '../types/list/module.f.mjs'
+import { join as listJoin, concat as stringConcat } from '../types/string/module.f.mjs'
+
+/** @type {Fold<string, List<string>>} */
+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 (`/`).
+ *
+ * @type {(path: string) => string}
+ */
+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.
+ *
+ * @type {(path: string) => readonly string[]}
+ */
+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.
+ *
+ * @type {Unary<string, string>}
+ */
+export const normalize = path => {
+    const foldResult = parse(path)
+    return listJoin('/')(foldResult)
+}
+
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ *
+ * @type {Reduce<string>}
+ */
+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.
+ *
+ * @type {(...list: readonly string[]) => string}
+ */
+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'`.
+ *
+ * @type {(base: string, path: string) => string}
+ */
+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.
+ *
+ * @type {(prefix: readonly string[], path: readonly string[]) => boolean}
+ */
+export const isProperPrefix = (prefix, path) =>
+    prefix.length < path.length && prefix.every((seg, i) => seg === path[i])

package/fjs/path/proof.f.mjs

@@ -0,0 +1,125 @@
+import { concat, isProperPrefix, join, normalize, relativize, toPosix } from "./module.f.mjs"
+import { assertEq } from '../asserts/module.f.mjs'
+
+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.d.mts

@@ -0,0 +1,13 @@
+/**
+ * @import { NodeProgram, NodeProgramOptions } from './effects/node/types.ts'
+ * @import { Dir } from './effects/node/virtual/types.ts'
+ */
+export declare const proof: {
+    help: () => void;
+    compileRequiresArgs: () => void;
+    runModule: () => void;
+    mcp: () => void;
+    throw: {
+        runImportError: () => void;
+    };
+};

package/fjs/proof.f.mjs

@@ -0,0 +1,51 @@
+/**
+ * @import { NodeProgram, NodeProgramOptions } from './effects/node/types.ts'
+ * @import { Dir } from './effects/node/virtual/types.ts'
+ */
+
+import { assert, assertEq } from './asserts/module.f.mjs'
+import { pure } from './effects/module.f.mjs'
+import { defaultNodeProgramOptions, emptyState, virtual } from './effects/node/virtual/module.f.mjs'
+import { main } from './module.f.mjs'
+
+/** @type {(args: readonly string[]) => NodeProgramOptions} */
+const makeOptions = args => ({ ...defaultNodeProgramOptions, args })
+
+const run = (/** @type {Dir} */ root) => (/** @type {readonly string[]} */ args) =>
+    virtual({ ...emptyState, root })(main(makeOptions(args)))
+
+/** @type {NodeProgram} */
+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: () => {
+        /** @type {Dir} */
+        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.mts

@@ -0,0 +1,127 @@
+/**
+ * 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
+ * `fjs/effects/node`, and concrete method sets such as MCP (i665-mcp), which layer
+ * on top of `dispatch`.
+ *
+ * https://www.jsonrpc.org/specification
+ *
+ * @module
+ *
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { Id, RpcError, Handlers, Response } from './types.ts'
+ */
+import type { Unknown } from '../../media/json/types.ts';
+import type { RpcError, Handlers, Response } from './types.ts';
+export declare const jsonrpc: '2.0';
+/** Request/response identifier: a string, a number, or `null`. */
+export declare const _id: import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"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/types.ts")._Type0<"string">;
+    readonly params: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+    readonly id: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"number">, null]>, undefined]>;
+};
+/** The JSON-RPC error object. */
+export declare const error: {
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+};
+export declare const successResponse: {
+    readonly jsonrpc: "2.0";
+    readonly result: () => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array];
+    readonly id: import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"number">, null]>;
+};
+export declare const errorResponse: {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+        readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+        readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+    };
+    readonly id: import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"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/types.ts").Or<[{
+    readonly jsonrpc: "2.0";
+    readonly result: () => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array];
+    readonly id: import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"number">, null]>;
+}, {
+    readonly jsonrpc: "2.0";
+    readonly error: {
+        readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+        readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+        readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+    };
+    readonly id: import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"number">, null]>;
+}]>;
+/** Decodes an untrusted value as a JSON-RPC request / notification. */
+export declare const decodeRequest: import("../../types/rtti/common/types.ts").Validate<{
+    readonly jsonrpc: "2.0";
+    readonly method: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly params: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+    readonly id: import("../../types/rtti/types.ts").Or<readonly [import("../../types/rtti/types.ts").Or<[import("../../types/rtti/types.ts")._Type0<"string">, import("../../types/rtti/types.ts")._Type0<"number">, null]>, undefined]>;
+}>;
+/**
+ * Builds an `RpcError` with the given `code` and `message` (no `data`).
+ * @type {(code: number) => (message: string) => RpcError}
+ */
+export declare const rpcError: (code: number) => (message: string) => RpcError;
+export declare const parseError: import("../../types/rtti/ts/types.ts").StructTs<{
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+}>;
+export declare const invalidRequest: import("../../types/rtti/ts/types.ts").StructTs<{
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+}>;
+export declare const methodNotFound: import("../../types/rtti/ts/types.ts").StructTs<{
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+}>;
+export declare const invalidParams: import("../../types/rtti/ts/types.ts").StructTs<{
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], undefined]>;
+}>;
+export declare const internalError: import("../../types/rtti/ts/types.ts").StructTs<{
+    readonly code: import("../../types/rtti/types.ts")._Type0<"number">;
+    readonly message: import("../../types/rtti/types.ts")._Type0<"string">;
+    readonly data: import("../../types/rtti/types.ts").Or<readonly [() => readonly ['or', typeof import("../../media/json/rtti/module.f.mjs").primitive, typeof import("../../media/json/rtti/module.f.mjs").object, typeof import("../../media/json/rtti/module.f.mjs").array], 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
+ *
+ * @param {Handlers} handlers
+ * @returns {(value: Unknown) => Response | null}
+ */
+export declare const dispatch: (handlers: Handlers) => (value: Unknown) => Response | null;