functionalscript 0.43.1 → 0.44.0

package/fjs/protocol/mcp/proof.f.js

@@ -1,208 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { pure, step } from '../../effects/module.f.js';
-import { eff } from '../../effects/eff/module.f.js';
-import { run } from '../../effects/mock/module.f.js';
-import { asBase, asNominal, create, read } from '../../effects/memory/module.f.js';
-import { uninitializedState, mcpStep, notInitialized, } from './module.f.js';
-const initial = { next: 0, values: {} };
-const mock = {
-    memCreate: value => state => {
-        const id = `k${state.next}`;
-        const key = asNominal(id);
-        return [{ next: state.next + 1, values: { ...state.values, [id]: value } }, key];
-    },
-    memRead: key => state => [state, state.values[asBase(key)]],
-    memWrite: (key, value) => state => {
-        const id = asBase(key);
-        return [{ ...state, values: { ...state.values, [id]: value } }, undefined];
-    },
-};
-// ── Fixtures ──────────────────────────────────────────────────────────────────
-const config = {
-    serverInfo: { name: 'test-server', version: '0.1.0' },
-    capabilities: { tools: {} },
-    protocolVersion: '2024-11-05',
-};
-const configNoTools = { ...config, capabilities: {} };
-const handlers = {
-    // Echoes a received cursor as `nextCursor` so tests can observe pagination params.
-    toolsList: (p) => pure(p.cursor === undefined
-        ? { tools: [{ name: 'greet', inputSchema: {} }] }
-        : { tools: [], nextCursor: p.cursor }),
-    toolsCall: (_p) => pure({ content: [{ type: 'text', text: 'hello' }] }),
-};
-// Run a memory effect against the mock, return the result.
-const runMem = (effect) => run(mock)(initial)(effect)[1];
-// TypeScript infers O = Operation (the upper bound) rather than O = never when
-// O flows through McpHandlers<never>, so we cast the widened type down to MemOp.
-const asMemEffect = (e) => e;
-// Run one step from uninitializedState, return [response, newState].
-const step1 = (cfg) => (msg) => runMem(asMemEffect(step(create(uninitializedState), key => step(mcpStep(cfg)(handlers)(key)(msg), resp => step(read(key), state => pure([resp, state]))))));
-// Run initialize then a second step, return [response, newState] of the second.
-const step2 = (cfg) => (msg1) => (msg2) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(resp => step(read(key), state => pure([resp, state]))).value).value).value));
-// Run initialize, notifications/initialized, then a third step; return [response, newState] of the third.
-const step3 = (cfg) => (msg1) => (msg2) => (msg3) => runMem(asMemEffect(eff(create(uninitializedState)).step(key => eff(mcpStep(cfg)(handlers)(key)(msg1)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg2)).step(() => eff(mcpStep(cfg)(handlers)(key)(msg3)).step(resp => eff(read(key)).step(state => pure([resp, state])).value).value).value).value).value));
-// ── Test messages ─────────────────────────────────────────────────────────────
-const initMsg = { jsonrpc: '2.0', method: 'initialize', id: 1,
-    params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'client', version: '0.0.1' } } };
-const initNotif = { jsonrpc: '2.0', method: 'notifications/initialized' };
-// ── Tests ─────────────────────────────────────────────────────────────────────
-export const proof = {
-    lifecycle: {
-        initialStateIsUninitialized: () => {
-            assert(uninitializedState[0] === 'uninitialized');
-        },
-        initializeTransitionsToInitializing: () => {
-            const [, newState] = step1(config)(initMsg);
-            assert(newState[0] === 'initializing');
-        },
-        initializedNotificationTransitionsToInitialized: () => {
-            const [resp, newState] = step2(config)(initMsg)(initNotif);
-            assertEq(resp, null);
-            assert(newState[0] === 'initialized');
-        },
-        initializeReturnsResult: () => {
-            const [resp] = step1(config)(initMsg);
-            assert(resp !== null && typeof resp === 'object' && 'result' in resp);
-            const r = resp.result;
-            assertEq(r.protocolVersion, '2024-11-05');
-        },
-        initializeWithBadParamsReturnsInvalidParams: () => {
-            const bad = { jsonrpc: '2.0', method: 'initialize', id: 2, params: { wrong: true } };
-            const [resp, newState] = step1(config)(bad);
-            assert(newState[0] === 'uninitialized');
-            assertEq(resp.error.code, -32602);
-        },
-        notificationBeforeInitReturnNull: () => {
-            const [resp, newState] = step1(config)(initNotif);
-            assert(newState[0] === 'uninitialized');
-            assertEq(resp, null);
-        },
-        unknownNotificationReturnNull: () => {
-            const notif = { jsonrpc: '2.0', method: 'notifications/unknown' };
-            const [resp] = step2(config)(initMsg)(notif);
-            assertEq(resp, null);
-        },
-        doubleInitializeReturnsInvalidRequest: () => {
-            const [resp, newState] = step2(config)(initMsg)(initMsg);
-            assert(newState[0] === 'initializing');
-            assertEq(resp.error.code, -32600);
-        },
-        pingBeforeInitSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'ping', id: 11 };
-            const [resp, newState] = step1(config)(msg);
-            assert(newState[0] === 'uninitialized');
-            assert(!('error' in resp));
-        },
-        pingDuringInitializingSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'ping', id: 12 };
-            const [resp, newState] = step2(config)(initMsg)(msg);
-            assert(newState[0] === 'initializing');
-            assert(!('error' in resp));
-        },
-        pingAfterInitSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'ping', id: 15 };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assert(!('error' in resp));
-        },
-        pingWithObjectParamsSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'ping', id: 19, params: {} };
-            const [resp] = step1(config)(msg);
-            assert(!('error' in resp));
-        },
-        pingInvalidParamsReturnsInvalidParams: () => {
-            const msg = { jsonrpc: '2.0', method: 'ping', id: 20, params: 1 };
-            const [resp] = step1(config)(msg);
-            assertEq(resp.error.code, -32602);
-        },
-        initializedNotificationObjectParamsTransitions: () => {
-            const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: {} };
-            const [resp, newState] = step2(config)(initMsg)(notif);
-            assertEq(resp, null);
-            assert(newState[0] === 'initialized');
-        },
-        initializedNotificationBadParamsIgnored: () => {
-            const notif = { jsonrpc: '2.0', method: 'notifications/initialized', params: 1 };
-            const [resp, newState] = step2(config)(initMsg)(notif);
-            assertEq(resp, null);
-            assert(newState[0] === 'initializing');
-        },
-        methodBeforeInitReturnsNotInitialized: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 3 };
-            const [resp, newState] = step1(config)(msg);
-            assert(newState[0] === 'uninitialized');
-            assertEq(resp.error.code, notInitialized.code);
-        },
-        methodDuringInitializingReturnsNotInitialized: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 16 };
-            const [resp, newState] = step2(config)(initMsg)(msg);
-            assert(newState[0] === 'initializing');
-            assertEq(resp.error.code, notInitialized.code);
-        },
-        invalidEnvelopeReturnsInvalidRequest: () => {
-            const bad = { jsonrpc: '1.0', method: 'ping', id: 4 };
-            const [resp] = step1(config)(bad);
-            assertEq(resp.error.code, -32600);
-            assertEq(resp.id, null);
-        },
-    },
-    tools: {
-        toolsListSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 5 };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.result.tools.length, 1);
-            assertEq(resp.result.tools[0].name, 'greet');
-        },
-        toolsListPassesCursorToHandler: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 17,
-                params: { cursor: 'page-2' } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.result.nextCursor, 'page-2');
-        },
-        toolsListInvalidCursorReturnsInvalidParams: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 18,
-                params: { cursor: 42 } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32602);
-        },
-        toolsCallSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 6,
-                params: { name: 'greet', arguments: {} } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.result.content[0].text, 'hello');
-        },
-        toolsCallBadParamsReturnsInvalidParams: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 7, params: { missing: true } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32602);
-        },
-        toolsCallAbsentArgumentsSucceeds: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 13,
-                params: { name: 'greet' } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.result.content[0].text, 'hello');
-        },
-        toolsCallNullArgumentsReturnsInvalidParams: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 14,
-                params: { name: 'greet', arguments: null } };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32602);
-        },
-        toolsListWithoutCapabilityReturnsMethodNotFound: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/list', id: 8 };
-            const [resp] = step3(configNoTools)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32601);
-        },
-        toolsCallWithoutCapabilityReturnsMethodNotFound: () => {
-            const msg = { jsonrpc: '2.0', method: 'tools/call', id: 9,
-                params: { name: 'greet', arguments: {} } };
-            const [resp] = step3(configNoTools)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32601);
-        },
-        unknownMethodReturnsMethodNotFound: () => {
-            const msg = { jsonrpc: '2.0', method: 'resources/list', id: 10 };
-            const [resp] = step3(config)(initMsg)(initNotif)(msg);
-            assertEq(resp.error.code, -32601);
-        },
-    },
-};

package/fjs/protocol/mcp/stdio/module.f.d.ts

@@ -1,47 +0,0 @@
-/**
- * stdio transport for JSON-RPC / MCP servers.
- *
- * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fjs/protocol/mcp/module.f.ts` — in the
- * canonical read → parse → dispatch → write loop, expressed as a recursive
- * effect so it stays in the pure effect model and is fully testable against a
- * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
- *
- * The loop only consumes `Read` (stdin, one byte at a time, via the pure
- * `readLine` combinator) and emits `Write` (stdout) on top of whatever `O` the
- * step needs (e.g. `MemOp`); it is transport-agnostic and carries no filesystem
- * dependency.
- *
- * Edge cases, matching the issue's spec:
- * - `readLine` yields `null` (EOF) → the loop returns, a clean shutdown.
- * - a malformed JSON line → a JSON-RPC parse-error response (`-32700`, `id`
- *   `null`) is written rather than silently discarded, per JSON-RPC 2.0 §5.
- * - the step yields `null` (a notification needing no reply) → nothing is
- *   written and the loop continues.
- * - a response that doesn't fit in one encoded line (`tryUtf8` overflow —
- *   `maxLength`, 128 KiB) never throws. `writeResponse` retries with a fixed,
- *   small `-32603` internal-error body carrying the original `id`; if even
- *   that overflows (a pathological caller-controlled `id`, e.g. a very large
- *   string), it retries once more with `id: null` — a fully constant response
- *   shape that is always small enough to encode. Every request that reaches
- *   `step` therefore gets *some* response line, never silence and never a
- *   crashed process.
- *
- * @module
- */
-import { type Effect, type Operation } from '../../../effects/module.f.ts';
-import { type Read, type Write } from '../../../effects/node/module.f.ts';
-import { type Unknown } from '../../../media/json/module.f.ts';
-import { type Response } from '../../json_rpc/module.f.ts';
-/**
- * A transport step: maps one parsed JSON-RPC message to a response, or `null`
- * for a notification that needs no reply. The shape of `mcpStep(config)(handlers)(key)`.
- */
-export type Step<O extends Operation> = (value: Unknown) => Effect<O, Response | null>;
-/**
- * Drives the read-parse-dispatch-write loop for `handler` over stdin/stdout.
- *
- * Recurses after each handled line; terminates (resolving to `void`) when
- * `readLine` reports EOF.
- */
-export declare const stdioTransport: <O extends Operation>(handler: Step<O>) => Effect<Read | Write | O, void>;

package/fjs/protocol/mcp/stdio/module.f.js

@@ -1,78 +0,0 @@
-/**
- * stdio transport for JSON-RPC / MCP servers.
- *
- * `stdioTransport` wraps a step function — the `mcpStep`-shaped
- * `(value) => Effect<O, Response | null>` from `fjs/protocol/mcp/module.f.ts` — in the
- * canonical read → parse → dispatch → write loop, expressed as a recursive
- * effect so it stays in the pure effect model and is fully testable against a
- * mock stdin / stdout (see `fjs/effects/node/virtual`) with no real process.
- *
- * The loop only consumes `Read` (stdin, one byte at a time, via the pure
- * `readLine` combinator) and emits `Write` (stdout) on top of whatever `O` the
- * step needs (e.g. `MemOp`); it is transport-agnostic and carries no filesystem
- * dependency.
- *
- * Edge cases, matching the issue's spec:
- * - `readLine` yields `null` (EOF) → the loop returns, a clean shutdown.
- * - a malformed JSON line → a JSON-RPC parse-error response (`-32700`, `id`
- *   `null`) is written rather than silently discarded, per JSON-RPC 2.0 §5.
- * - the step yields `null` (a notification needing no reply) → nothing is
- *   written and the loop continues.
- * - a response that doesn't fit in one encoded line (`tryUtf8` overflow —
- *   `maxLength`, 128 KiB) never throws. `writeResponse` retries with a fixed,
- *   small `-32603` internal-error body carrying the original `id`; if even
- *   that overflows (a pathological caller-controlled `id`, e.g. a very large
- *   string), it retries once more with `id: null` — a fully constant response
- *   shape that is always small enough to encode. Every request that reaches
- *   `step` therefore gets *some* response line, never silence and never a
- *   crashed process.
- *
- * @module
- */
-import { pure, step } from '../../../effects/module.f.js';
-import { readLine, write } from '../../../effects/node/module.f.js';
-import { tryUtf8 } from '../../../text/module.f.js';
-import { parse, stringify } from '../../../media/json/module.f.js';
-import { sort } from '../../../types/object/module.f.js';
-import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.js';
-import { error, ok } from '../../../types/result/module.f.js';
-const stringifyJson = stringify(sort);
-/** The parse-error response (`-32700`, `id: null`) for a malformed input line. */
-const parseErrorResponse = { jsonrpc, error: parseError, id: null };
-/** An internal-error response (`-32603`) carrying `id`. */
-const internalErrorResponse = (id) => ({ jsonrpc, error: internalError, id });
-/** Encodes a response as a newline-terminated UTF-8 line and writes it to `stdout`. */
-const writeResponse = (resp) => {
-    const v = tryUtf8(stringifyJson(resp) + '\n');
-    return v === null
-        ? pure(error(undefined))
-        : step(write('stdout', v), () => pure(ok(undefined)));
-};
-/**
- * Drives the read-parse-dispatch-write loop for `handler` over stdin/stdout.
- *
- * Recurses after each handled line; terminates (resolving to `void`) when
- * `readLine` reports EOF.
- */
-export const stdioTransport = (handler) => step(readLine('stdin'), line => line === null
-    ? pure(undefined)
-    : handleLine(handler)(line));
-const handleLine = (handler) => (line) => {
-    const [t, value] = parse(line);
-    return step(t === 'error'
-        ? writeResponse(parseErrorResponse)
-        : step(handler(value), resp => resp === null
-            ? pure(undefined)
-            : step(writeResponse(resp), ([t2]) => t2 === 'error'
-                // The real response didn't fit. Retry with a fixed, small
-                // internal-error body carrying `resp.id` — but a
-                // caller-controlled `id` (e.g. a very large string) can
-                // itself push even this fallback over `maxLength`, so
-                // that retry is bounded by one more: an `id: null`
-                // internal-error, whose fully-constant shape is the only
-                // line in this transport guaranteed to always encode.
-                ? step(writeResponse(internalErrorResponse(resp.id)), ([t3]) => t3 === 'error'
-                    ? step(writeResponse(internalErrorResponse(null)), () => pure(undefined))
-                    : pure(undefined))
-                : pure(undefined))), () => stdioTransport(handler));
-};

package/fjs/protocol/mcp/stdio/proof.f.d.ts

@@ -1,13 +0,0 @@
-export declare const proof: {
-    eofImmediately: () => void;
-    requestWritesResponse: () => void;
-    requestWithoutTrailingNewline: () => void;
-    notificationWritesNothing: () => void;
-    malformedJsonWritesParseError: () => void;
-    trailingCommaWritesParseError: () => void;
-    undefinedFieldOmitted: () => void;
-    oversizedResponseWritesInternalError: () => void;
-    loopContinuesAfterOversizedResponse: () => void;
-    oversizedIdFallsBackToNullId: () => void;
-    multipleLines: () => void;
-};

package/fjs/protocol/mcp/stdio/proof.f.js

@@ -1,143 +0,0 @@
-import { assertEq } from '../../../asserts/module.f.js';
-import { pure } from '../../../effects/module.f.js';
-import { emptyState, virtual } from '../../../effects/node/virtual/module.f.js';
-import { stringify } from '../../../media/json/module.f.js';
-import { utf8 } from '../../../text/module.f.js';
-import { fromVec } from '../../../types/uint8array/module.f.js';
-import { maxLengthBytes } from '../../../types/bit_vec/module.f.js';
-import { sort } from '../../../types/object/module.f.js';
-import { internalError, jsonrpc, parseError } from '../../json_rpc/module.f.js';
-import { stdioTransport } from './module.f.js';
-const stringifyJson = stringify(sort);
-// Extracts the request `id` (a request has one; a notification does not).
-const idOf = (value) => value !== null && typeof value === 'object' && !(value instanceof Array)
-    ? value.id
-    : undefined;
-// A step that mirrors the mcpStep contract closely enough to drive the loop:
-// a message carrying an `id` (a request) gets an echo success response; a
-// message without an `id` (a notification) yields `null` — no reply.
-const echoStep = (value) => {
-    const id = idOf(value);
-    return pure(id === undefined
-        ? null
-        : { jsonrpc, result: { ok: true }, id });
-};
-// UTF-8 bytes of `s` as a plain array — the virtual stdin byte stream.
-const toBytes = (s) => [...fromVec(utf8(s))];
-// Run the transport with `step` over `input` fed to stdin one byte at a time;
-// return the final state. `input` is raw text so tests control newline framing.
-const runStep = (step) => (input) => virtual({ ...emptyState, stdin: toBytes(input) })(stdioTransport(step))[0];
-const run = runStep(echoStep);
-const okResponse = (id) => stringifyJson({ jsonrpc, result: { ok: true }, id }) + '\n';
-const parseErrorLine = stringifyJson({ jsonrpc, error: parseError, id: null }) + '\n';
-const internalErrorLine = (id) => stringifyJson({ jsonrpc, error: internalError, id }) + '\n';
-const ping = (id) => `{"jsonrpc":"2.0","method":"ping","id":${id}}`;
-// One byte past `maxLengthBytes` on its own; embedded in a response envelope
-// it stays comfortably over the limit despite the surrounding JSON overhead.
-const oversizedString = 'a'.repeat(Number(maxLengthBytes) + 1);
-const notification = '{"jsonrpc":"2.0","method":"notifications/initialized"}';
-export const proof = {
-    // EOF on the very first read: clean shutdown, nothing written, no further reads.
-    eofImmediately: () => {
-        const state = run('');
-        assertEq(state.stdout, '');
-        assertEq(state.stdin.length, 0);
-    },
-    // A newline-terminated request is parsed, dispatched, and its response
-    // written; stdin is fully drained before the terminating EOF.
-    requestWritesResponse: () => {
-        const state = run(ping(1) + '\n');
-        assertEq(state.stdout, okResponse(1));
-        assertEq(state.stdin.length, 0);
-    },
-    // A final line lacking a trailing newline is still flushed and dispatched
-    // (covers `readLine`'s EOF-with-buffered-bytes branch).
-    requestWithoutTrailingNewline: () => {
-        const state = run(ping(2));
-        assertEq(state.stdout, okResponse(2));
-    },
-    // A notification (no `id`) yields a `null` step result → nothing is written.
-    notificationWritesNothing: () => {
-        const state = run(notification + '\n');
-        assertEq(state.stdout, '');
-    },
-    // A malformed JSON line produces a JSON-RPC parse-error response (-32700),
-    // not a silent discard.
-    malformedJsonWritesParseError: () => {
-        const state = run('not json\n');
-        assertEq(state.stdout, parseErrorLine);
-    },
-    // A request that is not strict JSON (trailing comma) must be rejected with
-    // a parse error, never dispatched to the step.
-    trailingCommaWritesParseError: () => {
-        const state = run('{"jsonrpc":"2.0","method":"ping","id":1,}\n');
-        assertEq(state.stdout, parseErrorLine);
-    },
-    // A response with an optional field explicitly `undefined` serializes like
-    // JSON.stringify — the field is omitted, not a thrown TypeError that would
-    // abort the loop.
-    undefinedFieldOmitted: () => {
-        const step = (value) => {
-            const id = idOf(value);
-            return pure(id === undefined
-                ? null
-                : { jsonrpc, result: { ok: true, nextCursor: undefined }, id });
-        };
-        const state = runStep(step)(ping(1) + '\n');
-        assertEq(state.stdout, okResponse(1));
-    },
-    // A response that would exceed `maxLengthBytes` once UTF-8 encoded cannot
-    // be written as a single bit vector (`tryUtf8` reports overflow); the loop
-    // writes a JSON-RPC internal-error response — carrying the original
-    // request's `id`, not `null` — instead of throwing or silently dropping
-    // the reply.
-    oversizedResponseWritesInternalError: () => {
-        const step = (value) => {
-            const id = idOf(value);
-            return pure(id === undefined
-                ? null
-                : { jsonrpc, result: { big: oversizedString }, id });
-        };
-        const state = runStep(step)(ping(1) + '\n');
-        assertEq(state.stdout, internalErrorLine(1));
-    },
-    // The loop recovers from the oversized-response error and keeps draining
-    // stdin: a well-behaved request on the next line still gets its normal
-    // reply.
-    loopContinuesAfterOversizedResponse: () => {
-        const step = (value) => {
-            const id = idOf(value);
-            return pure(id === undefined
-                ? null
-                : id === 1
-                    ? { jsonrpc, result: { big: oversizedString }, id }
-                    : { jsonrpc, result: { ok: true }, id });
-        };
-        const state = runStep(step)([ping(1), ping(2)].join('\n'));
-        assertEq(state.stdout, internalErrorLine(1) + okResponse(2));
-        assertEq(state.stdin.length, 0);
-    },
-    // When even the `id`-preserving internal-error fallback would overflow —
-    // because the `id` itself is the oversized part, not just `result` — the
-    // loop falls back once more to a fixed `id: null` internal-error, the only
-    // shape in this transport guaranteed to always fit. Without this second
-    // fallback tier the request would get no response line at all.
-    oversizedIdFallsBackToNullId: () => {
-        const step = (value) => {
-            const id = idOf(value);
-            return pure(id === undefined
-                ? null
-                : { jsonrpc, result: { ok: true }, id: oversizedString });
-        };
-        const state = runStep(step)(ping(1) + '\n');
-        assertEq(state.stdout, internalErrorLine(null));
-    },
-    // A multi-line session interleaving all cases: request, notification, and
-    // malformed line, ending with an unterminated request. Order is preserved
-    // and the notification contributes nothing.
-    multipleLines: () => {
-        const state = run([ping(1), notification, 'not json', ping(2)].join('\n'));
-        assertEq(state.stdout, okResponse(1) + parseErrorLine + okResponse(2));
-        assertEq(state.stdin.length, 0);
-    },
-};

package/fjs/sul/id/module.f.d.ts

@@ -1,33 +0,0 @@
-/**
- * 256-bit content-addressed identifiers for SUL values.
- * Every identifier is one of three variants: a level-3 literal (inline), a raw bit vector (inline),
- * or a SHA2-based hash, selected automatically by `compress` based on size and input type.
- *
- * @module
- */
-import { type Vec } from '../../types/bit_vec/module.f.ts';
-import { type Nominal } from '../../types/nominal/module.f.ts';
-/** A 256-bit SUL identifier. One of three variants: level-3 literal, raw bit vector, or SHA2 hash. */
-export type Id = Nominal<'sul/id', '6f5f6da053a6ac70e9687d42b7a09e925c3be21027f55beb2cba3040bf3d5b71', bigint>;
-/**
- * Note: no need to add a prefix.
- */
-export declare const level3Id: (v: bigint) => Id;
-/**
- * Note: length(symbol) <= 253n
- *
- * @param symbol
- * @returns
- */
-export declare const rawId: (symbol: Vec) => Id;
-export declare const isRaw: (v: Id) => boolean;
-export declare const isHash: (v: Id) => boolean;
-/**
- * Note: we don't need to remove the prefix bits from the hash because
- * the prefix equals the prefix mask (`1n << 0xFFn`).
- *
- * @param symbol
- * @returns
- */
-export declare const hashId: (hash: bigint) => Id;
-export declare const compress: (a: Id, b: Id) => Id;

package/fjs/sul/id/module.f.js

@@ -1,93 +0,0 @@
-/**
- * 256-bit content-addressed identifiers for SUL values.
- * Every identifier is one of three variants: a level-3 literal (inline), a raw bit vector (inline),
- * or a SHA2-based hash, selected automatically by `compress` based on size and input type.
- *
- * @module
- */
-import { toArray } from '../../types/list/module.f.js';
-import { length, msb, uint, uintChunkList, unpack, vec } from '../../types/bit_vec/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-import { utf8 } from '../../text/module.f.js';
-import { secp256r1 } from '../../crypto/secp/module.f.js';
-import { base32 } from '../../crypto/sha2/module.f.js';
-import { literal3ToVec } from '../level/literal/module.f.js';
-import { log2 } from '../../types/bigint/module.f.js';
-import { asBase, asNominal } from '../../types/nominal/module.f.js';
-// 32 bytes = 256 bits.
-//
-//              0               1
-//              0123456789ABCDEF0123456789ABCDEF
-const ivSeed = "Synthetic Universal Language 001";
-const utf8IvSeed = utf8(ivSeed);
-const c = secp256r1;
-const ivUint = c.mul(uint(utf8IvSeed))(c.g)[0];
-// 64 hex = 256 bits = 32 bytes:
-assertEq(ivUint, 
-//    0                 1                 2                 3
-//    01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF
-0x325d5666573eb118f32191de20d17f6433392ba3291ae46c1474a5eda5383f25n);
-const iv = toArray(uintChunkList(msb)(32n)({ length: 256n, uint: ivUint }));
-assertEq(iv.length, 8);
-/**
- * Note: no need to add a prefix.
- */
-export const level3Id = asNominal;
-const rawPrefixOffset = 0xfen;
-const rawPrefix = 1n << rawPrefixOffset;
-assertEq(rawPrefix, 
-//    0                 1                 2                 3
-//    01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF
-0x4000000000000000000000000000000000000000000000000000000000000000n);
-/**
- * Note: length(symbol) <= 253n
- *
- * @param symbol
- * @returns
- */
-export const rawId = (symbol) => {
-    const { length, uint } = unpack(symbol);
-    return asNominal(rawPrefix | uint | (1n << length));
-};
-// 253
-const rawLenMax = 0xfdn;
-export const isRaw = (v) => asBase(v) >> rawPrefixOffset === 1n;
-const toRaw = (a) => {
-    if (!isRaw(a)) {
-        return literal3ToVec(asBase(a));
-    }
-    const raw = asBase(a) ^ rawPrefix;
-    const len = log2(raw);
-    return vec(len)(raw ^ (1n << len));
-};
-const hashPrefixOffset = 0xffn;
-const hashPrefix = 1n << hashPrefixOffset;
-assertEq(hashPrefix, 
-//    0                 1                 2                 3
-//    01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF_01234567_89ABCDEF
-0x8000000000000000000000000000000000000000000000000000000000000000n);
-export const isHash = (v) => asBase(v) >> hashPrefixOffset === 1n;
-/**
- * Note: we don't need to remove the prefix bits from the hash because
- * the prefix equals the prefix mask (`1n << 0xFFn`).
- *
- * @param symbol
- * @returns
- */
-export const hashId = (hash) => asNominal(hashPrefix | hash);
-const hash2 = base32.compress(iv);
-const vecX20 = vec(0x20n);
-const { concat, listToVec } = msb;
-const hashMerge = (a, b) => hashId(uint(listToVec(hash2((asBase(a) << 0x100n) | asBase(b)).map(vecX20))));
-export const compress = (a, b) => {
-    if (isHash(a) || isHash(b)) {
-        return hashMerge(a, b);
-    }
-    const ra = toRaw(a);
-    const rb = toRaw(b);
-    const len = length(ra) + length(rb);
-    if (len > rawLenMax) {
-        return hashMerge(a, b);
-    }
-    return rawId(concat(ra)(rb));
-};