functionalscript 0.43.0 → 0.44.0

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.mjs

@@ -0,0 +1,48 @@
+import { assert, assertEq } from './asserts/module.f.mjs'
+import { pure } from './effects/module.f.mjs'
+/** @import { NodeProgram, NodeProgramOptions } from './effects/node/types.ts' */
+import { defaultNodeProgramOptions, emptyState, virtual } from './effects/node/virtual/module.f.mjs'
+/** @import { Dir } from './effects/node/virtual/types.ts' */
+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, Handler, 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;

package/fjs/protocol/json_rpc/module.f.mjs

@@ -0,0 +1,112 @@
+/**
+ * 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, Handler, Handlers, Response } from './types.ts'
+ */
+
+import { number, string, or, option } from '../../types/rtti/module.f.mjs'
+import { validate } from '../../types/rtti/validate/module.f.mjs'
+import { unknown } from '../../media/json/rtti/module.f.mjs'
+
+export const jsonrpc = /** @type {const} */ ('2.0')
+
+/** Request/response identifier: a string, a number, or `null`. */
+export 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.
+ *
+ * https://www.jsonrpc.org/specification#request_object
+ */
+export const request = /** @type {const} */ ({
+    jsonrpc,
+    method: string,
+    params: option(unknown),
+    id: option(_id),
+})
+
+/** The JSON-RPC error object. */
+export const error = /** @type {const} */ ({
+    code: number,
+    message: string,
+    data: option(unknown),
+})
+
+export const successResponse = /** @type {const} */ ({ jsonrpc, result: unknown, id: _id })
+export const errorResponse = /** @type {const} */ ({ jsonrpc, error, id: _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.
+ *
+ * https://www.jsonrpc.org/specification#response_object
+ */
+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`).
+ * @type {(code: number) => (message: string) => RpcError}
+ */
+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')
+
+/** @type {(id: Id) => (error: RpcError) => Response} */
+const errorResponseOf = id => error => ({ jsonrpc, error, 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
+ *
+ * @param {Handlers} handlers
+ * @returns {(value: Unknown) => Response | null}
+ */
+export const dispatch = handlers => value => {
+    const [t, message] = decodeRequest(value)
+    if (t === 'error') {
+        return errorResponseOf(null)(invalidRequest)
+    }
+    const { id, method, params } = message
+    if (id === undefined) {
+        return null
+    }
+    /** @type {Handler | undefined} */
+    const handler = handlers[method]
+    if (handler === undefined) {
+        return errorResponseOf(id)(methodNotFound)
+    }
+    const [t2, result] = handler(params)
+    return t2 === 'ok'
+        ? { jsonrpc, result, id }
+        : errorResponseOf(id)(result)
+}

package/fjs/protocol/json_rpc/proof.f.mjs

@@ -0,0 +1,84 @@
+/** @import { Handlers } from './types.ts' */
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+import { ok, error } from '../../types/result/module.f.mjs'
+import { validate } from '../../types/rtti/validate/module.f.mjs'
+import {
+    error as errorSchema,
+    decodeRequest,
+    dispatch,
+    rpcError,
+    parseError,
+    invalidRequest,
+    methodNotFound,
+    invalidParams,
+    internalError,
+} from './module.f.mjs'
+
+/** @type {(r: readonly [string, unknown]) => boolean} */
+const isOk = r => r[0] === 'ok'
+
+/** @type {Handlers} */
+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/fjs/protocol/json_rpc/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Type-level API for `fjs/protocol/json_rpc/module.f.mjs`: `Id`, `Request`,
+ * `RpcError`, and `Response`, derived from the module's own rtti schemas,
+ * plus the `Handler` / `Handlers` shapes a dispatcher is built from.
+ *
+ * @module
+ */
+import type { Unknown } from '../../media/json/types.ts';
+import type { Result } from '../../types/result/types.ts';
+import type { _id, request, error as errorSchema, response } from './module.f.mjs';
+import type { Ts } from '../../types/rtti/ts/types.ts';
+export type Id = Ts<typeof _id>;
+export type Request = Ts<typeof request>;
+export type RpcError = Ts<typeof errorSchema>;
+/**
+ * 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 type Response = Ts<typeof response>;
+/** 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;
+};

package/fjs/protocol/json_rpc/types.js

@@ -0,0 +1,8 @@
+/**
+ * Type-level API for `fjs/protocol/json_rpc/module.f.mjs`: `Id`, `Request`,
+ * `RpcError`, and `Response`, derived from the module's own rtti schemas,
+ * plus the `Handler` / `Handlers` shapes a dispatcher is built from.
+ *
+ * @module
+ */
+export {};