functionalscript 0.39.0 → 0.40.0

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

@@ -0,0 +1,30 @@
+/**
+ * A minimal, checked eDSL for constructing and serializing Nix expressions.
+ *
+ * The tree deliberately models syntax rather than evaluated Nix values. String
+ * expressions are escaped double-quoted strings; the other supported forms are
+ * represented by tagged tuples.
+ *
+ * @module
+ */
+import { type List as ChunkList } from '../../types/list/module.f.ts';
+type Identifier = string;
+type AttributeName = string;
+type AttributePath = readonly [AttributeName, ...AttributeName[]];
+type Binding = readonly ['=', AttributePath, Expression];
+type Reference = readonly ['ref', Identifier, ...AttributeName[]];
+type AttributeSet = readonly ['set', ...Binding[]];
+type NixList = readonly ['list', ...Reference[]];
+type ApplicationArgument = Reference | AttributeSet;
+type Application = readonly ['apply', Reference, ...ApplicationArgument[]];
+type OpenSetPattern = readonly ['open-set-pattern', ...Identifier[]];
+type Lambda = readonly ['lambda', OpenSetPattern, Expression];
+type Let = readonly ['let', readonly Binding[], Expression];
+type IndentedString = readonly ['indented-string', string];
+/** The Nix syntax supported by the serializer. */
+export type Expression = string | Reference | AttributeSet | NixList | Application | Lambda | Let | IndentedString;
+/** Serializes an expression into composable chunks, or rejects an invalid identifier. */
+export declare const nix: (expression: Expression) => ChunkList<string> | undefined;
+/** Serializes an expression with exactly one trailing newline on success. */
+export declare const nixToString: (expression: Expression) => string | undefined;
+export {};

package/fjs/media/nix/module.f.js

@@ -0,0 +1,166 @@
+/**
+ * A minimal, checked eDSL for constructing and serializing Nix expressions.
+ *
+ * The tree deliberately models syntax rather than evaluated Nix values. String
+ * expressions are escaped double-quoted strings; the other supported forms are
+ * represented by tagged tuples.
+ *
+ * @module
+ */
+import { toArray } from '../../types/list/module.f.js';
+import { concat } from '../../types/string/module.f.js';
+import { includes } from '../../types/array/module.f.js';
+import { digitRange, latinCapitalLetterRange, latinSmallLetterRange, range, } from '../../text/ascii/module.f.js';
+import { fromRange, get, merge } from '../../types/range_set/module.f.js';
+const reservedWords = [
+    'assert',
+    'else',
+    'if',
+    'in',
+    'inherit',
+    'let',
+    'or',
+    'rec',
+    'then',
+    'with',
+];
+const isReservedWord = includes(reservedWords);
+const letters = merge(fromRange(latinCapitalLetterRange))(fromRange(latinSmallLetterRange));
+const identifierInitial = toArray(merge(letters)(fromRange(range('_'))));
+const getIdentifierInitial = get(identifierInitial);
+const isIdentifierInitial = (character) => getIdentifierInitial(character.charCodeAt(0));
+const identifierTrailing = toArray(merge(merge(identifierInitial)(fromRange(digitRange)))(merge(fromRange(range("'")))(fromRange(range('-')))));
+const getIdentifierTrailing = get(identifierTrailing);
+const isIdentifierTrailing = (character) => getIdentifierTrailing(character.charCodeAt(0));
+const isIdentifier = (value) => {
+    const [initial, ...trailing] = value;
+    return initial !== undefined
+        && isIdentifierInitial(initial)
+        && trailing.every(isIdentifierTrailing)
+        && !isReservedWord(value);
+};
+const indent = (level) => '    '.repeat(level);
+const escapeQuoted = (value) => value
+    .replaceAll('\\', '\\\\')
+    .replaceAll('"', '\\"')
+    .replaceAll('${', '\\${')
+    .replaceAll('\n', '\\n')
+    .replaceAll('\r', '\\r')
+    .replaceAll('\t', '\\t');
+const quoted = (value) => `"${escapeQuoted(value)}"`;
+const attributeName = (value) => isIdentifier(value) ? value : quoted(value);
+const attributePath = (path) => path.map(attributeName).join('.');
+const escapeIndented = (value) => value
+    .replaceAll("''", "'''")
+    .replaceAll('${', "''${");
+const protectLeadingWhitespace = (line) => {
+    const contentStart = [...line, 'x'].findIndex(character => character !== ' ' && character !== '\t');
+    const leading = line.slice(0, contentStart)
+        .replaceAll(' ', "''\\ ")
+        .replaceAll('\t', "''\\t");
+    return `${leading}${line.slice(contentStart)}`;
+};
+const serializeReference = ([, name, ...selection]) => isIdentifier(name)
+    ? [name, ...selection.map(attributeName)].join('.')
+    : undefined;
+const serializeReferenceChunks = (reference) => {
+    const serialized = serializeReference(reference);
+    return serialized === undefined ? undefined : [serialized];
+};
+const serializePattern = ([, ...names]) => names.every((name, index) => isIdentifier(name) && names.indexOf(name) === index)
+    ? `{ ${[...names, '...'].join(', ')} }`
+    : undefined;
+const joinChunks = (chunks, separator) => chunks.flatMap((chunk, index) => index === 0 ? chunk : [separator, ...chunk]);
+const isPathPrefix = (prefix, path) => prefix.length <= path.length
+    && prefix.every((name, index) => name === path[index]);
+const pathsConflict = (a, b) => isPathPrefix(a, b) || isPathPrefix(b, a);
+const bindingsCompatible = (bindings) => bindings.every(([, path], index) => bindings.slice(0, index).every(([, previous]) => !pathsConflict(path, previous)));
+const serializeBindings = (bindings, level) => {
+    if (!bindingsCompatible(bindings)) {
+        return undefined;
+    }
+    const serialized = bindings.map(([, path, value]) => {
+        const expression = serialize(value, level);
+        return expression === undefined
+            ? undefined
+            : [indent(level), attributePath(path), ' = ', ...expression, ';'];
+    });
+    const defined = serialized.flatMap(value => value === undefined ? [] : [value]);
+    return defined.length !== serialized.length
+        ? undefined
+        : joinChunks(defined, '\n');
+};
+const serializeSet = ([, ...bindings], level) => {
+    if (bindings.length === 0) {
+        return ['{}'];
+    }
+    const body = serializeBindings(bindings, level + 1);
+    return body === undefined ? undefined : ['{\n', ...body, '\n', indent(level), '}'];
+};
+const serializeList = ([, ...references]) => {
+    const items = references.map(serializeReference);
+    const definedItems = items.flatMap(item => item === undefined ? [] : [item]);
+    return items.includes(undefined)
+        ? undefined
+        : items.length === 0
+            ? ['[ ]']
+            : ['[ ', ...definedItems.flatMap((item, index) => index === 0 ? [item] : [' ', item]), ' ]'];
+};
+const serializeApplication = ([, fn, ...args], level) => {
+    const serializedFn = serializeReference(fn);
+    const serializedArgs = args.map(argument => argument[0] === 'ref'
+        ? serializeReferenceChunks(argument)
+        : serializeSet(argument, level));
+    const definedArgs = serializedArgs.flatMap(argument => argument === undefined ? [] : [argument]);
+    return serializedFn === undefined || definedArgs.length !== serializedArgs.length
+        ? undefined
+        : [serializedFn, ...definedArgs.flatMap(argument => [' ', ...argument])];
+};
+const serializeLambda = ([, pattern, body], level) => {
+    const serializedPattern = serializePattern(pattern);
+    const serializedBody = serialize(body, level);
+    return serializedPattern === undefined || serializedBody === undefined
+        ? undefined
+        : [serializedPattern, ': ', ...serializedBody];
+};
+const serializeLet = ([, bindings, body], level) => {
+    const serializedBindings = serializeBindings(bindings, level + 1);
+    const serializedBody = serialize(body, level);
+    return serializedBindings === undefined || serializedBody === undefined
+        ? undefined
+        : ['let\n', ...serializedBindings, '\n', indent(level), 'in\n', indent(level), ...serializedBody];
+};
+const serialize = (expression, level) => {
+    if (typeof expression === 'string') {
+        return [quoted(expression)];
+    }
+    switch (expression[0]) {
+        case 'ref': {
+            return serializeReferenceChunks(expression);
+        }
+        case 'set': return serializeSet(expression, level);
+        case 'list': return serializeList(expression);
+        case 'apply': return serializeApplication(expression, level);
+        case 'lambda': return serializeLambda(expression, level);
+        case 'let': return serializeLet(expression, level);
+        case 'indented-string': {
+            const [, value] = expression;
+            const contentIndent = indent(level + 1);
+            const content = escapeIndented(value)
+                .split('\n')
+                .map(protectLeadingWhitespace)
+                .map(line => `${contentIndent}${line}`)
+                .join('\n');
+            return ["''\n", content, '\n', indent(level), "''"];
+        }
+    }
+};
+/** Serializes an expression into composable chunks, or rejects an invalid identifier. */
+export const nix = (expression) => {
+    return serialize(expression, 0);
+};
+/** Serializes an expression with exactly one trailing newline on success. */
+export const nixToString = (expression) => {
+    const chunks = nix(expression);
+    return chunks === undefined ? undefined : `${concat(chunks)}\n`;
+};

package/fjs/media/nix/proof.f.d.ts

@@ -0,0 +1,32 @@
+export declare const proof: {
+    strings: () => void;
+    reference: () => void;
+    emptySetAndList: () => void;
+    multiReferenceList: () => void;
+    compatiblePaths: () => void;
+    chunks: () => void;
+    indentedStringEscaping: () => void;
+    emptyPattern: () => void;
+    node24: () => void;
+    node22: () => void;
+    invalid: {
+        reference: () => void;
+        reservedReference: () => void;
+        emptyReference: () => void;
+        digitReference: () => void;
+        nonAsciiReference: () => void;
+        pattern: () => void;
+        duplicatePattern: () => void;
+        duplicateBinding: () => void;
+        parentThenChildBinding: () => void;
+        childThenParentBinding: () => void;
+        duplicateLetBinding: () => void;
+        bindingValue: () => void;
+        listItem: () => void;
+        applicationFunction: () => void;
+        applicationArgument: () => void;
+        lambdaBody: () => void;
+        letBinding: () => void;
+        letBody: () => void;
+    };
+};

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

@@ -0,0 +1,127 @@
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
+import { nix, nixToString } from './module.f.js';
+const nodeFlake = (nodePackage, shellHook) => ['set',
+    ['=', ['inputs', 'nixpkgs', 'url'], 'github:NixOS/nixpkgs/<commit>'],
+    ['=', ['outputs'], ['lambda',
+            ['open-set-pattern', 'nixpkgs'],
+            ['set',
+                ['=', ['devShells', 'aarch64-linux', 'default'],
+                    ['let', [
+                            ['=', ['pkgs'], ['apply',
+                                    ['ref', 'import'],
+                                    ['ref', 'nixpkgs'],
+                                    ['set', ['=', ['system'], 'aarch64-linux']]
+                                ]]
+                        ], ['apply',
+                            ['ref', 'pkgs', 'mkShell'],
+                            ['set',
+                                ['=', ['packages'], ['list', ['ref', 'pkgs', nodePackage]]],
+                                ...(shellHook ? [[
+                                        '=',
+                                        ['shellHook'],
+                                        ['indented-string', `export NPM_CONFIG_PREFIX="$HOME/.npm-global"
+export PATH="$NPM_CONFIG_PREFIX/bin:$PATH"
+mkdir -p "$NPM_CONFIG_PREFIX"`]
+                                    ]] : [])
+                            ]
+                        ]]
+                ]
+            ]
+        ]]
+];
+const node24 = `{
+    inputs.nixpkgs.url = "github:NixOS/nixpkgs/<commit>";
+    outputs = { nixpkgs, ... }: {
+        devShells.aarch64-linux.default = let
+            pkgs = import nixpkgs {
+                system = "aarch64-linux";
+            };
+        in
+        pkgs.mkShell {
+            packages = [ pkgs.nodejs_24 ];
+        };
+    };
+}
+`;
+const node22 = `{
+    inputs.nixpkgs.url = "github:NixOS/nixpkgs/<commit>";
+    outputs = { nixpkgs, ... }: {
+        devShells.aarch64-linux.default = let
+            pkgs = import nixpkgs {
+                system = "aarch64-linux";
+            };
+        in
+        pkgs.mkShell {
+            packages = [ pkgs.nodejs_22 ];
+            shellHook = ''
+                export NPM_CONFIG_PREFIX="$HOME/.npm-global"
+                export PATH="$NPM_CONFIG_PREFIX/bin:$PATH"
+                mkdir -p "$NPM_CONFIG_PREFIX"
+            '';
+        };
+    };
+}
+`;
+export const proof = {
+    strings: () => {
+        assertEq(nixToString('"\\${\n\r\t'), `"\\"\\\\\\\${\\n\\r\\t"\n`);
+    },
+    reference: () => {
+        assertEq(nixToString(['ref', 'pkgs', 'a.b', 'or']), 'pkgs."a.b"."or"\n');
+        assertEq(nixToString(['ref', "a-b'9"]), "a-b'9\n");
+        assertEq(nixToString(['ref', '_AZ']), '_AZ\n');
+    },
+    emptySetAndList: () => {
+        assertEq(nixToString(['set']), '{}\n');
+        assertEq(nixToString(['list']), '[ ]\n');
+    },
+    multiReferenceList: () => {
+        assertEq(nixToString(['list', ['ref', 'pkgs', 'nodejs_22'], ['ref', 'pkgs', 'nodejs_24']]), '[ pkgs.nodejs_22 pkgs.nodejs_24 ]\n');
+    },
+    compatiblePaths: () => {
+        assertEq(nixToString(['set', ['=', ['x', 'y'], 'a'], ['=', ['x', 'z'], 'b']]), '{\n    x.y = "a";\n    x.z = "b";\n}\n');
+    },
+    chunks: () => {
+        const chunks = nix(['list', ['ref', 'pkgs', 'nodejs_24']]);
+        assert(chunks !== undefined);
+        const [open, reference, close, extra] = toArray(chunks);
+        assertEq(open, '[ ');
+        assertEq(reference, 'pkgs.nodejs_24');
+        assertEq(close, ' ]');
+        assertEq(extra, undefined);
+    },
+    indentedStringEscaping: () => {
+        assertEq(nixToString(['indented-string', "a '' ${b}"]), "''\n    a ''' ''${b}\n''\n");
+        assertEq(nixToString(['indented-string', '  a\n\t b\n  ']), "''\n    ''\\ ''\\ a\n    ''\\t''\\ b\n    ''\\ ''\\ \n''\n");
+    },
+    emptyPattern: () => {
+        assertEq(nixToString(['lambda', ['open-set-pattern'], ['set']]), '{ ... }: {}\n');
+    },
+    node24: () => {
+        assertEq(nixToString(nodeFlake('nodejs_24', false)), node24);
+    },
+    node22: () => {
+        assertEq(nixToString(nodeFlake('nodejs_22', true)), node22);
+    },
+    invalid: {
+        reference: () => assertEq(nixToString(['ref', 'not valid']), undefined),
+        reservedReference: () => assertEq(nixToString(['ref', 'let']), undefined),
+        emptyReference: () => assertEq(nixToString(['ref', '']), undefined),
+        digitReference: () => assertEq(nixToString(['ref', '1abc']), undefined),
+        nonAsciiReference: () => assertEq(nixToString(['ref', 'é']), undefined),
+        pattern: () => assertEq(nixToString(['lambda', ['open-set-pattern', 'if'], ['set']]), undefined),
+        duplicatePattern: () => assertEq(nixToString(['lambda', ['open-set-pattern', 'x', 'x'], ['set']]), undefined),
+        duplicateBinding: () => assertEq(nixToString(['set', ['=', ['x'], 'a'], ['=', ['x'], 'b']]), undefined),
+        parentThenChildBinding: () => assertEq(nixToString(['set', ['=', ['x'], 'a'], ['=', ['x', 'y'], 'b']]), undefined),
+        childThenParentBinding: () => assertEq(nixToString(['set', ['=', ['x', 'y'], 'a'], ['=', ['x'], 'b']]), undefined),
+        duplicateLetBinding: () => assertEq(nixToString(['let', [['=', ['x'], 'a'], ['=', ['x'], 'b']], ['ref', 'x']]), undefined),
+        bindingValue: () => assertEq(nixToString(['set', ['=', ['ok'], ['ref', 'bad name']]]), undefined),
+        listItem: () => assertEq(nixToString(['list', ['ref', 'valid'], ['ref', 'bad name']]), undefined),
+        applicationFunction: () => assertEq(nixToString(['apply', ['ref', 'with']]), undefined),
+        applicationArgument: () => assertEq(nixToString(['apply', ['ref', 'f'], ['ref', 'bad name']]), undefined),
+        lambdaBody: () => assertEq(nixToString(['lambda', ['open-set-pattern', 'good'], ['ref', 'bad name']]), undefined),
+        letBinding: () => assertEq(nixToString(['let', [['=', ['x'], ['ref', 'bad name']]], ['ref', 'x']]), undefined),
+        letBody: () => assertEq(nixToString(['let', [], ['ref', 'bad name']]), undefined),
+    }
+};

package/fjs/module.f.js

@@ -9,7 +9,7 @@ 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 './cas/mcp/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 = [

package/fjs/protocol/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 '../../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 {};

package/fjs/{media/json/rpc → protocol/json_rpc}/module.f.js

@@ -14,9 +14,9 @@
  *
  * @module
  */
-import { number, string, or, option } from '../../../types/rtti/module.f.js';
-import { validate } from '../../../types/rtti/validate/module.f.js';
-import { unknown } from '../module.f.js';
+import { number, string, or, option } from '../../types/rtti/module.f.js';
+import { validate } from '../../types/rtti/validate/module.f.js';
+import { unknown } from '../../media/json/module.f.js';
 export const jsonrpc = '2.0';
 /** Request/response identifier: a string, a number, or `null`. */
 const id = or(string, number, null);

package/fjs/{media/json/rpc → protocol/json_rpc}/proof.f.js

@@ -1,6 +1,6 @@
-import { assert, assertEq } from '../../../asserts/module.f.js';
-import { ok, error } from '../../../types/result/module.f.js';
-import { validate } from '../../../types/rtti/validate/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { ok, error } from '../../types/result/module.f.js';
+import { validate } from '../../types/rtti/validate/module.f.js';
 import { error as errorSchema, decodeRequest, dispatch, rpcError, parseError, invalidRequest, methodNotFound, invalidParams, internalError, } from './module.f.js';
 const isOk = (r) => r[0] === 'ok';
 const handlers = {