functionalscript 0.33.0 → 0.35.0

package/fs/cas/cli/proof.f.js

@@ -0,0 +1,149 @@
+import { commands } from "./module.f.js";
+import { computeSync, sha256 } from "../../crypto/sha2/module.f.js";
+import { maxLength, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../../effects/node/virtual/module.f.js";
+import {} from "../../effects/node/module.f.js";
+import { dispatch } from "../../cli/module.f.js";
+import { vecToCBase32 } from "../../cbase32/module.f.js";
+import { assert, assertEq } from "../../asserts/module.f.js";
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
+const main = dispatch(commands);
+export const proof = {
+    mainAdd: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: [content] } };
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+        if (finalState.stdout.length === 0) {
+            throw 'expected hash in stdout';
+        }
+    },
+    mainAddGetBig: () => {
+        const chunk = vec(maxLength)(1n);
+        const content = [chunk, chunk];
+        const state = { ...emptyState, root: { myfile: content } };
+        //
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        assertEq(exitCode, 0);
+        const stdout = finalState.stdout;
+        assert(stdout.length !== 0);
+        //
+        const h = computeSync(sha256)(content);
+        const hs = vecToCBase32(h);
+        assertEq(stdout, `${hs}\n`);
+        //
+        const [finalState2, exitCode2] = virtual(finalState)(main(makeOptions(['get', hs, 'myfile2'])));
+        // console.log(finalState2.stderr)
+        assertEq(exitCode2, 0, 'e2');
+        const { myfile2 } = finalState2.root;
+        assert(myfile2 instanceof Array);
+        const h2 = computeSync(sha256)(myfile2);
+        assertEq(h, h2, 'h');
+    },
+    mainAddWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['add'])));
+        assertEq(exitCode, 1);
+        assert(finalState.stderr.length !== 0);
+    },
+    mainGetFound: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: [content] } };
+        const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        if (exitCode1 !== 0) {
+            throw ['expected add exit 0', exitCode1];
+        }
+        const hashStr = state1.stdout.trim();
+        const [, exitCode2] = virtual(state1)(main(makeOptions(['get', hashStr, 'output'])));
+        if (exitCode2 !== 0) {
+            throw ['expected get exit 0', exitCode2];
+        }
+    },
+    mainGetNotFound: () => {
+        // valid cBase32 hash that has not been stored
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: [content] } };
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        const hashStr = state1.stdout.trim();
+        // use an empty store so the hash is not found
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', hashStr, 'output'])));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get'])));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetInvalidHash: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', 'not-a-valid-hash', 'output'])));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainList: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: [content] } };
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
+        const [, exitCode] = virtual(state1)(main(makeOptions(['list'])));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+    },
+    mainListEmptyStore: () => {
+        // A fresh directory has no `.cas` yet; listing must succeed (empty),
+        // not crash unwrapping a readdir ENOENT.
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['list'])));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+        if (finalState.stdout !== '') {
+            throw ['expected empty stdout', finalState.stdout];
+        }
+    },
+    mainListCorruptStore: () => {
+        // `.cas` exists but is a file, not a directory: a real storage error
+        // that must surface, not be masked as an empty list.
+        const state = { ...emptyState, root: { '.cas': [vec8(0x2an)] } };
+        let threw = false;
+        try {
+            virtual(state)(main(makeOptions(['list'])));
+        }
+        catch {
+            threw = true;
+        }
+        if (!threw) {
+            throw 'expected list to surface the storage error';
+        }
+    },
+    mainNoCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions([])));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainUnknownCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['bogus'])));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+};

package/fs/cas/mcp/module.f.d.ts

@@ -1,13 +1,12 @@
-import { type Effect, type Operation } from '../../effects/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
 import { type MemOp } from '../../effects/memory/module.f.ts';
-import { type Vec } from '../../types/bit_vec/module.f.ts';
-import { type Mkdir, type RandomInt, type Read, type ReadBytes, type Rename, type Write } from '../../effects/node/module.f.ts';
+import { type Read, type Rm, type Write } from '../../effects/node/module.f.ts';
 import { type McpConfig, type McpHandlers } from '../../mcp/module.f.ts';
-import { type Cas } from '../module.f.ts';
+import { type FileCasOperation } from '../module.f.ts';
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
 export declare const casAddArgs: {
     readonly content: import("../../types/rtti/module.f.ts").String;
-    readonly type: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Or<[import("../../types/rtti/module.f.ts").Or<["text", "base64"]>, "url"]>, undefined]>;
+    readonly type: import("../../types/rtti/module.f.ts").Or<["text", "base64", "url", undefined]>;
 };
 /** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
 export declare const casGetArgs: {
@@ -17,24 +16,17 @@ export declare const casGetArgs: {
 /** Arguments for `cas_list`: none. */
 export declare const casListArgs: {};
 /**
- * MCP handlers for an injected `Cas<O>` — generic in `O` exactly like `Cas`
- * itself, so the same handlers run over `Fs` (production) or memory (tests).
- *
- * When `toUrl` is provided, `cas_get` includes the `url` field pointing to
- * the blob on the local filesystem. When absent (e.g. memory-backed tests),
- * `url` is omitted.
+ * MCP handlers for `FileCas`.
  */
-export declare const casMcpHandlers: <O extends Operation>(c: Cas<O>, home: string, toUrl?: (hash: Vec) => string) => McpHandlers<Mkdir | Rename | RandomInt | ReadBytes | O>;
+export declare const casMcpHandlers: (home: string) => McpHandlers<FileCasOperation | Rm>;
 /**
  * Static MCP configuration for the CAS server: advertises the `tools`
  * capability, identifies the server, and pins the protocol version.
  */
 export declare const casConfig: McpConfig;
 /**
- * Runs the CAS MCP server over stdio: allocates the session-state slot, builds
+ * Runs the file CAS MCP server over stdio: allocates the session-state slot, builds
  * the `mcpStep` for `c`, and drives the read → parse → dispatch → write loop
- * until stdin EOF. Generic in `O` so it composes with any `Cas<O>` backing.
- *
- * When `toUrl` is provided, `cas_get` includes the blob's filesystem URL.
+ * until stdin EOF.
  */
-export declare const casMcpServer: <O extends Operation>(c: Cas<O>, home: string, toUrl?: (hash: Vec) => string) => Effect<Read | Write | MemOp | Mkdir | Rename | RandomInt | ReadBytes | O, void>;
+export declare const casMcpServer: (home: string) => Effect<Read | Write | MemOp | FileCasOperation | Rm, void>;

package/fs/cas/mcp/module.f.js

@@ -30,18 +30,31 @@
  * ## `cas_get` output
  *
  * Always returns a JSON object `{ length, mime_type, type[, url][, content] }`.
- * `type` is always present (`'text'` or `'base64'`). When `content: true` is
- * requested, the inline payload is also included. Two-phase MIME detection
- * determines the encoding:
- *
- * 1. **Magic-byte sniffing** (`fs/mime` `detect`): PNG/JPEG/GIF/WebP/PDF/ZIP →
- *    `type: 'base64'` with the detected `mime_type`.
- * 2. **UTF-8 validation** (`fs/text/utf8` `fromVec`): valid UTF-8 →
- *    `type: 'text'`, `mime_type: 'text/plain'`.
- * 3. **Fallback**: `type: 'base64'`, `mime_type: 'application/octet-stream'`.
- *
- * When `content: false` (default), only `{ length, mime_type, type[, url] }` is
- * returned — no content transfer.
+ * `type` is always present (`'text'` or `'base64'`). A single classifier — the
+ * `fs/mime` detector state machine (length × magic-byte eliminator × UTF-8 DFA) —
+ * produces the same three-way verdict on both paths, so there is no second,
+ * divergent copy of the rules:
+ *
+ * 1. **Magic-byte hit** (PNG/JPEG/GIF/WebP/PDF/ZIP) → `type: 'base64'` with the
+ *    detected `mime_type`.
+ * 2. **Whole-blob-valid UTF-8** → `type: 'text'`, `mime_type: 'text/plain'`.
+ * 3. **Fallback** → `type: 'base64'`, `mime_type: 'application/octet-stream'`.
+ *
+ * **Metadata-only (`content: false`, the default) is size-independent.** It folds
+ * the read stream through `fs/mime` `detectStream` and never buffers the blob.
+ * Because a single `Vec` caps at `maxLength` bits (128 KiB), the old
+ * drain-into-one-`Vec` approach failed on any blob larger than one chunk even when
+ * only metadata was asked for; streaming detection returns correct
+ * `{ length, mime_type, type[, url] }` regardless of size.
+ *
+ * **`content: true`** first derives `{ length, mime_type, type }` with the same
+ * size-independent `fs/mime` `detectStream` machine, then materializes the bytes
+ * (via `collectRead`, bounded by `maxLength`) and encodes the inline payload by
+ * `type` — a `fs/text/utf8` `fromVec` string for `text`, base64 for `base64`. A
+ * blob larger than `maxLength` (128 KiB) cannot be buffered into one `Vec`, so it
+ * is rejected here with a descriptive *"too large"* error (carrying the byte size
+ * and `url`) rather than being misreported as absent; it should be fetched via
+ * `url` or inspected with metadata-only `cas_get`.
  *
  * ## Encoding split: hashes vs. content
  *
@@ -59,118 +72,139 @@
  * - `type: 'base64'` with malformed content (base64 `decode` → `null`) → `isError`
  * - malformed `hash` (`cBase32ToVec` → `null`) → `isError`
  * - `cas_get` on an absent hash (`c.read` → `undefined`) → `isError`
+ * - `cas_get` with `content: true` on a blob larger than `maxLength` → `isError`
+ *   (distinct "too large" message, not "no such hash")
  * - unknown tool `name` → `isError`
  *
  * @module
  */
 import { string, option, or, boolean } from "../../types/rtti/module.f.js";
+import { stringify } from "../../json/module.f.js";
 import { pure } from "../../effects/module.f.js";
 import { create } from "../../effects/memory/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../../cbase32/module.f.js";
 import { decode as base64Decode, encode as base64Encode } from "../../base64/module.f.js";
-import { utf8 } from "../../text/module.f.js";
-import { detect } from "../../mime/module.f.js";
-import { length as bitVecLength } from "../../types/bit_vec/module.f.js";
-import {} from "../../effects/node/module.f.js";
+import { tryUtf8 } from "../../text/module.f.js";
+import { detectStream } from "../../mime/module.f.js";
+import { empty, length as bitVecLength, maxLength, maxLengthBytes, msb } from "../../types/bit_vec/module.f.js";
+import { ok, error } from "../../types/result/module.f.js";
+import { rm } from "../../effects/node/module.f.js";
 import { stdioTransport } from "../../mcp/stdio/module.f.js";
 import { mcpStep, uninitializedState, toolEntry, fromRegistry, errorResult, } from "../../mcp/module.f.js";
-import { casUpload } from "../module.f.js";
+import { casAddFile, fileCas } from "../module.f.js";
 import { fromVec } from "../../text/utf8/module.f.js";
+import { identity } from "../../types/function/module.f.js";
+import { sha256 } from "../../crypto/sha2/module.f.js";
+import { nonEmpty, empty as elEmpty } from "../../effects/list/module.f.js";
 // ── Argument schemas (declared once, used for both inputSchema and validate) ─────
 /** Arguments for `cas_add`: content to store, with optional encoding type. */
-export const casAddArgs = { content: string, type: option(or(or('text', 'base64'), 'url')) };
+export const casAddArgs = {
+    content: string,
+    type: or('text', 'base64', 'url', undefined)
+};
 /** Arguments for `cas_get`: the cBase32 hash to look up; optionally request inline content. */
-export const casGetArgs = { hash: string, content: option(boolean) };
+export const casGetArgs = {
+    hash: string,
+    content: option(boolean)
+};
 /** Arguments for `cas_list`: none. */
 export const casListArgs = {};
+// ── Stream helper ────────────────────────────────────────────────────────────────
+/**
+ * Drains a CAS read stream into a single `Vec`. Used only on the `content: true`
+ * path, where the whole blob is needed for inline base64 / UTF-8 transfer; the
+ * chunk stream is concatenated and an error item is surfaced as the result.
+ * Metadata-only `cas_get` avoids this entirely via `fs/mime` `detectStream`,
+ * which is why it is not bound by the `maxLength` ceiling below.
+ */
+const collectRead = (stream) => {
+    const loop = (acc) => (s) => s.step((node) => {
+        if (node === undefined) {
+            return pure(ok(acc));
+        }
+        const { first, tail } = node;
+        const [t, v] = first;
+        if (t === 'error') {
+            return pure(first);
+        }
+        // A single `Vec` cannot exceed `maxLength` bits; concatenating past it would
+        // overflow the runtime's `bigint` constraint. Surface that as an error item
+        // so the tool reports a failure rather than crashing the process.
+        if (bitVecLength(acc) + bitVecLength(v) > maxLength) {
+            return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`));
+        }
+        return loop(msb.concat(acc)(v))(tail);
+    });
+    return loop(empty)(stream);
+};
 // ── Tool registry ──────────────────────────────────────────────────────────────
+const toJson = stringify(identity);
 /** Registry of all CAS tools. */
-const casToolRegistry = (c, home, toUrl) => {
+const casToolRegistry = (home) => {
+    const c = fileCas(sha256)(home);
     const casUploadDir = `${home}/cas_upload`;
     return [
-        toolEntry('cas_add', 'Store content and return its hash (cBase32). Pass type:"base64" for binary; type:"url" to stream a file from $HOME/cas_upload/ (no size limit); omit or pass type:"text" for UTF-8 text (default).', casAddArgs, ({ type, content }) => {
-            // type:'url' — streaming move-hash-move pipeline (no size limit)
+        toolEntry('cas_add', 'Store content and return its hash (cBase32). Pass type:"base64" for binary; omit or pass type:"text" for UTF-8 text (default). Inline content (text/base64) is capped at 128 KiB (131072 bytes) — larger content is rejected. For larger content use type:"url" to stream a file from $HOME/cas_upload/ (no size limit).', casAddArgs, ({ type, content }) => {
+            // type:'url' — stream the file into cas, then delete the source on success
             if (type === 'url') {
                 if (!content.startsWith(`${casUploadDir}/`) || content.includes('..')) {
                     return pure(errorResult(`cas_add type:url paths must be within ${casUploadDir}/ — got: ${content}`));
                 }
-                const fileName = content.slice(`${casUploadDir}/`.length);
-                return casUpload(home)(fileName).step(result => pure(result[0] === 'error'
-                    ? errorResult(`upload failed: ${result[1]}`)
-                    : okResult(vecToCBase32(result[1]))));
+                return casAddFile(c)(content).step(([t, v]) => t === 'error'
+                    ? pure(errorResult(`upload failed: ${v}`))
+                    : rm(content).step(() => pure(okResult(vecToCBase32(v)))));
             }
             // type:'text' or 'base64' — resolve content to Vec, store via c.write()
-            let x;
-            switch (type) {
-                case 'base64':
-                    const value = base64Decode(content);
-                    x = pure(value === null ? `invalid base64 content: ${content}` : value);
-                    break;
-                default:
-                    x = pure(utf8(content));
-                    break;
-            }
-            return x.step(value => typeof value === 'string'
-                ? pure(errorResult(value))
-                : c.write(value).step(hash => pure(hash === undefined
+            let x = type === 'base64'
+                ? base64Decode(content)
+                : tryUtf8(content);
+            return x === null
+                ? pure(errorResult('too large or malformed — use type:"url" for large content'))
+                // The resolved content fits in one chunk; feed it as a single-item stream.
+                : c.write(nonEmpty(ok(x), elEmpty())).step(([tag, hash]) => pure(tag === 'error'
                     ? errorResult('write')
-                    : okResult(vecToCBase32(hash)))));
+                    : okResult(vecToCBase32(hash))));
         }),
-        toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mime_type,type[,url]} where type is "text" or "base64". Pass content:true to also include the inline content string.', casGetArgs, r => {
+        toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mime_type,type[,url]} where type is "text" or "base64". Pass content:true to also include the inline content string, but content is capped at 128 KiB (131072 bytes) — a larger blob is rejected with an error. To download a blob, prefer the url field returned in the result instead of requesting inline content.', casGetArgs, r => {
             const key = cBase32ToVec(r.hash);
             if (key === null) {
                 return pure(errorResult(`invalid cBase32 hash: ${r.hash}`));
             }
-            return c.read(key).step(value => {
-                if (value === undefined) {
+            const url = c.url(key);
+            return detectStream(c.read(key)).step(([tag, detected]) => {
+                if (tag === 'error') {
                     return pure(errorResult(`no such hash: ${r.hash}`));
                 }
-                const byteLength = Number(bitVecLength(value) / 8n);
-                // Phase 1: magic-byte sniffing for known binary formats.
-                const detectedMime = detect(value);
-                if (detectedMime !== null) {
-                    const url = toUrl?.(key);
-                    const meta = {
-                        length: byteLength,
-                        mime_type: detectedMime,
-                        type: 'base64',
-                        ...(url !== undefined && { url })
-                    };
-                    if (r.content === true) {
-                        const blob = base64Encode(value);
-                        return pure(blob === null
-                            ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                            : okResult(JSON.stringify({ ...meta, content: blob })));
-                    }
-                    return pure(okResult(JSON.stringify(meta)));
+                const { length, mime_type, type } = detected;
+                const meta = { length: Number(length), mime_type, type, url };
+                if (r.content !== true) {
+                    // content:true path continues below; this is just the metadata step.
+                    return pure(okResult(toJson(meta)));
                 }
-                // Phase 2: UTF-8 validation — text if valid, octet-stream otherwise.
-                const str = fromVec(value);
-                const url = toUrl?.(key);
-                if (str !== null) {
-                    const meta = {
-                        length: byteLength,
-                        mime_type: 'text/plain',
-                        type: 'text',
-                        ...(url !== undefined && { url })
-                    };
-                    return pure(r.content === true
-                        ? okResult(JSON.stringify({ ...meta, content: str }))
-                        : okResult(JSON.stringify(meta)));
+                // A single `Vec` caps at `maxLength` bits (`maxLengthBytes` bytes), so
+                // a larger blob cannot be buffered for inline transfer. Report the
+                // size and point at the size-independent alternatives instead of
+                // misreporting an existing blob as `no such hash`.
+                if (length > maxLengthBytes) {
+                    return pure(errorResult(`blob too large to fetch inline (${length} bytes, limit ${maxLengthBytes} bytes); use the url field (${url}) or omit content for metadata`));
                 }
-                const meta = {
-                    length: byteLength,
-                    mime_type: 'application/octet-stream',
-                    type: 'base64',
-                    ...(url !== undefined && { url })
-                };
-                if (r.content === true) {
+                return collectRead(c.read(key)).step(([collectTag, value]) => {
+                    if (collectTag === 'error') {
+                        return pure(errorResult(`no such hash: ${r.hash}`));
+                    }
+                    if (type === 'text') {
+                        // `type: 'text'` means the detector validated `value` as UTF-8,
+                        // so `fromVec` is non-null here; guard defensively regardless.
+                        const str = fromVec(value);
+                        return pure(str === null
+                            ? errorResult(`content is not byte-aligned: ${r.hash}`)
+                            : okResult(toJson({ ...meta, content: str })));
+                    }
                     const blob = base64Encode(value);
                     return pure(blob === null
                         ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                        : okResult(JSON.stringify({ ...meta, content: blob })));
-                }
-                return pure(okResult(JSON.stringify(meta)));
+                        : okResult(toJson({ ...meta, content: blob })));
+                });
             });
         }),
         toolEntry('cas_list', 'List all stored content hashes (cBase32), one per line.', casListArgs, () => c.list().step(hashes => pure(okResult(hashes.map(vecToCBase32).join('\n'))))),
@@ -181,14 +215,9 @@ const casToolRegistry = (c, home, toUrl) => {
 const okResult = (text) => ({ content: [{ type: 'text', text }] });
 // ── Handlers ────────────────────────────────────────────────────────────────────
 /**
- * MCP handlers for an injected `Cas<O>` — generic in `O` exactly like `Cas`
- * itself, so the same handlers run over `Fs` (production) or memory (tests).
- *
- * When `toUrl` is provided, `cas_get` includes the `url` field pointing to
- * the blob on the local filesystem. When absent (e.g. memory-backed tests),
- * `url` is omitted.
+ * MCP handlers for `FileCas`.
  */
-export const casMcpHandlers = (c, home, toUrl) => fromRegistry(casToolRegistry(c, home, toUrl));
+export const casMcpHandlers = (home) => fromRegistry(casToolRegistry(home));
 // ── Session configuration ───────────────────────────────────────────────────────
 /**
  * Static MCP configuration for the CAS server: advertises the `tools`
@@ -201,10 +230,8 @@ export const casConfig = {
 };
 // ── Server ──────────────────────────────────────────────────────────────────────
 /**
- * Runs the CAS MCP server over stdio: allocates the session-state slot, builds
+ * Runs the file CAS MCP server over stdio: allocates the session-state slot, builds
  * the `mcpStep` for `c`, and drives the read → parse → dispatch → write loop
- * until stdin EOF. Generic in `O` so it composes with any `Cas<O>` backing.
- *
- * When `toUrl` is provided, `cas_get` includes the blob's filesystem URL.
+ * until stdin EOF.
  */
-export const casMcpServer = (c, home, toUrl) => create(uninitializedState).step(key => stdioTransport(mcpStep(casConfig)(casMcpHandlers(c, home, toUrl))(key)));
+export const casMcpServer = (home) => create(uninitializedState).step(key => stdioTransport(mcpStep(casConfig)(casMcpHandlers(home))(key)));

package/fs/cas/mcp/proof.f.d.ts

@@ -1,4 +1,10 @@
 export declare const proof: {
+    getMetaLargeMultiChunkBlobNoError: () => void;
+    getMetaLargeMultiChunkUtf8Symbols: () => void;
+    getMetaLargeMultiChunkTextThenBinary: () => void;
+    getContentLargeBlobTooLargeError: () => void;
+    getContentMissingHashIsError: () => void;
+    getContentDoubleEscapedOverflowWritesInternalError: () => void;
     toolsListAdvertisesThreeTools: () => void;
     addReturnsHash: () => void;
     textAddGetMetaRoundTrips: () => void;
@@ -11,6 +17,10 @@ export declare const proof: {
     listEnumeratesStoredHashes: () => void;
     addInvalidContentIsError: () => void;
     addBadLengthContentIsError: () => void;
+    addBase64OverLimitIsError: () => void;
+    addTextOverLimitIsError: () => void;
+    addTextAtLimitSucceeds: () => void;
+    addBase64AtLimitIsError: () => void;
     getUnterminatedHashIsError: () => void;
     addMissingContentIsError: () => void;
     getMissingHashArgumentIsError: () => void;
@@ -24,11 +34,12 @@ export declare const proof: {
     getMetaReturnsLengthAndMimeType: () => void;
     getMetaBinaryBlob: () => void;
     getMetaOctetStreamForUnknownBinary: () => void;
-    getMetaNoUrlWhenToUrlAbsent: () => void;
+    getMetaOctetStreamForNulBlob: () => void;
     getMetaMissingHashIsError: () => void;
     getMetaInvalidHashIsError: () => void;
     addUrlFromSubdirectorySucceeds: () => void;
     addUrlFromApprovedDirectorySucceeds: () => void;
     addUrlFromRandomDirectoryIsRejected: () => void;
     addUrlWithPathTraversalIsRejected: () => void;
+    getOctetStreamWithContentIncludesBase64: () => void;
 };