functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/path/proof.f.js

@@ -1,170 +1,119 @@
 import { concat, isProperPrefix, join, normalize, relativize, toPosix } from "./module.f.js";
+import { assertEq } from '../asserts/module.f.js';
 const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
-        if (norm !== "dir/file.json") {
-            throw norm;
-        }
+        assertEq(norm, "dir/file.json");
     },
     () => {
         const norm = normalize("dir//file.json");
-        if (norm !== "dir/file.json") {
-            throw norm;
-        }
+        assertEq(norm, "dir/file.json");
     },
     () => {
         const norm = normalize("../../dir/file.json");
-        if (norm !== "../../dir/file.json") {
-            throw norm;
-        }
+        assertEq(norm, "../../dir/file.json");
     },
     () => {
         const norm = normalize("../../dir/../file.json");
-        if (norm !== "../../file.json") {
-            throw norm;
-        }
+        assertEq(norm, "../../file.json");
     },
 ];
 const concatTest = [
     () => {
         const c = concat("a")("b");
-        if (c !== "a/b") {
-            throw c;
-        }
+        assertEq(c, "a/b");
     },
     () => {
         const c = concat("a///b/")("c");
-        if (c !== "a/b/c") {
-            throw c;
-        }
+        assertEq(c, "a/b/c");
     },
     () => {
         const c = concat("a/../b/..")("c");
-        if (c !== "c") {
-            throw c;
-        }
+        assertEq(c, "c");
     },
 ];
 const joinTest = [
     () => {
         const r = join('a', 'b');
-        if (r !== 'a/b') {
-            throw r;
-        }
+        assertEq(r, 'a/b');
     },
     () => {
         const r = join('/abs/root', 'x');
-        if (r !== '/abs/root/x') {
-            throw r;
-        }
+        assertEq(r, '/abs/root/x');
     },
     () => {
         const r = join('a', 'b', 'c', 'd');
-        if (r !== 'a/b/c/d') {
-            throw r;
-        }
+        assertEq(r, 'a/b/c/d');
     },
     () => {
         const r = join('', 'x');
-        if (r !== '/x') {
-            throw r;
-        }
+        assertEq(r, '/x');
     },
     () => {
         const r = join();
-        if (r !== '') {
-            throw r;
-        }
+        assertEq(r, '');
     },
     () => {
         const r = join('only');
-        if (r !== 'only') {
-            throw r;
-        }
+        assertEq(r, 'only');
     },
 ];
 const relativizeTest = [
     () => {
         const r = relativize('/repo', '/repo/fs/a.ts');
-        if (r !== './fs/a.ts') {
-            throw r;
-        }
+        assertEq(r, './fs/a.ts');
     },
     () => {
         const r = relativize('/repo', '/other/a.ts');
-        if (r !== '/other/a.ts') {
-            throw r;
-        }
+        assertEq(r, '/other/a.ts');
     },
     () => {
         const r = relativize('', './fs/a.ts');
-        if (r !== './fs/a.ts') {
-            throw r;
-        }
+        assertEq(r, './fs/a.ts');
     },
 ];
 const toPosixTest = [
     () => {
         const p = toPosix('a\\b\\c');
-        if (p !== 'a/b/c') {
-            throw p;
-        }
+        assertEq(p, 'a/b/c');
     },
     () => {
         const p = toPosix('a/b/c');
-        if (p !== 'a/b/c') {
-            throw p;
-        }
+        assertEq(p, 'a/b/c');
     },
     () => {
         const p = toPosix('C:\\Users\\x');
-        if (p !== 'C:/Users/x') {
-            throw p;
-        }
+        assertEq(p, 'C:/Users/x');
     },
     () => {
         const p = toPosix('');
-        if (p !== '') {
-            throw p;
-        }
+        assertEq(p, '');
     },
 ];
 const isProperPrefixTest = [
     () => {
         const r = isProperPrefix(['a', 'b'], ['a', 'b', 'c']);
-        if (r !== true) {
-            throw r;
-        }
+        assertEq(r, true);
     },
     () => {
         const r = isProperPrefix(['a', 'b'], ['a', 'b']);
-        if (r !== false) {
-            throw r;
-        }
+        assertEq(r, false);
     },
     () => {
         const r = isProperPrefix(['a', 'x'], ['a', 'b', 'c']);
-        if (r !== false) {
-            throw r;
-        }
+        assertEq(r, false);
     },
     () => {
         const r = isProperPrefix(['a', 'b', 'c'], ['a', 'b']);
-        if (r !== false) {
-            throw r;
-        }
+        assertEq(r, false);
     },
     () => {
         const r = isProperPrefix([], ['a']);
-        if (r !== true) {
-            throw r;
-        }
+        assertEq(r, true);
     },
     () => {
         const r = isProperPrefix([], []);
-        if (r !== false) {
-            throw r;
-        }
+        assertEq(r, false);
     },
 ];
 export const proof = { normalizeTest, concatTest, joinTest, relativizeTest, toPosixTest, isProperPrefixTest };

package/{fs → fjs}/proof.f.js

@@ -25,6 +25,8 @@ export const proof = {
     mcp: () => {
         // stdin is empty in the virtual environment, so the server sees EOF
         // immediately and shuts down cleanly, exercising the `mcp` handler.
+        // The store is empty too, so `casMcpServer`'s Evo cache scan
+        // (`initEvo`) also runs and finds nothing.
         const [, code] = run({})(['mcp']);
         assertEq(code, 0);
     },

package/{fs → fjs}/sul/id/proof.f.js

@@ -28,9 +28,7 @@ export const proof = {
     inline_is_raw: () => assert(isRaw(compress(level3Id(0x00n), level3Id(0x00n)))),
     // Non-commutativity: argument order is preserved in concatenation
     non_commutative: () => {
-        if (compress(level3Id(0n), level3Id(1n)) === compress(level3Id(1n), level3Id(0n))) {
-            throw compress(level3Id(0n), level3Id(1n));
-        }
+        assert(compress(level3Id(0n), level3Id(1n)) !== compress(level3Id(1n), level3Id(0n)), compress(level3Id(0n), level3Id(1n)));
     },
     // Overflow: two 127-bit raw payloads sum to 254 bits, exceeding the 253-bit inline limit
     overflow_is_hash: () => assert(isHash(overflowHash)),
@@ -38,38 +36,26 @@ export const proof = {
     hash_left_is_hash: () => assert(isHash(compress(overflowHash, level3Id(0n)))),
     hash_right_is_hash: () => assert(isHash(compress(level3Id(0n), overflowHash))),
     hash_non_commutative: () => {
-        if (compress(overflowHash, level3Id(0n)) === compress(level3Id(0n), overflowHash)) {
-            throw compress(overflowHash, level3Id(0n));
-        }
+        assert(compress(overflowHash, level3Id(0n)) !== compress(level3Id(0n), overflowHash), compress(overflowHash, level3Id(0n)));
     },
     // High-bit sensitivity: prefix bit of `a` is included in the SHA2 upper half
     hash_merge_a_high_bits: () => {
-        if (compress(hashId(0n), hashId(0n)) === compress(level3Id(0n), hashId(0n))) {
-            throw compress(hashId(0n), hashId(0n));
-        }
+        assert(compress(hashId(0n), hashId(0n)) !== compress(level3Id(0n), hashId(0n)), compress(hashId(0n), hashId(0n)));
     },
     // High-bit sensitivity: prefix bit of `b` is included in the SHA2 lower half
     hash_merge_b_high_bits: () => {
-        if (compress(hashId(0n), hashId(0n)) === compress(hashId(0n), level3Id(0n))) {
-            throw compress(hashId(0n), hashId(0n));
-        }
+        assert(compress(hashId(0n), hashId(0n)) !== compress(hashId(0n), level3Id(0n)), compress(hashId(0n), hashId(0n)));
     },
     // Shift correctness: changing a bit in `a` (upper 256 bits of SHA2 input) changes result
     hash_merge_a_sensitivity: () => {
-        if (compress(hFF, hFF) === compress(hFE, hFF)) {
-            throw compress(hFF, hFF);
-        }
+        assert(compress(hFF, hFF) !== compress(hFE, hFF), compress(hFF, hFF));
     },
     // Shift correctness: changing a bit in `b` (lower 256 bits of SHA2 input) changes result
     hash_merge_b_sensitivity: () => {
-        if (compress(hFF, hFF) === compress(hFF, hFE)) {
-            throw compress(hFF, hFF);
-        }
+        assert(compress(hFF, hFF) !== compress(hFF, hFE), compress(hFF, hFF));
     },
     // Shift correctness: same bit-flip in `a` vs `b` lands at different SHA2 input positions
     hash_merge_shift: () => {
-        if (compress(hFE, hFF) === compress(hFF, hFE)) {
-            throw compress(hFE, hFF);
-        }
+        assert(compress(hFE, hFF) !== compress(hFF, hFE), compress(hFE, hFF));
     },
 };

package/{fs → fjs}/sul/level/hash/proof.f.js

@@ -42,9 +42,9 @@ export const proof = {
     // All symbols before the terminator return undefined
     intermediate_undefined: () => {
         const [r0, st0] = enc(s1, initial);
-        assert(r0 === undefined);
+        assertEq(r0, undefined);
         const [r1, st1] = enc(s0, st0);
-        assert(r1 === undefined);
+        assertEq(r1, undefined);
         const [r2] = enc(s1, st1);
         assert(r2 !== undefined);
     },
@@ -100,13 +100,13 @@ export const proof = {
     // Trie-internal merges have isSymbol=false; only the terminal merge has isSymbol=true
     isSymbol_terminal_only: () => {
         const [, storage] = runWord([s1, s0, s0]);
-        assert(storage[0][3] === false); // Patricia trie merge
-        assert(storage[1][3] === true); // terminal compress(root, t)
+        assertEq(storage[0][3], false); // Patricia trie merge
+        assertEq(storage[1][3], true); // terminal compress(root, t)
     },
     // Single-step word: no trie merges, exactly one isSymbol=true
     isSymbol_min_word: () => {
         const [, storage] = runWord([s0, s0]);
         assertEq(storage.length, 1);
-        assert(storage[0][3] === true);
+        assertEq(storage[0][3], true);
     },
 };

package/{fs → fjs}/sul/level/literal/proof.f.js

@@ -1,4 +1,5 @@
 import { chunkList, msb, vec } from '../../../types/bit_vec/module.f.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
 import { map, stateScan, toArray } from '../../../types/list/module.f.js';
 import { emptyEncodeState, emptyPipelineState, level, literal1ToVec, literal2ToVec, literal3ToVec, pipelineStep, symbolToString, wordEqual, wordToString } from './module.f.js';
 const tests = (n) => {
@@ -18,33 +19,24 @@ const tests = (n) => {
             }
             // encode
             const a = toArray(stateScan(push)(emptyEncodeState)(word));
-            if (!a.slice(0, -1).every(i => i === undefined)) {
-                throw a;
-            }
+            assert(a.slice(0, -1).every(i => i === undefined), a);
             const x = a.at(-1);
-            if (x !== expected) {
-                throw x;
-            }
+            assertEq(x, expected);
         }
     };
 };
 const l = (f) => (l, e) => {
     const result = f(l);
-    if (result !== e) {
-        throw [result, e];
-    }
+    assertEq(result, e, [result, e]);
 };
 const vecToBits = (v) => map((b) => msb.front(1n)(b))(chunkList(msb)(1n)(v));
 const w = (symbol, expected) => {
     const result = literal3ToVec(symbol);
-    if (result !== expected)
-        throw [result, expected];
+    assertEq(result, expected, [result, expected]);
     const a = toArray(stateScan(pipelineStep)(emptyPipelineState)(vecToBits(expected)));
-    if (!a.slice(0, -1).every(o => o === undefined))
-        throw a;
+    assert(a.slice(0, -1).every(o => o === undefined), a);
     const out = a.at(-1);
-    if (out !== symbol)
-        throw out;
+    assertEq(out, symbol);
 };
 export const proof = {
     x2: () => {
@@ -688,9 +680,7 @@ export const proof = {
     },
     wordToString: () => {
         const result = wordToString([0n, 1n, 0xabn]);
-        if (result !== '0,1,ab') {
-            throw result;
-        }
+        assertEq(result, '0,1,ab');
     },
     pipeline: () => {
         // 4 L1 [0,0] words → 2 L2 [0,0] words → L3 [0,0] word → symbol 0
@@ -698,14 +688,12 @@ export const proof = {
         let s = emptyPipelineState;
         for (let i = 0; i < 7; i++) {
             const [out, next] = pipelineStep(0n, s);
-            if (out !== undefined)
-                throw out;
+            assertEq(out, undefined);
             s = next;
         }
         // 8th zero emits L3 symbol 0
         const [out0, s2] = pipelineStep(0n, s);
-        if (out0 !== 0n)
-            throw out0;
+        assertEq(out0, 0n);
         // state resets after emit: second batch of 8 zeros also emits 0
         let s3 = s2;
         for (let i = 0; i < 7; i++) {
@@ -713,8 +701,7 @@ export const proof = {
             s3 = next;
         }
         const [out1] = pipelineStep(0n, s3);
-        if (out1 !== 0n)
-            throw out1;
+        assertEq(out1, 0n);
         // 8 ones emit a different symbol than 8 zeros
         let s4 = emptyPipelineState;
         for (let i = 0; i < 7; i++) {
@@ -722,7 +709,6 @@ export const proof = {
             s4 = next;
         }
         const [out2] = pipelineStep(1n, s4);
-        if (out2 === 0n)
-            throw out2;
+        assert(out2 !== 0n, out2);
     }
 };

package/fjs/text/ascii/proof.f.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    range: () => void;
+    throw: {
+        oneThrowsOnEmpty: () => number;
+    };
+};

package/{fs → fjs}/text/ascii/proof.f.js

@@ -1,24 +1,14 @@
 import { one, range } from './module.f.js';
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../../types/object/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     range: () => {
         const r = stringify(range("A"));
-        if (r !== '[65,65]') {
-            throw r;
-        }
+        assertEq(r, '[65,65]');
     },
-    oneThrowsOnEmpty: () => {
-        let threw = false;
-        try {
-            one('');
-        }
-        catch (_) {
-            threw = true;
-        }
-        if (!threw) {
-            throw 'expected throw';
-        }
+    throw: {
+        oneThrowsOnEmpty: () => one(''),
     },
 };

package/{fs → fjs}/text/code_point/module.f.js

@@ -48,18 +48,18 @@ const maxCodePoint = 0x10_ffff;
  * Checks whether the 16-bit word (U16) is a high surrogate.
  * Range: 0xD800 - 0xDBFF.
  */
-export const isHighSurrogate = contains([surrogateMin, lowSurrogateMin - 1]);
+export const isHighSurrogate = contains(surrogateMin, lowSurrogateMin - 1);
 /**
  * Checks whether the 16-bit word (U16) is a low surrogate.
  * Range: 0xDC00 - 0xDFFF.
  */
-export const isLowSurrogate = contains([lowSurrogateMin, surrogateMax]);
+export const isLowSurrogate = contains(lowSurrogateMin, surrogateMax);
 /**
  * Ranges of code points for the lower (Low) and higher (High) parts of the BMP
  * (Basic Multilingual Plane), i.e. the BMP with the surrogate block removed.
  */
-const lowBmp = contains([0x0000, surrogateMin - 1]);
-const highBmp = contains([surrogateMax + 1, bmpMax]);
+const lowBmp = contains(0x0000, surrogateMin - 1);
+const highBmp = contains(surrogateMax + 1, bmpMax);
 /**
  * Checks whether the code point is in the BMP range.
  * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
@@ -70,13 +70,13 @@ export const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePo
  * Checks whether the code point belongs to a supplementary (additional) Unicode
  * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
  */
-export const isSupplementaryPlane = contains([bmpMax + 1, maxCodePoint]);
+export const isSupplementaryPlane = contains(bmpMax + 1, maxCodePoint);
 /**
  * The full assignable code-point range and the surrogate block, used to gate
  * overall validity below.
  */
-const validRange = contains([0, maxCodePoint]);
-const isSurrogate = contains([surrogateMin, surrogateMax]);
+const validRange = contains(0, maxCodePoint);
+const isSurrogate = contains(surrogateMin, surrogateMax);
 /**
  * Checks whether the code point is a valid scalar value: within the assignable
  * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
@@ -89,9 +89,9 @@ export const isValidCodePoint = (c) => validRange(c) && !isSurrogate(c);
  * contiguous run; the whitespace block 0x0009 - 0x000D (TAB, LF, VT, FF, CR) is
  * the only control range legitimate in text.
  */
-const c0Control = contains([0x00, 0x1f]);
-const delAndC1Control = contains([0x7f, 0x9f]);
-const textWhitespace = contains([0x09, 0x0d]);
+const c0Control = contains(0x00, 0x1f);
+const delAndC1Control = contains(0x7f, 0x9f);
+const textWhitespace = contains(0x09, 0x0d);
 /**
  * Checks whether the code point is a *text* code point — distinct from
  * {@link isValidCodePoint}, which gates well-formedness for decoding. A code

package/{fs → fjs}/text/proof.f.js

@@ -1,4 +1,4 @@
-import { assert, assertEq } from '../asserts/module.f.js';
+import { assertEq, assertNotNullish } from '../asserts/module.f.js';
 import { flat, utf8, utf8ToString, tryUtf8 } from './module.f.js';
 import { join } from '../types/string/module.f.js';
 import { empty, maxLengthBytes } from '../types/bit_vec/module.f.js';
@@ -15,20 +15,15 @@ export const proof = {
             'e',
         ];
         const result = join('\n')(flat(':')(text));
-        if (result !== 'a\nb\n:c\n::d\ne') {
-            throw result;
-        }
+        assertEq(result, 'a\nb\n:c\n::d\ne');
     },
     encoding: () => {
         const v = utf8('Hello world!');
         const r = utf8ToString(v);
-        if (r !== 'Hello world!') {
-            throw r;
-        }
+        assertEq(r, 'Hello world!');
     },
     tryUtf8RoundTrip: () => {
-        const v = tryUtf8('Hello world!');
-        assert(v !== null);
+        const v = assertNotNullish(tryUtf8('Hello world!'));
         assertEq(v, utf8('Hello world!'));
         assertEq(utf8ToString(v), 'Hello world!');
     },

package/{fs → fjs}/text/sgr/proof.f.js

@@ -1,42 +1,33 @@
 import { fgRed, reset, createConsoleText, backspace, csiWrite } from './module.f.js';
 import { virtual, emptyState, defaultNodeProgramOptions } from '../../effects/node/virtual/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const makeOptions = (isTTY) => ({ ...defaultNodeProgramOptions, std: { stdout: { isTTY }, stderr: { isTTY } } });
 export const proof = [
     () => {
-        if (fgRed !== '\x1b[31m') {
-            throw new Error('Test failed: sgr(0)');
-        }
+        assertEq(fgRed, '\x1b[31m', new Error('Test failed: sgr(0)'));
     },
     () => {
         const output = [];
         const stdout = { write: (s) => { output.push(s); } };
         const writer1 = createConsoleText(stdout);
         const writer2 = writer1('hello');
-        if (output[0] !== 'hello') {
-            throw output[0];
-        }
+        assert(output[0] === 'hello');
         // replacing 'hello' (len=5) with 'hi' (len=2): suffixLength=3
         writer2('hi');
         const expected = backspace.repeat(5) + 'hi' + ' '.repeat(3) + backspace.repeat(3);
-        if (output[1] !== expected) {
-            throw output[1];
-        }
+        assertEq(output[1], expected);
     },
     () => {
         // csiWrite with isTTY=false strips ANSI SGR sequences
         const writeFn = csiWrite(makeOptions(false))('stdout');
         const [state] = virtual(emptyState)(writeFn(fgRed + 'hello' + reset));
-        if (state.stdout !== 'hello') {
-            throw ['expected ANSI stripped', state.stdout];
-        }
+        assertEq(state.stdout, 'hello', ['expected ANSI stripped', state.stdout]);
     },
     () => {
         // csiWrite with isTTY=true preserves ANSI SGR sequences
         const writeFn = csiWrite(makeOptions(true))('stdout');
         const [state] = virtual(emptyState)(writeFn(fgRed + 'hello' + reset));
         const expected = fgRed + 'hello' + reset;
-        if (state.stdout !== expected) {
-            throw ['expected ANSI preserved', state.stdout];
-        }
+        assertEq(state.stdout, expected, ['expected ANSI preserved', state.stdout]);
     },
 ];

package/{fs → fjs}/text/utf16/module.f.js

@@ -107,7 +107,7 @@ export const fromCodePointList = flatMap(codePointToUtf16);
  * const edgeCaseHigh = u16(0xFFFF)  // true: Maximum valid value for UTF-16
  * ```
  */
-const u16 = contains([0x0000, 0xFFFF]);
+const u16 = contains(0x0000, 0xFFFF);
 /**
  * A stateful operation that converts a UTF-16 word (U16) to a list of Unicode code points (CodePoint),
  * while maintaining the state of surrogate pair decoding.