functionalscript 0.44.0 → 0.45.0

package/fjs/media/type/module.f.mjs

@@ -1,15 +1,16 @@
 /**
  * Magic-byte MIME type detection.
  *
- * `detect` is a pure table lookup over the leading bytes of a `Vec`: it returns a
- * MIME type string for the container formats whose signatures it knows, or `null`
- * for anything else — text, unknown binary, or a `Vec` too short to match.
+ * One list — `signatures` — declares every recognized magic-byte pattern, and
+ * both detectors read it through the same eliminator (`magicStep`): `detect`
+ * folds a whole `Vec` and returns a MIME type string or `null`, while
+ * `detectStream` folds a read stream one chunk at a time.
  *
- * Beside it, `detectStream` is the **streaming counterpart**: a byte-accepting
- * state machine (length × magic-byte eliminator × UTF-8 validity DFA) that derives
- * `{ length, mime_type, type }` by folding a CAS read stream in O(1) space, without
- * ever buffering the blob into a single `maxLength`-bounded `Vec`. See the README
- * for the factored design.
+ * Beside `detect`, `detectStream` is the **streaming counterpart**: a
+ * byte-accepting state machine (length × magic-byte eliminator × UTF-8 validity
+ * DFA) that derives `{ length, mime_type, type }` by folding a CAS read stream in
+ * O(1) space, without ever buffering the blob into a single `maxLength`-bounded
+ * `Vec`. See the README for the factored design.
  *
  * The CAS store is type-agnostic and keeps raw bytes only, so type is never
  * stored; it is recovered on read by sniffing the content. Callers decide what
@@ -27,107 +28,51 @@
  * | `application/zip` | `50 4B 03 04` / `05 06` / `07 08` (`"PK"` entry, empty, or spanned) |
  *
  * WebP is the one signature with a gap: the four-byte little-endian file size
- * sits between the `RIFF` and `WEBP` markers, so it is matched as a prefix plus
- * a second marker at byte offset 8 rather than a single contiguous run.
+ * sits between the `RIFF` and `WEBP` markers, so its pattern carries four
+ * wildcard bytes rather than being one contiguous run.
  *
  * See `./types.ts` for the type-level API.
  *
  * @module
+ *
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { Nullable } from '../../types/nullable/types.ts'
+ * @import { Effect, Operation } from '../../effects/types.ts'
+ * @import { List } from '../../effects/list/types.ts'
+ * @import { IoResult } from '../../effects/node/types.ts'
+ * @import { DetectMeta, DetectState, _MagicState, _Signature, _Utf8Detect } from './types.ts'
  */
 
-import { msb, fromSentinel, length, u8List } from '../../types/bit_vec/module.f.mjs'
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+import { msb, length, u8List } from '../../types/bit_vec/module.f.mjs'
 import { iterable } from '../../types/list/module.f.mjs'
-/** @import { Nullable } from '../../types/nullable/types.ts' */
 import { pure, step } from '../../effects/module.f.mjs'
-/** @import { Effect, Operation } from '../../effects/types.ts' */
-/** @import { List } from '../../effects/list/types.ts' */
-/** @import { IoResult } from '../../effects/node/types.ts' */
 import { ok, error } from '../../types/result/module.f.mjs'
 import { isValidCodePoint, isTextCodePoint } from '../../text/code_point/module.f.mjs'
 import { utf8ByteToCodePointOp } from '../../text/utf8/module.f.mjs'
-/** @import { DetectMeta, DetectState, _MagicState, _Signature, _Utf8Detect } from './types.ts' */
-
-const { startsWith, removeFront } = msb
-
-// Each signature is written as a hex literal whose leading `1` nibble is a
-// sentinel marking the start of the byte run (so leading zero bytes survive)
-// and fixing the length — see `bit_vec` `fromSentinel`.
-const sig = fromSentinel
-
-/**
- * Contiguous magic-byte signatures, checked in order; the first prefix match
- * wins. Ordering is irrelevant here — no signature is a prefix of another.
- *
- * @type {readonly (readonly [Vec, string])[]}
- */
-const table = [
-    [sig(0x1_89_50_4e_47_0d_0a_1a_0an), 'image/png'],
-    [sig(0x1_ff_d8_ffn), 'image/jpeg'],
-    // Match the full GIF version headers ("GIF87a" / "GIF89a"), not just "GIF8",
-    // so opaque bytes that merely start with "GIF8" are not mistyped.
-    [sig(0x1_47_49_46_38_37_61n), 'image/gif'],
-    [sig(0x1_47_49_46_38_39_61n), 'image/gif'],
-    [sig(0x1_25_50_44_46_2dn), 'application/pdf'],
-    // ZIP has three "PK" local-header variants: a normal entry, an empty
-    // archive (end-of-central-directory only), and a spanned archive.
-    [sig(0x1_50_4b_03_04n), 'application/zip'],
-    [sig(0x1_50_4b_05_06n), 'application/zip'],
-    [sig(0x1_50_4b_07_08n), 'application/zip'],
-]
-
-// WebP: "RIFF" at offset 0, "WEBP" at offset 8 (the 4 bytes between are the
-// file size). 12 bytes = 96 bits is the minimum to carry both markers.
-const riff = sig(0x1_52_49_46_46n)
-const webp = sig(0x1_57_45_42_50n)
-
-/** @type {(bytes: Vec) => boolean} */
-const isWebp = bytes =>
-    length(bytes) >= 96n
-        && startsWith(riff)(bytes)
-        && startsWith(webp)(removeFront(64n)(bytes))
-
-/**
- * Detects the MIME type of `bytes` from its leading magic-byte signature.
- *
- * @returns the MIME type string for a recognized format, or `null` when the
- *   leading bytes match no known signature (including any `Vec` shorter than
- *   the signature it might otherwise match).
- *
- * @type {(bytes: Vec) => Nullable<string>}
- */
-export const detect = bytes => {
-    if (isWebp(bytes)) { return 'image/webp' }
-    for (const [s, m] of table) {
-        if (startsWith(s)(bytes)) { return m }
-    }
-    return null
-}
 
-// ── Streaming detector ────────────────────────────────────────────────────────────
+// ── Magic-byte signatures ─────────────────────────────────────────────────────────
 //
-// A byte-accepting state machine that derives the same `{ length, mime_type, type }`
-// metadata as the pure `detect` + UTF-8 path, but **without buffering the blob**.
-// It is the product of three independent folds over the byte stream — length,
-// magic-byte signature elimination, and a UTF-8 validity DFA — read off at
-// end-of-stream by `finish`. This lets `cas_get` inspect arbitrarily large blobs
-// (where a single `Vec` would overflow `maxLength`) in O(1) space, since the bulk
-// of a large blob costs only length counting once the verdict is fixed (see
-// `isSettled`: a magic match settles it immediately, a dead magic once utf8 fails).
+// The single declaration of what a signature is: a byte pattern the eliminator can
+// consume one byte at a time, with `null` for a wildcard byte. Both `detect` and
+// the streaming detector below eliminate against this one list, so a signature is
+// added or corrected in exactly one place.
 
-// The streaming counterpart of `table`/`isWebp`: the same signatures expressed as
-// byte patterns the eliminator can consume one byte at a time. WebP's gap is the
-// only wildcard run.
 /** @type {readonly _Signature[]} */
 const signatures = [
     { pattern: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], mime: 'image/png' },
     { pattern: [0xff, 0xd8, 0xff], mime: 'image/jpeg' },
+    // Match the full GIF version headers ("GIF87a" / "GIF89a"), not just "GIF8",
+    // so opaque bytes that merely start with "GIF8" are not mistyped.
     { pattern: [0x47, 0x49, 0x46, 0x38, 0x37, 0x61], mime: 'image/gif' },
     { pattern: [0x47, 0x49, 0x46, 0x38, 0x39, 0x61], mime: 'image/gif' },
     { pattern: [0x25, 0x50, 0x44, 0x46, 0x2d], mime: 'application/pdf' },
+    // ZIP has three "PK" local-header variants: a normal entry, an empty
+    // archive (end-of-central-directory only), and a spanned archive.
     { pattern: [0x50, 0x4b, 0x03, 0x04], mime: 'application/zip' },
     { pattern: [0x50, 0x4b, 0x05, 0x06], mime: 'application/zip' },
     { pattern: [0x50, 0x4b, 0x07, 0x08], mime: 'application/zip' },
+    // WebP: "RIFF" at offset 0, "WEBP" at offset 8; the four bytes between are
+    // the little-endian file size, matched as wildcards.
     {
         pattern: [0x52, 0x49, 0x46, 0x46, null, null, null, null, 0x57, 0x45, 0x42, 0x50],
         mime: 'image/webp',
@@ -154,6 +99,45 @@ const magicStep = (m, byte) => {
 /** @type {(m: _MagicState) => Nullable<string>} */
 const magicMime = m => m.tag === 'matched' ? m.mime : null
 
+/**
+ * Detects the MIME type of `bytes` from its leading magic-byte signature by
+ * folding them through the same eliminator the streaming detector uses. Both
+ * absorbing states end the fold: a `matched` signature is the answer, and a
+ * `dead` eliminator can no longer produce one. Bytes still in `scan` at the end
+ * of the `Vec` — a prefix too short to complete any signature — leave the
+ * eliminator unsettled, which reads as `null`.
+ *
+ * The bytes come from `u8List`, so a `Vec` whose length is not a whole number of
+ * bytes has its trailing partial byte zero-padded — the same reading of a ragged
+ * `Vec` the streaming detector already uses.
+ *
+ * @returns the MIME type string for a recognized format, or `null` when the
+ *   leading bytes match no known signature (including any `Vec` shorter than
+ *   the signature it might otherwise match).
+ *
+ * @type {(bytes: Vec) => Nullable<string>}
+ */
+export const detect = bytes => {
+    /** @type {_MagicState} */
+    let magic = magicInit
+    for (const byte of iterable(u8List(msb)(bytes))) {
+        magic = magicStep(magic, byte)
+        if (magic.tag !== 'scan') { break }
+    }
+    return magicMime(magic)
+}
+
+// ── Streaming detector ────────────────────────────────────────────────────────────
+//
+// A byte-accepting state machine that derives the same `{ length, mime_type, type }`
+// metadata as the pure `detect` + UTF-8 path, but **without buffering the blob**.
+// It is the product of three independent folds over the byte stream — length,
+// magic-byte signature elimination, and a UTF-8 validity DFA — read off at
+// end-of-stream by `finish`. This lets `cas_get` inspect arbitrarily large blobs
+// (where a single `Vec` would overflow `maxLength`) in O(1) space, since the bulk
+// of a large blob costs only length counting once the verdict is fixed (see
+// `isSettled`: a magic match settles it immediately, a dead magic once utf8 fails).
+
 /** @type {_Utf8Detect} */
 const utf8Init = { st: null, valid: true, text: true }
 

package/fjs/media/type/proof.f.d.mts

@@ -1,3 +1,9 @@
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { List } from '../../effects/list/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { DetectMeta } from './types.ts'
+ */
 export declare const proof: {
     png: () => void;
     jpeg: () => void;
@@ -7,11 +13,21 @@ export declare const proof: {
     pdf: () => void;
     zip: () => void;
     emptyZip: () => void;
+    spannedZip: () => void;
     webp: () => void;
     riffNotWebp: () => void;
     textIsNull: () => void;
     shortIsNull: () => void;
     emptyIsNull: () => void;
+    truncated: {
+        png: () => void;
+        jpeg: () => void;
+        gif87a: () => void;
+        gif89a: () => void;
+        pdf: () => void;
+        zip: () => void;
+        webp: () => void;
+    };
     stream: {
         text: () => void;
         png: () => void;

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

@@ -1,13 +1,16 @@
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { List } from '../../effects/list/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { DetectMeta } from './types.ts'
+ */
+
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { msb, u8ListToVec, vec8, repeat, empty } from '../../types/bit_vec/module.f.mjs'
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
 import { runPure } from '../../effects/module.f.mjs'
 import { nonEmpty, empty as emptyList } from '../../effects/list/module.f.mjs'
-/** @import { List } from '../../effects/list/types.ts' */
-/** @import { Result } from '../../types/result/types.ts' */
 import { ok } from '../../types/result/module.f.mjs'
 import { detect, detectStream, detectVec } from './module.f.mjs'
-/** @import { DetectMeta } from './types.ts' */
 
 // Builds a big-endian `Vec` from a list of byte values — mirrors how the CAS
 // store would hold the leading bytes of a stored blob.
@@ -61,6 +64,11 @@ export const proof = {
     emptyZip: () =>
         assertEq(detect(bytes(0x50, 0x4b, 0x05, 0x06, 0x00, 0x00)), 'application/zip'),
 
+    // A spanned ZIP archive — the third "PK" variant, so every entry of the
+    // signature list has a case that fails if it is dropped.
+    spannedZip: () =>
+        assertEq(detect(bytes(0x50, 0x4b, 0x07, 0x08, 0x00, 0x00)), 'application/zip'),
+
     webp: () =>
         // "RIFF" + 4-byte size + "WEBP"
         assertEq(
@@ -86,6 +94,38 @@ export const proof = {
     emptyIsNull: () =>
         assertEq(detect(empty), null),
 
+    // Every signature, one byte short of complete. A signature is only ever
+    // recognized on its *last* byte, so each of these must still be null — an
+    // off-by-one in the eliminator's terminal-position test would report the
+    // format here, and would fire the "GIF8"-prefix trap `gif8NotGif` guards.
+    truncated: {
+        png: () =>
+            assertEq(detect(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a)), null),
+
+        jpeg: () =>
+            assertEq(detect(bytes(0xff, 0xd8)), null),
+
+        gif87a: () =>
+            assertEq(detect(bytes(0x47, 0x49, 0x46, 0x38, 0x37)), null),
+
+        gif89a: () =>
+            assertEq(detect(bytes(0x47, 0x49, 0x46, 0x38, 0x39)), null),
+
+        pdf: () =>
+            assertEq(detect(bytes(0x25, 0x50, 0x44, 0x46)), null),
+
+        zip: () =>
+            assertEq(detect(bytes(0x50, 0x4b, 0x03)), null),
+
+        // 11 bytes: "RIFF", the size wildcards, and all but the last byte of
+        // "WEBP" — the wildcard run must not shorten the pattern either.
+        webp: () =>
+            assertEq(
+                detect(bytes(
+                    0x52, 0x49, 0x46, 0x46, 0x1a, 0x00, 0x00, 0x00, 0x57, 0x45, 0x42)),
+                null),
+    },
+
     // ── Streaming detector (detectStream) ───────────────────────────────────────
 
     stream: {

package/fjs/module.d.mts

@@ -1,2 +1,7 @@
 #!/usr/bin/env node
+/**
+ * The `fjs` CLI executable entry point.
+ *
+ * @module
+ */
 export {};

package/fjs/module.f.d.mts

@@ -1,3 +1,11 @@
+/**
+ * FunctionalScript compiler entry points and command handlers.
+ *
+ * @module
+ *
+ * @import { NodeOp, NodeProgram } from './effects/node/types.ts'
+ * @import { Commands } from './cli/types.ts'
+ */
 import type { NodeProgram } from './effects/node/types.ts';
 /** @type {NodeProgram} */
 export declare const main: NodeProgram;

package/fjs/module.f.mjs

@@ -2,15 +2,17 @@
  * FunctionalScript compiler entry points and command handlers.
  *
  * @module
+ *
+ * @import { NodeOp, NodeProgram } from './effects/node/types.ts'
+ * @import { Commands } from './cli/types.ts'
  */
+
 import { compile } from './djs/module.f.mjs'
 import { main as testMain } from './emergent_testing/module.f.mjs'
 import { commands as casCommands } from './cas/cli/module.f.mjs'
 import { main as ciMain } from './ci/module.f.mjs'
 import { import_ } from './effects/node/module.f.mjs'
-/** @import { NodeOp, NodeProgram } from './effects/node/types.ts' */
 import { dispatch } from './cli/module.f.mjs'
-/** @import { Commands } from './cli/types.ts' */
 import { casMcpServer } from './mcp/module.f.mjs'
 import { pure, step } from './effects/module.f.mjs'
 import { unwrap } from './types/result/module.f.mjs'

package/fjs/module.mjs

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
 
+/**
+ * The `fjs` CLI executable entry point.
+ *
+ * @module
+ */
+
 import { main } from './module.f.mjs'
 import { run } from './effects/node/module.mjs'
 

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

@@ -1,3 +1,11 @@
+/**
+ * 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 (`/`).

package/fjs/path/module.f.mjs

@@ -2,9 +2,11 @@
  * 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, 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'
 

package/fjs/proof.f.d.mts

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

package/fjs/proof.f.mjs

@@ -1,8 +1,11 @@
+/**
+ * @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 { 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} */

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

@@ -15,7 +15,7 @@
  * @module
  *
  * @import { Unknown } from '../../media/json/types.ts'
- * @import { Id, RpcError, Handler, Handlers, Response } from './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';

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

@@ -15,9 +15,10 @@
  * @module
  *
  * @import { Unknown } from '../../media/json/types.ts'
- * @import { Id, RpcError, Handler, Handlers, Response } from './types.ts'
+ * @import { Id, RpcError, Handlers, Response } from './types.ts'
  */
 
+import { at } from '../../types/object/module.f.mjs'
 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'
@@ -100,9 +101,11 @@ export const dispatch = handlers => value => {
     if (id === undefined) {
         return null
     }
-    /** @type {Handler | undefined} */
-    const handler = handlers[method]
-    if (handler === undefined) {
+    // `at`, not `handlers[method]`: `method` is untrusted wire data, and a
+    // bracket lookup on a plain object resolves inherited `Object.prototype`
+    // names (`constructor`, `toString`, …) to callables.
+    const handler = at(method)(handlers)
+    if (handler === null) {
         return errorResponseOf(id)(methodNotFound)
     }
     const [t2, result] = handler(params)

package/fjs/protocol/json_rpc/proof.f.d.mts

@@ -1,3 +1,6 @@
+/**
+ * @import { Handlers } from './types.ts'
+ */
 export declare const proof: {
     schema: {
         request: {
@@ -29,6 +32,9 @@ export declare const proof: {
         paramsPassed: () => void;
         handlerError: () => void;
         methodNotFound: () => void;
+        inheritedToString: () => void;
+        inheritedConstructor: () => void;
+        ownPrototypeName: () => void;
         invalidRequest: () => void;
         notification: () => void;
     };

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

@@ -1,4 +1,7 @@
-/** @import { Handlers } from './types.ts' */
+/**
+ * @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'
@@ -25,6 +28,9 @@ const handlers = {
 }
 const d = dispatch(handlers)
 
+/** A handler table that does own the `Object.prototype` name `toString`. */
+const dOwnPrototypeName = dispatch({ toString: () => ok('own') })
+
 export const proof = {
     schema: {
         request: {
@@ -72,6 +78,21 @@ export const proof = {
             const r = d({ jsonrpc: '2.0', method: 'nope', id: 4 })
             assert(r !== null && 'error' in r && r.error.code === -32601)
         },
+        // `method` is untrusted wire data: an inherited `Object.prototype`
+        // name must not resolve to a callable.
+        inheritedToString: () => {
+            const r = d({ jsonrpc: '2.0', method: 'toString', id: 4 })
+            assert(r !== null && 'error' in r && r.error.code === -32601)
+        },
+        inheritedConstructor: () => {
+            const r = d({ jsonrpc: '2.0', method: 'constructor', id: 4 })
+            assert(r !== null && 'error' in r && r.error.code === -32601)
+        },
+        // ... while an *own* property of that name is an ordinary method.
+        ownPrototypeName: () => {
+            const r = dOwnPrototypeName({ jsonrpc: '2.0', method: 'toString', id: 4 })
+            assert(r !== null && 'result' in r && r.result === 'own')
+        },
         invalidRequest: () => {
             const r = d({ jsonrpc: '1.0', method: 'ping', id: 5 })
             assert(r !== null && 'error' in r && r.error.code === -32600 && r.id === null)

package/fjs/protocol/mcp/proof.f.d.mts

@@ -3,6 +3,7 @@
  * @import { Effect, Operation } from '../../effects/types.ts'
  * @import { MemOperationMap } from '../../effects/mock/types.ts'
  * @import { Key, MemOp } from '../../effects/memory/types.ts'
+ * @import { Ts } from '../../types/rtti/ts/types.ts'
  * @import {
  *   ToolsListParams, ToolsListResult, ToolsCallParams, ToolsCallResult,
  *   McpHandlers, McpConfig, McpSessionState,
@@ -50,4 +51,7 @@ export declare const proof: {
         toolsCallWithoutCapabilityReturnsMethodNotFound: () => void;
         unknownMethodReturnsMethodNotFound: () => void;
     };
+    registry: {
+        toolsCallAbsentArgumentsDefaultsToEmptyObject: () => void;
+    };
 };

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

@@ -3,6 +3,7 @@
  * @import { Effect, Operation } from '../../effects/types.ts'
  * @import { MemOperationMap } from '../../effects/mock/types.ts'
  * @import { Key, MemOp } from '../../effects/memory/types.ts'
+ * @import { Ts } from '../../types/rtti/ts/types.ts'
  * @import {
  *   ToolsListParams, ToolsListResult, ToolsCallParams, ToolsCallResult,
  *   McpHandlers, McpConfig, McpSessionState,
@@ -10,12 +11,11 @@
  */
 
 import { assert, assertEq } from '../../asserts/module.f.mjs'
-import { pure, step } from '../../effects/module.f.mjs'
-import { eff } from '../../effects/eff/module.f.mjs'
+import { history, historyStep, mapStep, pure, step, runPure } from '../../effects/module.f.mjs'
 import { run } from '../../effects/mock/module.f.mjs'
 import { asBase, asNominal, create, read } from '../../effects/memory/module.f.mjs'
 import {
-    uninitializedState, mcpStep, notInitialized,
+    uninitializedState, mcpStep, notInitialized, fromRegistry, toolEntry, okResult,
 } from './module.f.mjs'
 
 // ── Memory mock ────────────────────────────────────────────────────────────────
@@ -80,40 +80,44 @@ const runMem = effect =>
 /** @type {<T>(e: Effect<Operation, T>) => Effect<MemOp, T>} */
 const asMemEffect = e => /** @type {Effect<MemOp, any>} */ (/** @type {unknown} */ (e))
 
+// Pairs the last step's response with the session state read back afterwards.
+// The response is still needed after the read, so it is carried forward in a
+// history rather than closed over by a nested continuation.
+/** @type {(key: Key<McpSessionState>) => (e: Effect<Operation, unknown>) => Effect<Operation, _StepResult>} */
+const withState = key => e => {
+    const read0 = historyStep(history(e), () => read(key))
+    return mapStep(read0, ([state, resp]) => /** @type {const} */ ([resp, state]))
+}
+
 // Run one step from uninitializedState, return [response, newState].
 /** @type {(cfg: McpConfig) => (msg: unknown) => _StepResult} */
 const step1 = cfg => msg =>
     runMem(asMemEffect(step(
         create(/** @type {McpSessionState} */ (uninitializedState)),
-        key => step(
-            mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg)),
-            resp => step(
-                read(key),
-                state => pure(/** @type {const} */ ([resp, state])),
-            ),
-        ),
-    )))
+        key => withState(key)(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg))))))
 
 // Run initialize then a second step, return [response, newState] of the second.
 /** @type {(cfg: McpConfig) => (msg1: unknown) => (msg2: unknown) => _StepResult} */
 const step2 = cfg => msg1 => msg2 =>
-    runMem(asMemEffect(eff(create(/** @type {McpSessionState} */ (uninitializedState))).step(key =>
-        eff(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg1))).step(() =>
-            eff(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg2))).step(resp =>
-                step(
-                    read(key),
-                    state => pure(/** @type {const} */ ([resp, state])),
-                )
-            ).value).value).value))
+    runMem(asMemEffect(step(
+        create(/** @type {McpSessionState} */ (uninitializedState)),
+        key => {
+            const r1 = mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg1))
+            const r2 = step(r1, () => mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg2)))
+            return withState(key)(r2)
+        })))
 
 // Run initialize, notifications/initialized, then a third step; return [response, newState] of the third.
 /** @type {(cfg: McpConfig) => (msg1: unknown) => (msg2: unknown) => (msg3: unknown) => _StepResult} */
 const step3 = cfg => msg1 => msg2 => msg3 =>
-    runMem(asMemEffect(eff(create(/** @type {McpSessionState} */ (uninitializedState))).step(key =>
-        eff(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg1))).step(() =>
-            eff(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg2))).step(() =>
-                eff(mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg3))).step(resp =>
-                    eff(read(key)).step(state => pure(/** @type {const} */ ([/** @type {unknown} */ (resp), state]))).value).value).value).value).value))
+    runMem(asMemEffect(step(
+        create(/** @type {McpSessionState} */ (uninitializedState)),
+        key => {
+            const r1 = mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg1))
+            const r2 = step(r1, () => mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg2)))
+            const r3 = step(r2, () => mcpStep(cfg)(handlers)(key)(/** @type {Unknown} */ (msg3)))
+            return withState(key)(r3)
+        })))
 
 // ── Test messages ─────────────────────────────────────────────────────────────
 
@@ -309,4 +313,23 @@ export const proof = {
             assertEq(/** @type {{ error: { code: number } }} */ (resp).error.code, -32601)
         },
     },
+
+    registry: {
+        // `fromRegistry`'s `toolsCall` defaults a missing `arguments` field to
+        // `{}` before dispatching to the matched entry's `handle`. Exercised
+        // here directly (bypassing `mcpStep`) so the default reaches
+        // `toolEntry`'s own validation: if it were left `undefined` instead,
+        // validating it against the empty-object schema below would fail and
+        // this would observe an error result instead of `ok`.
+        toolsCallAbsentArgumentsDefaultsToEmptyObject: () => {
+            const echoArgs = /** @type {const} */ ({})
+            const entry = toolEntry('echo', 'echoes', echoArgs,
+                /** @type {(a: Ts<typeof echoArgs>) => Effect<never, ToolsCallResult>} */
+                (() => pure(okResult('ok'))))
+            const handlers = fromRegistry([entry])
+            const [result] = runPure(handlers.toolsCall({ name: 'echo' }))
+            assert(result !== undefined)
+            assertEq(/** @type {{ readonly text: string }} */ (result.content[0]).text, 'ok')
+        },
+    },
 }