functionalscript 0.44.0 → 0.46.0

package/fjs/js/tokenizer/proof.f.d.mts

@@ -2,6 +2,7 @@
  * @import { JsToken, JsTokenWithMetadata } from './types.ts'
  */
 export declare const proof: {
+    mergeTrivia: (() => void)[];
     djs: (() => void)[];
     operators: (() => void)[];
     ws: (() => void)[];

package/fjs/js/tokenizer/proof.f.mjs

@@ -2,7 +2,8 @@
  * @import { JsToken, JsTokenWithMetadata } from './types.ts'
  */
 
-import { tokenize } from './module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+import { mergeTrivia, tokenize } from './module.f.mjs'
 import { map, toArray } from '../../types/list/module.f.mjs'
 import { stringifyAsTree } from '../../djs/serializer/module.f.mjs'
 import { sort } from '../../types/object/module.f.mjs'
@@ -20,6 +21,14 @@ const stringify = stringifyAsTree(sort)
 const withoutMetada = tokenWithMetada => tokenWithMetada.token
 
 export const proof = {
+    // The coalescing rule both tokenizers read. All four combinations, since
+    // the whole point of exporting it is that neither side re-derives them.
+    mergeTrivia: [
+        () => assertEq(mergeTrivia('ws', 'ws'), 'ws'),
+        () => assertEq(mergeTrivia('ws', 'nl'), 'nl'),
+        () => assertEq(mergeTrivia('nl', 'ws'), 'nl'),
+        () => assertEq(mergeTrivia('nl', 'nl'), 'nl'),
+    ],
     djs: [
         () => {
             const result = stringify(tokenizeString(''))
@@ -164,16 +173,37 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('0'))
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('[0]'))
-            if (result !== '[{"kind":"["},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"]"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"["},{"kind":"number","value":"0"},{"kind":"]"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('00'))
             if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') { throw result }
         },
+        () => {
+            // A leading zero followed by another digit (not '0' itself, so
+            // digit19ToToken's own '0'-state arm, distinct from '00' above).
+            const result = stringify(tokenizeString('01'))
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') { throw result }
+        },
+        () => {
+            // 'e' right after a bare '.' (no fractional digits yet).
+            const result = stringify(tokenizeString('1.e5'))
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') { throw result }
+        },
+        () => {
+            // '+' after the exponent's digits have already started. A trailing
+            // digit (not just eof) matters here: if this branch were merged
+            // into the accepting 'e' arm, the '+' would restart the exponent
+            // and the trailing '3' would complete a *valid* number instead —
+            // 'invalid number' alone doesn't distinguish that from eof cutting
+            // the (still invalid) token short.
+            const result = stringify(tokenizeString('1e5+3'))
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"eof"}]') { throw result }
+        },
         () => {
             // terminal char after invalidNumber state (covers invalidNumberStateOp terminal branch)
             const result = stringify(tokenizeString('00,'))
@@ -185,23 +215,23 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('123456789012345678901234567890'))
-            if (result !== '[{"bf":[123456789012345678901234567890n,0],"kind":"number","value":"123456789012345678901234567890"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123456789012345678901234567890"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('{90}'))
-            if (result !== '[{"kind":"{"},{"bf":[90n,0],"kind":"number","value":"90"},{"kind":"}"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"{"},{"kind":"number","value":"90"},{"kind":"}"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('1 2'))
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"ws"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"1"},{"kind":"ws"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0. 2'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"ws"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"ws"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('10-0'))
-            if (result !== '[{"bf":[10n,0],"kind":"number","value":"10"},{"kind":"-"},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"10"},{"kind":"-"},{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('9a:'))
@@ -209,11 +239,11 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('-10'))
-            if (result !== '[{"kind":"-"},{"bf":[10n,0],"kind":"number","value":"10"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"10"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0'))
-            if (result !== '[{"kind":"-"},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-00'))
@@ -221,15 +251,15 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('-.123'))
-            if (result !== '[{"kind":"-"},{"kind":"."},{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"."},{"kind":"number","value":"123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0.01'))
-            if (result !== '[{"bf":[1n,-2],"kind":"number","value":"0.01"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0.01"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0.9'))
-            if (result !== '[{"kind":"-"},{"bf":[9n,-1],"kind":"number","value":"0.9"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"0.9"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0.'))
@@ -241,11 +271,11 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('12.34'))
-            if (result !== '[{"bf":[1234n,-2],"kind":"number","value":"12.34"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"12.34"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.00'))
-            if (result !== '[{"kind":"-"},{"bf":[1200n,-2],"kind":"number","value":"12.00"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12.00"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.'))
@@ -262,27 +292,27 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('0e1'))
-            if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e1"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e+2'))
-            if (result !== '[{"bf":[0n,2],"kind":"number","value":"0e+2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e+2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e-0'))
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0e-0"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"0e-0"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('12e0000'))
-            if (result !== '[{"bf":[12n,0],"kind":"number","value":"12e0000"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"12e0000"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12e-0001'))
-            if (result !== '[{"kind":"-"},{"bf":[12n,-1],"kind":"number","value":"12e-0001"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12e-0001"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.34e1234'))
-            if (result !== '[{"kind":"-"},{"bf":[1234n,1232],"kind":"number","value":"12.34e1234"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"-"},{"kind":"number","value":"12.34e1234"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e'))
@@ -302,11 +332,11 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('123 _123'))
-            if (result !== '[{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"_123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"_123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('123 $123'))
-            if (result !== '[{"bf":[123n,0],"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"$123"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"123"},{"kind":"ws"},{"kind":"id","value":"$123"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('123_123'))
@@ -361,7 +391,7 @@ export const proof = {
         },
         () => {
             const result = stringify(tokenizeString('1*2'))
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"*"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
+            if (result !== '[{"kind":"number","value":"1"},{"kind":"*"},{"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('( )'))

package/fjs/js/tokenizer/types.d.ts

@@ -5,15 +5,25 @@
  */
 import type { RangeMapArray } from '../../types/range_map/types.ts';
 import type { List } from '../../types/list/types.ts';
-import type { BigFloat } from '../../types/bigfloat/types.ts';
+import type { keywords } from '../keywords/module.f.mjs';
 export type StringToken = {
     readonly kind: 'string';
     readonly value: string;
 };
+/**
+ * A numeric literal, kept as the exact source lexeme.
+ *
+ * `value` is the canonical lossless numeric source: the tokenizer never
+ * narrows it to a runtime numeric representation, so a syntactically valid
+ * literal reaches its consumer whatever its magnitude — a coefficient beyond
+ * the runtime's `bigint` limit and an exponent beyond `number` precision alike.
+ * Each consumer applies its own numeric policy to `value`; see
+ * [`fjs/media/json/number`](../../media/json/number/module.f.mjs) for the
+ * bounded lexical helpers that read it without narrowing.
+ */
 export type NumberToken = {
     readonly kind: 'number';
     readonly value: string;
-    readonly bf: BigFloat;
 };
 export type BigIntToken = {
     readonly kind: 'bigint';
@@ -23,6 +33,12 @@ export type ErrorToken = {
     readonly kind: 'error';
     message: _ErrorMessage;
 };
+/**
+ * The two trivia kinds. A maximal run of whitespace and newlines collapses to
+ * one token, and the run is `'nl'` if it contains any newline — see
+ * `mergeTrivia` in `./module.f.mjs`, which owns that rule.
+ */
+export type TriviaKind = 'ws' | 'nl';
 export type WhitespaceToken = {
     readonly kind: 'ws';
 };
@@ -45,19 +61,15 @@ export type _NullToken = {
 export type _UndefinedToken = {
     readonly kind: 'undefined';
 };
-/** @internal */
+/**
+ * A keyword token, its kind drawn from the one source of truth for
+ * JavaScript keywords, `fjs/js/keywords` — minus the literal keywords
+ * (`true`/`false`/`null`/`undefined`), which have their own token types.
+ *
+ * @internal
+ */
 export type _KeywordToken = {
-    readonly kind: 'arguments' | 'await' | 'break' | 'case' | 'catch' | 'class' | 'const' | 'continue';
-} | {
-    readonly kind: 'debugger' | 'default' | 'delete' | 'do' | 'else' | 'enum' | 'eval' | 'export';
-} | {
-    readonly kind: 'extends' | 'finally' | 'for' | 'function' | 'if' | 'implements' | 'import' | 'in';
-} | {
-    readonly kind: 'instanceof' | 'interface' | 'let' | 'new' | 'package' | 'private' | 'protected' | 'public';
-} | {
-    readonly kind: 'return' | 'static' | 'super' | 'switch' | 'this' | 'throw' | 'try' | 'typeof';
-} | {
-    readonly kind: 'var' | 'void' | 'while' | 'with' | 'yield';
+    readonly kind: Exclude<typeof keywords[number], 'true' | 'false' | 'null' | 'undefined'>;
 };
 export type IdToken = {
     readonly kind: 'id';
@@ -158,20 +170,17 @@ export type _ParseUnicodeCharState = {
     readonly unicode: number;
     readonly hexIndex: number;
 };
-/** @internal */
+/**
+ * Numeric scanning state. It accumulates the lexeme only: no coefficient or
+ * exponent is materialized while scanning, so digit counts are bounded by the
+ * input rather than by any runtime numeric limit.
+ *
+ * @internal
+ */
 export type _ParseNumberState = {
     readonly kind: 'number';
     readonly numberKind: '0' | 'int' | '.' | 'fractional' | 'e' | 'e+' | 'e-' | 'expDigits' | 'bigint';
     readonly value: string;
-    readonly b: _ParseNumberBuffer;
-};
-/** @internal */
-export type _ParseNumberBuffer = {
-    readonly s: -1n | 1n;
-    readonly m: bigint;
-    readonly f: number;
-    readonly es: -1 | 1;
-    readonly e: number;
 };
 /** @internal */
 export type _InvalidNumberState = {

package/fjs/mcp/cas/module.f.d.mts

@@ -101,17 +101,12 @@
  *
  * @module
  *
- * @import { Effect } from '../../effects/types.ts'
  * @import { MemOp } from '../../effects/memory/types.ts'
  * @import { Vec } from '../../types/bit_vec/types.ts'
- * @import { Ok } from '../../types/result/types.ts'
- * @import { ToolEntry, ToolsCallResult } from '../../protocol/mcp/types.ts'
+ * @import { ToolEntry } from '../../protocol/mcp/types.ts'
  * @import { FileCasOperation } from '../../cas/types.ts'
  * @import { Cache } from '../../cas/evo/types.ts'
  * @import { Key } from '../../effects/memory/types.ts'
- * @import { Ts } from '../../types/rtti/ts/types.ts'
- * @import { List } from '../../effects/list/types.ts'
- * @import { IoResult } from '../../effects/node/types.ts'
  */
 import type { MemOp } from '../../effects/memory/types.ts';
 import type { ToolEntry } from '../../protocol/mcp/types.ts';

package/fjs/mcp/cas/module.f.mjs

@@ -101,39 +101,38 @@
  *
  * @module
  *
- * @import { Effect } from '../../effects/types.ts'
  * @import { MemOp } from '../../effects/memory/types.ts'
  * @import { Vec } from '../../types/bit_vec/types.ts'
- * @import { Ok } from '../../types/result/types.ts'
- * @import { ToolEntry, ToolsCallResult } from '../../protocol/mcp/types.ts'
+ * @import { ToolEntry } from '../../protocol/mcp/types.ts'
  * @import { FileCasOperation } from '../../cas/types.ts'
  * @import { Cache } from '../../cas/evo/types.ts'
  * @import { Key } from '../../effects/memory/types.ts'
- * @import { Ts } from '../../types/rtti/ts/types.ts'
- * @import { List } from '../../effects/list/types.ts'
- * @import { IoResult } from '../../effects/node/types.ts'
  */
 
 import { string, option, or, boolean } from '../../types/rtti/module.f.mjs'
 import { stringify } from '../../media/json/module.f.mjs'
-import { pure, step } from '../../effects/module.f.mjs'
+import { pureOk, resultStep } from '../../effects/module.f.mjs'
 import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
 import { decode as base64Decode, encode as base64Encode } from '../../basen/base64/module.f.mjs'
 import { tryUtf8 } from '../../text/module.f.mjs'
 import { detectStream } from '../../media/type/module.f.mjs'
 import { detect } from '../../media/module.f.mjs'
 import { revisionDialect } from '../../media/revision/module.f.mjs'
+import { lockDialect } from '../../media/lock/module.f.mjs'
+import { noteDialect } from '../../media/note/module.f.mjs'
 import { maxLengthBytes } from '../../types/bit_vec/module.f.mjs'
 import { ok } from '../../types/result/module.f.mjs'
 import {
     toolEntry, errorResult, okResult,
 } from '../../protocol/mcp/module.f.mjs'
 import { collectRead, fileCas } from '../../cas/module.f.mjs'
+import { errorSummary } from '../../effects/node/module.f.mjs'
 import { fromVec } from '../../text/utf8/module.f.mjs'
 import { identity } from '../../types/function/module.f.mjs'
 import { sha256 } from '../../crypto/sha2/module.f.mjs'
 import { nonEmpty, empty as elEmpty } from '../../effects/list/module.f.mjs'
 import { syncRevision } from '../../cas/evo/module.f.mjs'
+import { assertNotNullish } from '../../asserts/module.f.mjs'
 
 // ── Argument schemas (declared once, used for both inputSchema and validate) ─────
 
@@ -156,8 +155,13 @@ export const casListArgs = /** @type {const} */ ({})
 
 const toJson = stringify(identity)
 
-/** The dialect-aware classifier, bound to the dialects this server recognizes. */
-const detectDialect = detect([revisionDialect])
+/**
+ * The dialect-aware classifier, bound to the dialects this server recognizes:
+ * the revision format, the shared lock maps revisions reference
+ * (`fjs/media/lock`), and notes (`fjs/media/note`), so `cas_get` reports each
+ * under its own media type instead of `text/plain`.
+ */
+const detectDialect = detect([revisionDialect, lockDialect, noteDialect])
 
 /** @typedef {{
  *   readonly length: number
@@ -184,46 +188,43 @@ export const casToolRegistry = home => cacheKey => {
             '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 is capped at 128 KiB (131072 bytes) — larger content is rejected. For larger content, store the file with the `cas` CLI instead: run `npx functionalscript cas add <path>` yourself if you have shell access, or give the user that exact command to run — it prints the resulting hash on stdout.',
             casAddArgs,
-            /** @type {(args: Ts<typeof casAddArgs>) => Effect<FileCasOperation | MemOp, ToolsCallResult>} */
-            (({ type, content }) => {
+            ({ type, content }) => {
                 // type:'text' or 'base64' — resolve content to Vec, store via c.write()
                 /** @type {Vec | null} */
                 let x = type === 'base64'
                     ? base64Decode(content)
                     : tryUtf8(content)
                 return x === null
-                    ? pure(errorResult('too large or malformed — for large content, run `npx functionalscript cas add <path>` (or have the user run it) instead'))
+                    ? pureOk(errorResult('too large or malformed — for large content, run `npx functionalscript cas add <path>` (or have the user run it) instead'))
                     // The resolved content fits in one chunk; feed it as a single-item stream.
-                    : step(
-                        c.write(nonEmpty(ok(x), /** @type {List<never, Ok<Vec>>} */ (elEmpty()))),
-                        /** @type {(writeResult: IoResult<Vec>) => Effect<MemOp, ToolsCallResult>} */
-                        (writeResult => {
-                            if (writeResult[0] === 'error') { return pure(errorResult('write')) }
+                    : resultStep(
+                        c.write(nonEmpty(x, elEmpty())),
+                        writeResult => {
+                            if (writeResult[0] === 'error') { return pureOk(errorResult('write')) }
                             const hash = writeResult[1]
-                            return step(
-                                syncRevision(cacheKey)(hash)(/** @type {Vec} */ (x)),
-                                () => pure(okResult(vecToCBase32(hash)))
+                            return resultStep(
+                                syncRevision(cacheKey)(hash)(x),
+                                () => pureOk(okResult(vecToCBase32(hash)))
                             )
-                        }),
+                        },
                     )
-            }),
+            },
         ),
         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,
-            /** @type {(args: Ts<typeof casGetArgs>) => Effect<FileCasOperation, ToolsCallResult>} */
-            (r => {
+            r => {
                 const key = cBase32ToVec(r.hash)
                 if (key === null) {
-                    return pure(errorResult(`invalid cBase32 hash: ${r.hash}`))
+                    return pureOk(errorResult(`invalid cBase32 hash: ${r.hash}`))
                 }
                 const uri = c.url(key)
-                return step(
+                return resultStep(
                     detectStream(c.read(key)),
                     ([tag, detected]) => {
                         if (tag === 'error') {
-                            return pure(errorResult(`no such hash: ${r.hash}`))
+                            return pureOk(errorResult(`no such hash: ${r.hash}`))
                         }
                         const { length, mime_type: mimeType, type } = detected
                         /** @type {_Meta} */
@@ -233,17 +234,17 @@ export const casToolRegistry = home => cacheKey => {
                             // 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 pureOk(okResult(toJson(meta)))
                             }
-                            return step(
+                            return resultStep(
                                 collectRead(c.read(key)),
                                 ([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))) }
+                                    if (collectTag === 'error') { return pureOk(okResult(toJson(meta))) }
                                     const refined = detectDialect(value)
-                                    return pure(okResult(toJson({ ...meta, mimeType: refined.mime_type })))
+                                    return pureOk(okResult(toJson({ ...meta, mimeType: refined.mime_type })))
                                 }
                             )
                         }
@@ -252,14 +253,14 @@ export const casToolRegistry = home => cacheKey => {
                         // size and point at the size-independent alternatives instead of
                         // misreporting an existing blob as `no such hash`.
                         if (length > maxLengthBytes) {
-                            return pure(errorResult(
+                            return pureOk(errorResult(
                                 `blob too large to fetch inline (${length} bytes, limit ${maxLengthBytes} bytes); use the uri field (${uri}) or omit content for metadata`))
                         }
-                        return step(
+                        return resultStep(
                             collectRead(c.read(key)),
                             ([collectTag, value]) => {
                                 if (collectTag === 'error') {
-                                    return pure(errorResult(`no such hash: ${r.hash}`))
+                                    return pureOk(errorResult(`no such hash: ${r.hash}`))
                                 }
                                 // Re-derive the verdict from the now-materialized blob so a
                                 // dialect match — only decidable with the whole parsed JSON in
@@ -269,34 +270,37 @@ export const casToolRegistry = home => cacheKey => {
                                 /** @type {_Meta} */
                                 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({ ...refinedMeta, text: str }))
-                                    )
+                                    // `type: 'text'` means the detector validated `value` as
+                                    // whole-blob UTF-8 with a byte-aligned length (see
+                                    // `media/type`'s `finish`) — the same two conditions
+                                    // `fromVec` checks, via the same decoder — so `fromVec`
+                                    // cannot return `null` here (mirrors `media`'s own `detect`).
+                                    const str = assertNotNullish(fromVec(value), 'cas_get: type text implies fromVec succeeds')
+                                    return pureOk(okResult(toJson({ ...refinedMeta, text: str })))
                                 }
-                                const blob = base64Encode(value)
-                                return pure(blob === null
-                                    ? errorResult(`content is not byte-aligned: ${r.hash}`)
-                                    : okResult(toJson({ ...refinedMeta, blob }))
-                                )
+                                // Every byte ever written through `cas_add`/the CAS store is
+                                // whole-byte chunks (UTF-8 text or already-decoded base64), so
+                                // `value` is always byte-aligned regardless of which branch
+                                // classified it — `base64Encode` only rejects a non-byte-aligned
+                                // input.
+                                const blob = assertNotNullish(base64Encode(value), 'cas_get: stored content is always byte-aligned')
+                                return pureOk(okResult(toJson({ ...refinedMeta, blob })))
                             },
                         )
                     },
                 )
-            }),
+            },
         ),
         toolEntry(
             'cas_list',
             'List all stored content hashes (cBase32), one per line.',
             casListArgs,
-            /** @type {() => Effect<FileCasOperation, ToolsCallResult>} */
-            (() => step(
+            () => resultStep(
                 c.list(),
-                hashes => pure(okResult(hashes.map(vecToCBase32).join('\n')))
-            )),
+                r => pureOk(r[0] === 'error'
+                    ? errorResult(errorSummary(r[1]))
+                    : okResult(r[1].map(vecToCBase32).join('\n')))
+            ),
         ),
     ]
 }

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

@@ -0,0 +1,15 @@
+/**
+ * @import { Effect } from '../../effects/types.ts'
+ * @import { Result } from '../../types/result/types.ts'
+ * @import { FileCasOperation } from '../../cas/types.ts'
+ * @import { MemOp } from '../../effects/memory/types.ts'
+ * @import { Cache } from '../../cas/evo/types.ts'
+ * @import { Key } from '../../effects/memory/types.ts'
+ * @import { ToolsCallResult } from '../../protocol/mcp/types.ts'
+ */
+export declare const proof: {
+    casListStorageErrorReturnsError: () => void;
+    casAddWriteErrorReturnsError: () => void;
+    casGetMetadataRefineHashVanishesFallsBackToStreamingVerdict: () => void;
+    casGetContentFetchHashVanishesReturnsError: () => void;
+};