functionalscript 0.36.0 → 0.37.0

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

@@ -12,7 +12,7 @@
  * | Tool       | args                          | action           | result                              |
  * |------------|-------------------------------|------------------|-------------------------------------|
  * | `cas_add`  | `{ content, type? }`          | `c.write(...)`   | hash (cBase32)                      |
- * | `cas_get`  | `{ hash, content?: boolean }` | `c.read(key)`    | JSON `{length,mime_type,type[,content]}` |
+ * | `cas_get`  | `{ hash, content?: boolean }` | `c.read(key)`    | JSON `{length,mimeType,type[,uri][,text\|blob]}` |
  * | `cas_list` | `{}`                          | `c.list()`       | hashes, one per line                |
  *
  * ## `cas_add` input encoding
@@ -31,37 +31,56 @@
  *
  * ## `cas_get` output
  *
- * Always returns a JSON object `{ length, mime_type, type[, url][, content] }`.
- * `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:
+ * Always returns a JSON object `{ length, mimeType, type[, uri][, text | blob] }`.
+ * These field names mirror the MCP resource-contents shape (`resources/read`
+ * results), so the tool view and the future resource view of a blob use the same
+ * vocabulary: `mimeType` (not `mime_type`), `uri` (not `url`) — the resource URI
+ * under which the same blob will be readable via `resources/read` — and `text` /
+ * `blob` (not a `type`-tagged `content`) for inline payloads. `type` is always
+ * present (`'text'` or `'base64'`) as the discriminator for which of `text` /
+ * `blob` a later `content: true` fetch would populate — MCP allows extra fields,
+ * so `type` and `length` simply stay alongside the required resource-contents
+ * fields. A single classifier — the `fs/media/type` 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`.
+ *    detected `mimeType`.
+ * 2. **Whole-blob-valid UTF-8** → `type: 'text'`, `mimeType: 'text/plain'`.
+ * 3. **Fallback** → `type: 'base64'`, `mimeType: 'application/octet-stream'`.
+ *
+ * **Metadata-only (`content: false`, the default) is size-independent for
+ * non-text and oversized blobs.** It folds the read stream through
+ * `fs/media/type` `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, mimeType, type[, uri] }` regardless of size. A dialect (e.g.
+ * `vnd.fjs.revision`, see `fs/media/module.f.ts`) can only be recognized by
+ * parsing the whole blob as JSON, so when the streaming verdict is
+ * whole-blob-valid text within the same bounded inline cap as `content: true`
+ * (`maxLengthBytes`), one extra bounded read materializes the blob purely to
+ * refine `mimeType` through the dialect-aware detector; a larger or non-text
+ * blob is never a dialect match and is returned from the streaming verdict
+ * alone, unbuffered.
+ *
+ * **`content: true`** first derives `{ length, mimeType, type }` with the same
+ * size-independent `fs/media/type` `detectStream` machine (to decide whether the
+ * blob even fits inline), then materializes the bytes (via `collectRead`, bounded
+ * by `maxLength`) and re-derives the verdict from the dialect-aware detector
+ * (`fs/media/module.f.ts` `detect`) — now that the whole blob is in hand, a
+ * dialect match is reflected in the result — before encoding the inline payload
+ * by `type` — a `fs/text/utf8` `fromVec` string on `text` (for `type: 'text'`),
+ * base64 on `blob` (for `type: '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 `uri`) rather than
+ * being misreported as absent; it should be fetched via `uri` or inspected with
+ * metadata-only `cas_get`.
  *
  * ## Encoding split: hashes vs. content
  *
  * `Cas<O>` deals in `Vec` (bit vectors); MCP models only `textContent` today.
- * **Hashes** travel as cBase32 (`fs/cbase32`) — the canonical CAS hash format,
+ * **Hashes** travel as cBase32 (`fs/basen/cbase32`) — the canonical CAS hash format,
  * shared with the CLI and the on-disk store layout. **Content** encoding is
  * determined at read time as described above.
  *
@@ -80,24 +99,25 @@
  *
  * @module
  */
-import { string, option, or, boolean } from "../../types/rtti/module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { pure, decode } 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 { tryUtf8 } from "../../text/module.f.js";
-import { detectStream } from "../../mime/module.f.js";
-import { empty, length as bitVecLength, maxLength, maxLengthBytes, msb, vec } from "../../types/bit_vec/module.f.js";
-import { ok, error } from "../../types/result/module.f.js";
-import {} 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 { 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";
+import { string, option, or, boolean } from '../../types/rtti/module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { pure, decode } from '../../effects/module.f.js';
+import { create } from '../../effects/memory/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.js';
+import { decode as base64Decode, encode as base64Encode } from '../../basen/base64/module.f.js';
+import { tryUtf8 } from '../../text/module.f.js';
+import { detectStream } from '../../media/type/module.f.js';
+import { detect as detectDialect } from '../../media/module.f.js';
+import { empty, length as bitVecLength, maxLength, maxLengthBytes, msb, vec } from '../../types/bit_vec/module.f.js';
+import { ok, error } from '../../types/result/module.f.js';
+import {} 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 { 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 = {
@@ -116,7 +136,7 @@ export const casListArgs = {};
  * 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`,
+ * Metadata-only `cas_get` avoids this entirely via `fs/media/type` `detectStream`,
  * which is why it is not bound by the `maxLength` ceiling below.
  */
 const collectRead = (stream) => {
@@ -157,45 +177,65 @@ const casToolRegistry = (home) => {
                     ? errorResult('write')
                     : 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, 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 => {
+        toolEntry('cas_get', 'Inspect a blob by hash. Always returns JSON {length,mimeType,type[,uri]} where type is "text" or "base64". Pass content:true to also include the inline payload as text (type:"text") or blob (type:"base64"), but content is capped at 128 KiB (131072 bytes) — a larger blob is rejected with an error. To download a blob, prefer the uri 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}`));
             }
-            const url = c.url(key);
+            const uri = c.url(key);
             return detectStream(c.read(key)).step(([tag, detected]) => {
                 if (tag === 'error') {
                     return pure(errorResult(`no such hash: ${r.hash}`));
                 }
-                const { length, mime_type, type } = detected;
-                const meta = { length: Number(length), mime_type, type, url };
+                const { length, mime_type: mimeType, type } = detected;
+                const meta = { length: Number(length), mimeType, type, uri };
                 if (r.content !== true) {
-                    // content:true path continues below; this is just the metadata step.
-                    return pure(okResult(toJson(meta)));
+                    // A dialect match can only be decided from the whole parsed blob;
+                    // only attempt the extra bounded read when it stands a chance
+                    // (whole-blob text within the same cap `content: true` allows).
+                    if (type !== 'text' || length > maxLengthBytes) {
+                        return pure(okResult(toJson(meta)));
+                    }
+                    return collectRead(c.read(key)).step(([collectTag, value]) => {
+                        // Already known to fit from the streaming pass above, so an
+                        // error here means the hash vanished between reads; fall back
+                        // to the streaming verdict rather than fail the whole request.
+                        if (collectTag === 'error') {
+                            return pure(okResult(toJson(meta)));
+                        }
+                        const refined = detectDialect(value);
+                        return pure(okResult(toJson({ ...meta, mimeType: refined.mime_type })));
+                    });
                 }
                 // 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`));
+                    return pure(errorResult(`blob too large to fetch inline (${length} bytes, limit ${maxLengthBytes} bytes); use the uri field (${uri}) or omit content for metadata`));
                 }
                 return collectRead(c.read(key)).step(([collectTag, value]) => {
                     if (collectTag === 'error') {
                         return pure(errorResult(`no such hash: ${r.hash}`));
                     }
-                    if (type === 'text') {
+                    // Re-derive the verdict from the now-materialized blob so a
+                    // dialect match — only decidable with the whole parsed JSON in
+                    // hand — is reflected in the inline result too, not just the
+                    // streaming guess.
+                    const refined = detectDialect(value);
+                    const refinedMeta = { length: Number(refined.length), mimeType: refined.mime_type, type: refined.type, uri };
+                    if (refined.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 })));
+                            : okResult(toJson({ ...refinedMeta, text: str })));
                     }
                     const blob = base64Encode(value);
                     return pure(blob === null
                         ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                        : okResult(toJson({ ...meta, content: blob })));
+                        : okResult(toJson({ ...refinedMeta, blob })));
                 });
             });
         }),

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

@@ -16,13 +16,15 @@ export declare const proof: {
     addGetRoundTrips: () => void;
     getUntypedReturnsText: () => void;
     getTypedReturnsBinaryJson: () => void;
+    getMetaRecognizesRevisionDialect: () => void;
+    getContentRecognizesRevisionDialect: () => void;
     listEnumeratesStoredHashes: () => void;
     addInvalidContentIsError: () => void;
     addBadLengthContentIsError: () => void;
     addBase64OverLimitIsError: () => void;
     addTextOverLimitIsError: () => void;
     addTextAtLimitSucceeds: () => void;
-    addBase64AtLimitIsError: () => void;
+    addBase64AtLimitSucceeds: () => void;
     getUnterminatedHashIsError: () => void;
     addMissingContentIsError: () => void;
     getMissingHashArgumentIsError: () => void;

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

@@ -1,20 +1,21 @@
-import { assert, assertEq } from "../../asserts/module.f.js";
-import { pure } from "../../effects/module.f.js";
-import { run } from "../../effects/mock/module.f.js";
-import { asBase, asNominal, create } from "../../effects/memory/module.f.js";
-import { msb, u8ListToVec, vec8, repeat, length, maxLengthBytes } from "../../types/bit_vec/module.f.js";
-import { vecToCBase32 } from "../../cbase32/module.f.js";
-import { encode as base64Encode } from "../../base64/module.f.js";
-import { utf8 } from "../../text/module.f.js";
-import { fileCas } from "../module.f.js";
-import { sha256 } from "../../crypto/sha2/module.f.js";
-import { nonEmpty, empty as elEmpty } from "../../effects/list/module.f.js";
-import { mcpStep, uninitializedState, } from "../../mcp/module.f.js";
-import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
-import { casConfig, casMcpHandlers } from "./module.f.js";
-import { ok as resultOk } from "../../types/result/module.f.js";
-import { stdioTransport } from "../../mcp/stdio/module.f.js";
-import { fromVec } from "../../types/uint8array/module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { pure } from '../../effects/module.f.js';
+import { run } from '../../effects/mock/module.f.js';
+import { asBase, asNominal, create } from '../../effects/memory/module.f.js';
+import { msb, u8ListToVec, vec8, repeat, length, maxLengthBytes } from '../../types/bit_vec/module.f.js';
+import { vecToCBase32 } from '../../basen/cbase32/module.f.js';
+import { encode as base64Encode } from '../../basen/base64/module.f.js';
+import { utf8 } from '../../text/module.f.js';
+import { fileCas } from '../module.f.js';
+import { dialect as revisionDialect, mediaType as revisionMediaType } from '../../media/revision/module.f.js';
+import { sha256 } from '../../crypto/sha2/module.f.js';
+import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.js';
+import { mcpStep, uninitializedState, } from '../../mcp/module.f.js';
+import { emptyState, virtual } from '../../effects/node/virtual/module.f.js';
+import { casConfig, casMcpHandlers } from './module.f.js';
+import { ok as resultOk } from '../../types/result/module.f.js';
+import { stdioTransport } from '../../mcp/stdio/module.f.js';
+import { fromVec } from '../../types/uint8array/module.f.js';
 const initialTestState = { memory: { next: 0, values: {} } };
 const mock = {
     memCreate: value => state => {
@@ -104,10 +105,13 @@ const item0 = (resp) => resultOf(resp).content[0];
 const textOf = (resp) => item0(resp).text;
 // A plain text sample for text add→get round-trips.
 const textSample = 'hello, world!';
+// A valid `vnd.fjs.revision` blob: zero parents, so `subject` must be (and is,
+// per `fs/media/revision/proof.f.ts`) a valid cbase32 hash on its own.
+const revisionSample = `{"dialect":"${revisionDialect}","subject":"8","parents":[]}`;
 // A base64-encoded binary payload for binary add→get round-trips.
 const binarySample = base64Encode(vec8(0x2an));
 // A base64 blob whose leading bytes are the PNG magic-byte signature, so
-// `cas_get` detects its type and returns base64 with mime_type image/png.
+// `cas_get` detects its type and returns base64 with mimeType image/png.
 const pngSample = base64Encode(u8ListToVec(msb)([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x01]));
 // Returns the RFC 4648 base64 encoding of `n` zero bytes, computed directly
 // without bigint arithmetic — independent of `base64.encode` so these tests
@@ -141,9 +145,10 @@ const largeMultiChunkBlobMeta = (chunk0, chunk1, expectedType, expectedMime) =>
     assert(!resultOf(metaResp).isError);
     const meta = JSON.parse(textOf(metaResp));
     assertEq(meta.type, expectedType);
-    assertEq(meta.mime_type, expectedMime);
+    assertEq(meta.mimeType, expectedMime);
     assertEq(meta.length, Number((length(chunk0) + length(chunk1)) / 8n));
-    assertEq(meta.content, undefined);
+    assertEq(meta.text, undefined);
+    assertEq(meta.blob, undefined);
 };
 // A full `maxLengthBytes`-long chunk of repeated ASCII 'a' — valid UTF-8.
 const asciiChunk = repeat(maxLengthBytes)(vec8(0x61n));
@@ -207,7 +212,7 @@ export const proof = {
     // This test originally timed out under `bun test`'s native 5s per-test
     // limit (12-14s observed in CI on PR #1201) — the cost was in
     // `base64Encode`, quadratic before the `baseN.vecToString` fix (see
-    // `fs/base64/proof.f.ts` `encodeLargeVecIsSlow`). Now well under budget on
+    // `fs/basen/base64/proof.f.ts` `encodeLargeVecIsSlow`). Now well under budget on
     // both engines.
     getContentBase64InflationOverflowWritesInternalError: () => {
         const [root, hash] = seedBlob({})([oversizedBase64Chunk]);
@@ -271,10 +276,10 @@ export const proof = {
         const [, getResp] = session(call(2, 'cas_add', { content: textSample }), call(3, 'cas_get', { hash }));
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
-        assertEq(result.mime_type, 'text/plain');
+        assertEq(result.mimeType, 'text/plain');
         assertEq(result.type, 'text');
         assertEq(result.length, textSample.length);
-        assertEq(result.content, undefined);
+        assertEq(result.text, undefined);
     },
     // cas_get with content:true returns inline content.
     textAddGetContentRoundTrips: () => {
@@ -284,8 +289,8 @@ export const proof = {
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
         assertEq(result.type, 'text');
-        assertEq(result.mime_type, 'text/plain');
-        assertEq(result.content, textSample);
+        assertEq(result.mimeType, 'text/plain');
+        assertEq(result.text, textSample);
     },
     // Binary add→get round-trip: store as base64, retrieve metadata without content.
     binaryAddGetMetaRoundTrips: () => {
@@ -294,9 +299,9 @@ export const proof = {
         const [, getResp] = session(call(2, 'cas_add', { content: binarySample, type: 'base64' }), call(3, 'cas_get', { hash }));
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
-        assertEq(result.content, undefined);
+        assertEq(result.text, undefined);
         assertEq(result.type, 'text');
-        assertEq(result.mime_type, 'text/plain');
+        assertEq(result.mimeType, 'text/plain');
     },
     // Binary add→get with content:true returns inline base64 content.
     binaryAddGetContentRoundTrips: () => {
@@ -306,7 +311,7 @@ export const proof = {
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
         assertEq(result.type, 'text');
-        assertEq(result.content, '*');
+        assertEq(result.text, '*');
     },
     addGetRoundTrips: () => {
         const [addResp] = session(call(2, 'cas_add', { content: textSample }));
@@ -314,7 +319,7 @@ export const proof = {
         const [, getResp] = session(call(2, 'cas_add', { content: textSample }), call(3, 'cas_get', { hash, content: true }));
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
-        assertEq(result.content, textSample);
+        assertEq(result.text, textSample);
     },
     // Text content (no magic-byte match, valid UTF-8) comes back with type:'text' when content requested.
     getUntypedReturnsText: () => {
@@ -324,9 +329,9 @@ export const proof = {
         assertEq(item0(getResp) === null ? null : item0(getResp).type, 'text');
         const result = JSON.parse(textOf(getResp));
         assertEq(result.type, 'text');
-        assertEq(result.mime_type, 'text/plain');
+        assertEq(result.mimeType, 'text/plain');
     },
-    // Bytes with a recognised PNG signature come back as base64 with mime_type image/png when content requested.
+    // Bytes with a recognised PNG signature come back as base64 with mimeType image/png when content requested.
     getTypedReturnsBinaryJson: () => {
         const [addResp] = session(call(2, 'cas_add', { content: pngSample, type: 'base64' }));
         const hash = textOf(addResp);
@@ -335,8 +340,33 @@ export const proof = {
         assertEq(item0(getResp).type, 'text');
         const result = JSON.parse(textOf(getResp));
         assertEq(result.type, 'base64');
-        assertEq(result.mime_type, 'image/png');
-        assertEq(result.content, pngSample);
+        assertEq(result.mimeType, 'image/png');
+        assertEq(result.blob, pngSample);
+    },
+    // A stored `vnd.fjs.revision` blob is recognized by metadata-only
+    // `cas_get` (content:false, the default) — the CAS read path routes the
+    // bounded, whole-blob-text case through the dialect-aware detector rather
+    // than only reporting the streaming text/plain verdict.
+    getMetaRecognizesRevisionDialect: () => {
+        const [addResp] = session(call(2, 'cas_add', { content: revisionSample }));
+        const hash = textOf(addResp);
+        const [, metaResp] = session(call(2, 'cas_add', { content: revisionSample }), call(3, 'cas_get', { hash }));
+        assert(!resultOf(metaResp).isError);
+        const meta = JSON.parse(textOf(metaResp));
+        assertEq(meta.mimeType, revisionMediaType);
+        assertEq(meta.type, 'text');
+    },
+    // Same dialect recognition on the `content: true` path, alongside the
+    // inline text payload.
+    getContentRecognizesRevisionDialect: () => {
+        const [addResp] = session(call(2, 'cas_add', { content: revisionSample }));
+        const hash = textOf(addResp);
+        const [, getResp] = session(call(2, 'cas_add', { content: revisionSample }), call(3, 'cas_get', { hash, content: true }));
+        assert(!resultOf(getResp).isError);
+        const result = JSON.parse(textOf(getResp));
+        assertEq(result.mimeType, revisionMediaType);
+        assertEq(result.type, 'text');
+        assertEq(result.text, revisionSample);
     },
     listEnumeratesStoredHashes: () => {
         const [addResp, listResp] = session(call(2, 'cas_add', { content: textSample }), call(3, 'cas_list', {}));
@@ -375,16 +405,14 @@ export const proof = {
         assert(!resultOf(resp).isError);
         assert(textOf(resp).length > 0);
     },
-    // base64 of exactly maxLengthBytes — currently returns isError because
-    // base64Decode measures the raw pre-trim body (1_048_578 bits) against
-    // maxLength before stripping the 2 padding bits that would land it exactly at
-    // maxLength. Assert the current failing behavior; flip to a success assertion
-    // once `fs/base64/todo/decode-rejects-max-size-input.md` is fixed.
-    addBase64AtLimitIsError: () => {
+    // base64 of exactly maxLengthBytes — base64Decode trims the encoding's
+    // padding bits from the last character before measuring the result
+    // against maxLength, so a payload landing exactly at the limit decodes
+    // and stores cleanly.
+    addBase64AtLimitSucceeds: () => {
         const [resp] = session(call(2, 'cas_add', { content: base64OfA(maxLengthBytes), type: 'base64' }));
-        assertEq(resultOf(resp).isError, true);
-        assert(textOf(resp).includes('too large or malformed'));
-        assert(textOf(resp).includes('cas add'));
+        assert(!resultOf(resp).isError);
+        assert(textOf(resp).length > 0);
     },
     getUnterminatedHashIsError: () => {
         const [resp] = session(call(2, 'cas_get', { hash: '0' }));
@@ -423,10 +451,10 @@ export const proof = {
         const [, metaResp] = session(call(2, 'cas_add', { content: 'text content' }), call(3, 'cas_get', { hash }));
         assert(!resultOf(metaResp).isError);
         const meta = JSON.parse(textOf(metaResp));
-        assertEq(meta.mime_type, 'text/plain');
+        assertEq(meta.mimeType, 'text/plain');
         assertEq(meta.type, 'text');
         assertEq(meta.length, 12);
-        assertEq(meta.content, undefined);
+        assertEq(meta.text, undefined);
     },
     getMetaBinaryBlob: () => {
         const [addResp] = session(call(2, 'cas_add', { content: pngSample, type: 'base64' }));
@@ -434,10 +462,10 @@ export const proof = {
         const [, metaResp] = session(call(2, 'cas_add', { content: pngSample, type: 'base64' }), call(3, 'cas_get', { hash }));
         assert(!resultOf(metaResp).isError);
         const meta = JSON.parse(textOf(metaResp));
-        assertEq(meta.mime_type, 'image/png');
+        assertEq(meta.mimeType, 'image/png');
         assertEq(meta.type, 'base64');
         assertEq(meta.length, 10);
-        assertEq(meta.content, undefined);
+        assertEq(meta.blob, undefined);
     },
     getMetaOctetStreamForUnknownBinary: () => {
         const binaryContent = u8ListToVec(msb)([0xFF, 0xFE, 0x00, 0x01]);
@@ -447,9 +475,9 @@ export const proof = {
         const [, metaResp] = session(call(2, 'cas_add', { content: binaryB64, type: 'base64' }), call(3, 'cas_get', { hash }));
         assert(!resultOf(metaResp).isError);
         const meta = JSON.parse(textOf(metaResp));
-        assertEq(meta.mime_type, 'application/octet-stream');
+        assertEq(meta.mimeType, 'application/octet-stream');
         assertEq(meta.type, 'base64');
-        assertEq(meta.content, undefined);
+        assertEq(meta.blob, undefined);
     },
     // A NUL-bearing blob is valid UTF-8 yet binary: cas_get must report
     // base64/octet-stream, not text/plain.
@@ -461,7 +489,7 @@ export const proof = {
         const [, metaResp] = session(call(2, 'cas_add', { content: nulB64, type: 'base64' }), call(3, 'cas_get', { hash }));
         assert(!resultOf(metaResp).isError);
         const meta = JSON.parse(textOf(metaResp));
-        assertEq(meta.mime_type, 'application/octet-stream');
+        assertEq(meta.mimeType, 'application/octet-stream');
         assertEq(meta.type, 'base64');
     },
     getMetaMissingHashIsError: () => {
@@ -482,8 +510,8 @@ export const proof = {
         const [, getResp] = session(call(2, 'cas_add', { content: binaryB64, type: 'base64' }), call(3, 'cas_get', { hash, content: true }));
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
-        assertEq(result.mime_type, 'application/octet-stream');
+        assertEq(result.mimeType, 'application/octet-stream');
         assertEq(result.type, 'base64');
-        assertEq(result.content, binaryB64);
+        assertEq(result.blob, binaryB64);
     },
 };

package/fs/cas/module.f.js

@@ -3,16 +3,16 @@
  *
  * @module
  */
-import { sha256 } from "../crypto/sha2/module.f.js";
-import { join, normalize, parse } from "../path/module.f.js";
-import { empty, length, maxLengthBytes, msb, vec } from "../types/bit_vec/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { foldStep, forEachStep, okStep, pure } from "../effects/module.f.js";
-import { access, createExclusive, isNotFound, mkdir, now, randomInt, readBytes, readdir, rename, rm, stat, writeBytes, } from "../effects/node/module.f.js";
-import { toOption } from "../types/nullable/module.f.js";
-import { error, ok, unwrap } from "../types/result/module.f.js";
-import { splitAt } from "../types/string/module.f.js";
-import { nonEmpty, empty as elEmpty } from "../effects/list/module.f.js";
+import { sha256 } from '../crypto/sha2/module.f.js';
+import { join, normalize, parse } from '../path/module.f.js';
+import { empty, length, maxLengthBytes, msb, vec } from '../types/bit_vec/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
+import { foldStep, forEachStep, okStep, pure } from '../effects/module.f.js';
+import { access, createExclusive, isNotFound, mkdir, now, randomInt, readBytes, readdir, rename, rm, stat, writeBytes, } from '../effects/node/module.f.js';
+import { toOption } from '../types/nullable/module.f.js';
+import { error, ok, unwrap } from '../types/result/module.f.js';
+import { splitAt } from '../types/string/module.f.js';
+import { nonEmpty, empty as elEmpty } from '../effects/list/module.f.js';
 const split2 = splitAt(2);
 const prefix = '.cas';
 /** Converts a content key to its sharded relative CAS file path. */

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

@@ -2,9 +2,11 @@ import { type FileCasOperation } from './module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 import { type ReadFile, type WriteFile, type Rm, type Mkdir } from '../effects/node/module.f.ts';
 type TestOp = FileCasOperation | WriteFile | ReadFile | Rm | Mkdir;
+declare const testAddBigFile: () => Effect<TestOp, void>;
+declare const testAddAndGetBigFile: () => Effect<TestOp, void>;
 export declare const proof: {
-    addBigFile: () => Effect<TestOp, void>;
-    addAndGetBigFile: () => Effect<TestOp, void>;
+    addBigFile: typeof testAddBigFile;
+    addAndGetBigFile: typeof testAddAndGetBigFile;
     casWriteRead: () => void;
     casReadMissingShard: () => void;
     casWriteMultiChunk: () => void;

package/fs/cas/proof.f.js

@@ -1,13 +1,13 @@
-import { length, maxLength, msb, vec, vec8 } from "../types/bit_vec/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
-import { fileCas, casAddFile, casUpload } from "./module.f.js";
-import { pure } from "../effects/module.f.js";
-import { mkdir, writeFile, rm, readFile, access } from "../effects/node/module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { join } from "../path/module.f.js";
-import { nonEmpty, empty } from "../effects/list/module.f.js";
+import { length, maxLength, msb, vec, vec8 } from '../types/bit_vec/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
+import { computeSync, sha256 } from '../crypto/sha2/module.f.js';
+import { fileCas, casAddFile, casUpload } from './module.f.js';
+import { pure } from '../effects/module.f.js';
+import { mkdir, writeFile, rm, readFile, access } from '../effects/node/module.f.js';
+import { error, ok } from '../types/result/module.f.js';
+import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
+import { join } from '../path/module.f.js';
+import { nonEmpty, empty } from '../effects/list/module.f.js';
 const testDir = './test-cas-cli';
 // Create a 128 KiB big file content (at the max Vec size limit)
 // This tests the boundary where files are at the chunk size limit

package/fs/ci/bun/module.f.js

@@ -4,8 +4,8 @@
  *
  * @module
  */
-import { bun } from "../config/module.f.js";
-import { clean, install, test, uses } from "../common/module.f.js";
+import { bun } from '../config/module.f.js';
+import { clean, install, test, uses } from '../common/module.f.js';
 export const bunSteps = (version) => clean([
     install(uses('oven-sh/setup-bun', { 'bun-version': bun })),
     install({ run: `bun install -g functionalscript@${version}` }),

package/fs/ci/common/module.f.d.ts

@@ -7,9 +7,9 @@
  */
 import { actions, images } from '../config/module.f.ts';
 import { type Ts } from '../../types/rtti/ts/module.f.ts';
-export declare const os: readonly ["ubuntu", "macos", "windows"];
+export declare const os: readonly ['ubuntu', 'macos', 'windows'];
 export type Os = typeof os[number];
-export declare const architecture: readonly ["intel", "arm"];
+export declare const architecture: readonly ['intel', 'arm'];
 export type Architecture = typeof architecture[number];
 export type Image = typeof images[Os][Architecture];
 export declare const stepSchema: {

package/fs/ci/common/module.f.js

@@ -5,10 +5,10 @@
  *
  * @module
  */
-import { actions, images } from "../config/module.f.js";
-import { option, array, record, string } from "../../types/rtti/module.f.js";
-import {} from "../../types/rtti/ts/module.f.js";
-import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
+import { actions, images } from '../config/module.f.js';
+import { option, array, record, string } from '../../types/rtti/module.f.js';
+import {} from '../../types/rtti/ts/module.f.js';
+import { parse as rttiParse } from '../../types/rtti/parse/module.f.js';
 export const os = ['ubuntu', 'macos', 'windows'];
 export const architecture = ['intel', 'arm'];
 export const stepSchema = {