functionalscript 0.35.2 → 0.37.0

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

@@ -1,18 +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 {} from "../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 => {
@@ -59,6 +62,19 @@ const runSessionVirtual = (root, home = '/home/user') => (msgs) => {
     });
     return virtual({ ...emptyState, root })(effect)[1];
 };
+// Seeds a blob directly into the virtual store via `c.write`, bypassing the
+// MCP `cas_add` tool entirely — used by tests that need a stored blob larger
+// than `cas_add`'s inline limit, now that the removed `type:'url'` path is no
+// longer available to stage one through MCP. Returns the resulting root
+// `Dir` (with the new shard written) and the blob's cBase32 hash so a
+// subsequent `runSessionVirtual` call can read it back via `cas_get`.
+const seedBlob = (root, home = '/home/user') => (chunks) => {
+    const c = fileCas(sha256)(home);
+    const stream = chunks.reduceRight((tail, chunk) => nonEmpty(resultOk(chunk), tail), elEmpty());
+    const [state, result] = virtual({ ...emptyState, root })(c.write(stream));
+    assert(result[0] === 'ok', result);
+    return [state.root, vecToCBase32(result[1])];
+};
 // ── Messages ────────────────────────────────────────────────────────────────────
 const init = { jsonrpc: '2.0', method: 'initialize', id: 1,
     params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'c', version: '0' } } };
@@ -89,14 +105,18 @@ 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 — safe near maxLengthBytes where base64Encode on a
-// padded Vec would trigger the encode-padding-overflow bug. Handles every n%3
+// without bigint arithmetic — independent of `base64.encode` so these tests
+// don't rely on the correctness of the function they're indirectly exercising
+// (`cas_add` decodes the string via `base64.decode`). Handles every n%3
 // residue: rem=0 → no padding, rem=1 → 'AA==', rem=2 → 'AAA='.
 const base64OfA = (n) => {
     const groups = Number(n / 3n);
@@ -117,24 +137,18 @@ const base64OfA = (n) => {
 // exactly `maxLengthBytes` (the largest single `Vec` the runtime allows), so the
 // two-chunk blob spans two read chunks without any one `Vec` exceeding the cap.
 const largeMultiChunkBlobMeta = (chunk0, chunk1, expectedType, expectedMime) => () => {
-    const root = { 'home': { 'user': { 'cas_upload': { 'big': [chunk0, chunk1] } } } };
-    const [addResp] = runSessionVirtual(root)([
-        init, initialized,
-        call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-    ]).slice(2);
-    assert(!resultOf(addResp).isError);
-    const hash = textOf(addResp);
-    const [, metaResp] = runSessionVirtual(root)([
+    const [root, hash] = seedBlob({})([chunk0, chunk1]);
+    const [metaResp] = runSessionVirtual(root)([
         init, initialized,
-        call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-        call(3, 'cas_get', { hash }),
+        call(2, 'cas_get', { hash }),
     ]).slice(2);
     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));
@@ -145,8 +159,7 @@ const binaryChunk = repeat(maxLengthBytes)(vec8(0xffn));
 // 100,000 raw bytes of 0xFF: comfortably under `maxLengthBytes` (so `cas_get`'s
 // own `length > maxLengthBytes` guard does not fire), but base64 inflates it to
 // ceil(100_000/3)*4 = 133,336 chars — already past `maxLength` (131,072 bytes)
-// before the JSON-RPC envelope adds anything. Small enough to stay clear of the
-// separate `base64Encode`-near-`maxLength` padding bug (see `base64OfA` above).
+// before the JSON-RPC envelope adds anything.
 const oversizedBase64Chunk = repeat(100000n)(vec8(0xffn));
 // 90,000 raw bytes: base64 inflates to 120,000 chars, leaving ~11 KiB of margin
 // under `maxLength` once the envelope is added — the paired "still succeeds" case.
@@ -170,16 +183,10 @@ export const proof = {
     // "too large" error, not "no such hash" — the blob exists, it just can't be
     // buffered inline. The metadata-only path (above) still returns its size/type.
     getContentLargeBlobTooLargeError: () => {
-        const root = { 'home': { 'user': { 'cas_upload': { 'big': [asciiChunk, asciiChunk] } } } };
-        const [addResp] = runSessionVirtual(root)([
+        const [root, hash] = seedBlob({})([asciiChunk, asciiChunk]);
+        const [getResp] = runSessionVirtual(root)([
             init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-        ]).slice(2);
-        const hash = textOf(addResp);
-        const [, getResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-            call(3, 'cas_get', { hash, content: true }),
+            call(2, 'cas_get', { hash, content: true }),
         ]).slice(2);
         assertEq(resultOf(getResp).isError, true);
         const text = textOf(getResp);
@@ -205,34 +212,24 @@ 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 = { 'home': { 'user': { 'cas_upload': { 'big': [oversizedBase64Chunk] } } } };
-        const [addResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-        ]);
-        const hash = textOf(addResp);
-        const [, getResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-            call(3, 'cas_get', { hash, content: true }),
+        const [root, hash] = seedBlob({})([oversizedBase64Chunk]);
+        const [getResp] = runStdio(root)([
+            call(2, 'cas_get', { hash, content: true }),
         ]);
         const err = getResp;
         assertEq(err.error?.code, -32603);
-        assertEq(err.id, 3);
+        assertEq(err.id, 2);
     },
     // The paired boundary case: a blob whose base64 inflation leaves enough
     // margin under `maxLength` for the envelope — confirms the fallback above
     // only triggers on genuine overflow, not on every `content:true` binary read.
     getContentBase64NearBoundarySucceeds: () => {
-        const root = { 'home': { 'user': { 'cas_upload': { 'big': [boundaryBase64Chunk] } } } };
-        const [addResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-        ]);
-        const hash = textOf(addResp);
-        const [, getResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/big', type: 'url' }),
-            call(3, 'cas_get', { hash, content: true }),
+        const [root, hash] = seedBlob({})([boundaryBase64Chunk]);
+        const [getResp] = runStdio(root)([
+            call(2, 'cas_get', { hash, content: true }),
         ]);
         assert(!resultOf(getResp).isError);
         const result = JSON.parse(textOf(getResp));
@@ -243,25 +240,21 @@ export const proof = {
     // (33,000 bytes) well under `maxLengthBytes`, but each quote costs 2 bytes on
     // the inner CAS-JSON escape and 4 bytes once the outer JSON-RPC envelope
     // re-escapes that backslash-quote pair — no `cas_get`-level size guard could
-    // see this coming, only the transport's real encode attempt can. Uploaded via
-    // `type: 'url'` (a file, not an inlined JSON string) so the test exercises
-    // `cas_get`'s response-side escaping without also paying for parsing a huge
-    // inline `content` argument on the request side. Confirms `writeResponse`'s
+    // see this coming, only the transport's real encode attempt can. Seeded
+    // directly into the store via `seedBlob` (not an inlined `cas_add` JSON
+    // string) so the test exercises `cas_get`'s response-side escaping without
+    // also paying for parsing a huge inline `content` argument on the request
+    // side. Confirms `writeResponse`'s
     // `tryUtf8` fallback (not a crash) handles double-escaping overflow, again
     // preserving the request's `id`.
     getContentDoubleEscapedOverflowWritesInternalError: () => {
-        const root = { 'home': { 'user': { 'cas_upload': { 'q': [quotesChunk] } } } };
-        const [addResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/q', type: 'url' }),
-        ]);
-        const hash = textOf(addResp);
-        const [, getResp] = runStdio(root)([
-            call(2, 'cas_add', { content: '/home/user/cas_upload/q', type: 'url' }),
-            call(3, 'cas_get', { hash, content: true }),
+        const [root, hash] = seedBlob({})([quotesChunk]);
+        const [getResp] = runStdio(root)([
+            call(2, 'cas_get', { hash, content: true }),
         ]);
         const err = getResp;
         assertEq(err.error?.code, -32603);
-        assertEq(err.id, 3);
+        assertEq(err.id, 2);
     },
     toolsListAdvertisesThreeTools: () => {
         const [resp] = runSessionVirtual({})([init, initialized, list(2)]).slice(2);
@@ -283,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: () => {
@@ -296,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: () => {
@@ -306,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: () => {
@@ -318,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 }));
@@ -326,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: () => {
@@ -336,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);
@@ -347,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', {}));
@@ -370,6 +388,7 @@ export const proof = {
         const [resp] = session(call(2, 'cas_add', { content: 'A'.repeat(174_764), type: 'base64' }));
         assertEq(resultOf(resp).isError, true);
         assert(textOf(resp).includes('too large or malformed'));
+        assert(textOf(resp).includes('cas add'));
     },
     // One ASCII byte past maxLengthBytes — tryUtf8 returns null and cas_add
     // surfaces an error.
@@ -377,6 +396,7 @@ export const proof = {
         const [resp] = session(call(2, 'cas_add', { content: 'a'.repeat(Number(maxLengthBytes) + 1) }));
         assertEq(resultOf(resp).isError, true);
         assert(textOf(resp).includes('too large or malformed'));
+        assert(textOf(resp).includes('cas add'));
     },
     // Exactly maxLengthBytes (131,072) ASCII bytes — tryUtf8 returns a non-null
     // Vec (len === maxLength, not over), so cas_add stores cleanly.
@@ -385,15 +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(!resultOf(resp).isError);
+        assert(textOf(resp).length > 0);
     },
     getUnterminatedHashIsError: () => {
         const [resp] = session(call(2, 'cas_get', { hash: '0' }));
@@ -425,66 +444,17 @@ export const proof = {
         assert(!('error' in resp));
         assert('result' in resp);
     },
-    // cas_add with type:'url' streams a file from /home/user/cas_upload/ into CAS.
-    addUrlStoresFileAndReturnsHash: () => {
-        const fileContent = utf8('hello from file');
-        const root = { 'home': { 'user': { 'cas_upload': { 'hello.txt': [fileContent] } } } };
-        const [addUrlResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/hello.txt', type: 'url' }),
-        ]).slice(2);
-        assert(!resultOf(addUrlResp).isError);
-        assert(textOf(addUrlResp).length > 0);
-    },
-    addUrlRoundTrips: () => {
-        const fileContent = utf8('round-trip content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'rt.txt': [fileContent] } } } };
-        // First pass: add to get the hash (deterministic for same content).
-        const [addResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/rt.txt', type: 'url' }),
-        ]).slice(2);
-        const hash = textOf(addResp);
-        // Second pass: add again + get in one session (file re-present in fresh virtual state).
-        const [, getResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/rt.txt', type: 'url' }),
-            call(3, 'cas_get', { hash, content: true }),
-        ]).slice(2);
-        assert(!resultOf(getResp).isError);
-        const result = JSON.parse(textOf(getResp));
-        assertEq(result.type, 'text');
-        assertEq(result.content, 'round-trip content');
-    },
-    addUrlMissingFileIsError: () => {
-        const [resp] = runSessionVirtual({})([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/nonexistent.txt', type: 'url' }),
-        ]).slice(2);
-        assertEq(resultOf(resp).isError, true);
-    },
     // cas_get without content:true returns only metadata.
     getMetaReturnsLengthAndMimeType: () => {
-        const fileContent = utf8('text content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'f': [fileContent] } } } };
-        // First pass: add to get the hash.
-        const [addResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/f', type: 'url' }),
-        ]).slice(2);
+        const [addResp] = session(call(2, 'cas_add', { content: 'text content' }));
         const hash = textOf(addResp);
-        // Second pass: add + get metadata.
-        const [, metaResp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/f', type: 'url' }),
-            call(3, 'cas_get', { hash }),
-        ]).slice(2);
+        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' }));
@@ -492,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]);
@@ -505,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.
@@ -519,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: () => {
@@ -531,40 +501,6 @@ export const proof = {
         const [resp] = session(call(2, 'cas_get', { hash: 'bad!' }));
         assertEq(resultOf(resp).isError, true);
     },
-    // cas_add type:'url' with a subdirectory path flattens slashes to '-' in staging.
-    addUrlFromSubdirectorySucceeds: () => {
-        const fileContent = utf8('nested file content');
-        const root = { 'home': { 'user': { 'cas_upload': { 'subdir': { 'file.txt': [fileContent] } } } } };
-        const [resp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/subdir/file.txt', type: 'url' }),
-        ]).slice(2);
-        assert(!resultOf(resp).isError);
-        assert(textOf(resp).length > 0);
-    },
-    // cas_add with type:'url' accepts paths within /home/user/cas_upload/
-    addUrlFromApprovedDirectorySucceeds: () => {
-        const fileContent = utf8('approved file');
-        const root = { 'home': { 'user': { 'cas_upload': { 'test.txt': [fileContent] } } } };
-        const [resp] = runSessionVirtual(root)([
-            init, initialized,
-            call(2, 'cas_add', { content: '/home/user/cas_upload/test.txt', type: 'url' }),
-        ]).slice(2);
-        assert(!resultOf(resp).isError);
-        assert(textOf(resp).length > 0);
-    },
-    // cas_add with type:'url' rejects paths outside /home/user/cas_upload/
-    addUrlFromRandomDirectoryIsRejected: () => {
-        const [resp] = session(call(2, 'cas_add', { content: '/tmp/secret.txt', type: 'url' }));
-        assert(resultOf(resp).isError === true);
-        assert(textOf(resp).includes('/home/user/cas_upload/'));
-    },
-    // cas_add with type:'url' rejects path traversal attempts with ..
-    addUrlWithPathTraversalIsRejected: () => {
-        const [resp] = session(call(2, 'cas_add', { content: '/home/user/cas_upload/../../etc/passwd', type: 'url' }));
-        assert(resultOf(resp).isError === true);
-        assert(textOf(resp).includes('/home/user/cas_upload/'));
-    },
     // cas_get with content:true on octet-stream (no magic bytes, not UTF-8) returns inline base64.
     getOctetStreamWithContentIncludesBase64: () => {
         const binaryContent = u8ListToVec(msb)([0xFF, 0xFE, 0x00, 0x01]);
@@ -574,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, 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. */
@@ -141,9 +141,7 @@ export const fileCas = (sha2) => (path) => {
                     .step(t0 => {
                     const path0 = join(stageDir, stageName(t0 + leaseDelta, rndStr));
                     return createExclusive(path0)
-                        .step(([c, e]) => c === 'error'
-                        ? pure(error(e))
-                        : loop(sha2.init, 0, path0)(payload));
+                        .step(okStep(() => loop(sha2.init, 0, path0)(payload)));
                 }));
             }));
         },
@@ -200,10 +198,5 @@ cas.write(streamFile(path));
 export const casUpload = (home) => (fileName) => {
     const src = join(home, 'cas_upload', fileName);
     const c = fileCas(sha256)(home);
-    return casAddFile(c)(src).step((result) => {
-        if (result[0] === 'error') {
-            return pure(result);
-        }
-        return rm(src).step(() => pure(result));
-    });
+    return casAddFile(c)(src).step(okStep(v => rm(src).step(() => pure(ok(v)))));
 };

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: {