functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/effects/node/virtual/proof.f.js

@@ -1,30 +1,30 @@
-import { assertEq } from "../../../asserts/module.f.js";
-import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes } from "../module.f.js";
-import { maxLengthBytes, vec, vec8 } from "../../../types/bit_vec/module.f.js";
-import { emptyState, virtual } from "./module.f.js";
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { access, awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes, writeBytes } from '../module.f.js';
+import { maxLengthBytes, vec, vec8 } from '../../../types/bit_vec/module.f.js';
+import { emptyState, virtual } from './module.f.js';
 export const proof = {
     rm: {
         success: () => {
             const root = { 'a.txt': [vec8(0x42n)] };
             const [, result] = virtual({ ...emptyState, root })(rm('a.txt'));
-            assertEq(result[0], 'ok');
+            assert(result[0] === 'ok');
         },
         notFound: () => {
             const [, result] = virtual(emptyState)(rm('notexist.txt'));
-            assertEq(result[0], 'error');
+            assert(result[0] === 'error');
         },
         isDirectory: () => {
             const inner = {};
             const root = { 'mydir': inner };
             const [, result] = virtual({ ...emptyState, root })(rm('mydir'));
-            assertEq(result[0], 'error');
+            assert(result[0] === 'error');
         },
     },
     writeFileOnDirectory: () => {
         const inner = {};
         const root = { 'mydir': inner };
         const [, result] = virtual({ ...emptyState, root })(writeFile('mydir', vec8(0x42n)));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readdirRecursive: () => {
         const file = [vec8(0x42n)];
@@ -32,12 +32,19 @@ export const proof = {
         const outer = { 'sub': sub };
         const root = { 'mydir': outer };
         const [, result] = virtual({ ...emptyState, root })(readdir('mydir', { recursive: true }));
-        assertEq(result[0], 'ok');
-        if (result[0] !== 'ok') {
-            throw result;
-        }
+        assert(result[0] === 'ok');
+        assert(result[0] === 'ok', result);
         assertEq(result[1].length, 2);
     },
+    accessNestedPathThroughFile: () => {
+        // 'a/b/c' where 'a' is a file: the operation wrapper's "not a directory"
+        // fallback passes the full remaining path through unchanged, covering the
+        // path.length !== 1 branch of the access op (only path.length === 0 was
+        // otherwise exercised).
+        const root = { 'a': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(access('a/b/c'));
+        assert(result[0] === 'error');
+    },
     readFileIntoDir: () => {
         // 'a/b' where both 'a' and 'b' are directories
         // hits path.length === 0 in operation's f and path.length !== 1 in readFile op
@@ -45,7 +52,7 @@ export const proof = {
         const outer = { 'b': inner };
         const root = { 'a': outer };
         const [, result] = virtual({ ...emptyState, root })(readFile('a/b'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     awaitNonPromise: () => {
         // a non-promise value passes through the virtual `await` handler as-is
@@ -55,19 +62,19 @@ export const proof = {
     fetchNotFound: () => {
         // covers the `result === undefined` branch of the `fetch` handler
         const [, result] = virtual(emptyState)(fetch('https://example.com/missing'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     importNestedPath: () => {
         // import_ on a path whose parent does not exist covers the
         // path.length !== 1 branch of the import_ op
         const [, result] = virtual(emptyState)(import_('a/b'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     importNonModule: () => {
         // import_ on a Vec (not a JsModule) covers typeof entry !== 'function' branch
         const root = { 'module.f.ts': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(import_('module.f.ts'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     throw: {
         readFileOnJsModule: () => {
@@ -80,37 +87,37 @@ export const proof = {
         // rename('a', 'a') should succeed as a no-op, not reject
         const root = { 'a': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a'));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     renameIntoOwnSubtree: () => {
         // rename('a', 'a/b') should fail (dst inside src's subtree)
         const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a', 'a/b'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameOntoOwnAncestor: () => {
         // rename('a/b', 'a') should fail (src inside dst's subtree)
         const root = { 'a': { 'b': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('a/b', 'a'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameNonEmptyDirOverEmptyDir: () => {
         // rename a directory onto an empty directory should succeed
         const root = { 'src': { 'file': [vec8(0x42n)] }, 'dst': {} };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     renameEmptyDirOverNonEmptyDir: () => {
         // rename an empty directory onto a non-empty directory should fail
         const root = { 'src': {}, 'dst': { 'file': [vec8(0x42n)] } };
         const [, result] = virtual({ ...emptyState, root })(rename('src', 'dst'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     renameFileOntoDirectory: () => {
         // rename a file to a path that is already an existing directory should fail
         const root = { 'myfile': [vec8(0x42n)], 'mydir': {} };
         const [, result] = virtual({ ...emptyState, root })(rename('myfile', 'mydir'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readFileTooLarge: () => {
         // a file stored as two max-size chunks exceeds the limit; readFile must return an error
@@ -118,37 +125,37 @@ export const proof = {
         const chunk1 = vec(1n)(1n);
         const root = { 'big': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readFile('big'));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesNegativeSize: () => {
         // readBytes with negative size should fail
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, -1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesZeroSize: () => {
         // readBytes with zero size should succeed and return empty vec
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 0));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
     readBytesNegativeOffset: () => {
         // readBytes with negative offset should fail
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', -1, 1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesFractionalSize: () => {
         // readBytes with fractional size should fail rather than throw RangeError
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0, 1.5));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesFractionalOffset: () => {
         // readBytes with fractional offset should fail rather than throw RangeError
         const root = { 'file': [vec8(0x42n)] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('file', 0.5, 1));
-        assertEq(result[0], 'error');
+        assert(result[0] === 'error');
     },
     readBytesAcrossChunkBoundary: () => {
         // Two 128 KiB chunks; read 2 bytes spanning the boundary (last byte of chunk 0, first of chunk 1).
@@ -157,7 +164,14 @@ export const proof = {
         const chunk1 = vec(maxLengthBytes * 8n)(0xbbn);
         const root = { 'big': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('big', chunkSize - 1, 2));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
+    },
+    writeBytesWrongOffset: () => {
+        // writeBytes is append-only; an offset that doesn't match the current
+        // file size must fail rather than silently create a hole.
+        const root = { 'file': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(writeBytes('file', 5, vec8(0x43n)));
+        assert(result[0] === 'error');
     },
     largeFileReadBytes: () => {
         // A file stored as two 128 KiB chunks is larger than maxLengthBytes.
@@ -167,6 +181,6 @@ export const proof = {
         const chunk1 = vec(maxLengthBytes * 8n)(0xffn);
         const root = { 'large': [chunk0, chunk1] };
         const [, result] = virtual({ ...emptyState, root })(readBytes('large', chunkSize, 1));
-        assertEq(result[0], 'ok');
+        assert(result[0] === 'ok');
     },
 };

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

@@ -1,13 +1,10 @@
-import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } from "./module.f.js";
-import { error, ok } from "../types/result/module.f.js";
+import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } from './module.f.js';
+import { error, ok } from '../types/result/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
 const assertPure = (e, expected) => {
     const d = decode(e);
-    if (!d.done) {
-        throw e.value;
-    }
-    if (d.result !== expected) {
-        throw d.result;
-    }
+    assert(d.done, e.value);
+    assertEq(d.result, expected);
 };
 const next = match({ add: (a, b) => a + b });
 export const proof = {
@@ -19,13 +16,9 @@ export const proof = {
             // The thunk runs only when the effect is decoded, not when `lazy` is called.
             let evaluated = false;
             const e = lazy(() => { evaluated = true; return 7; });
-            if (evaluated) {
-                throw 'lazy must not evaluate eagerly';
-            }
+            assert(!(evaluated), 'lazy must not evaluate eagerly');
             assertPure(e, 7);
-            if (!evaluated) {
-                throw 'decode must force the thunk';
-            }
+            assert(evaluated, 'decode must force the thunk');
         },
         step: () => {
             const e = lazy(() => 5).step(v => pure(v * 2));
@@ -60,56 +53,34 @@ export const proof = {
         ok: () => {
             const e = pure(ok(5)).step(okStep((v) => pure(ok(v * 2))));
             const d = decode(e);
-            if (!d.done || d.result[0] !== 'ok' || d.result[1] !== 10) {
-                throw e.value;
-            }
+            assert(!(!d.done || d.result[0] !== 'ok' || d.result[1] !== 10), e.value);
         },
         error: () => {
             const e = pure(error('oops')).step(okStep(v => pure(ok(v * 2))));
             const d = decode(e);
-            if (!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops') {
-                throw e.value;
-            }
+            assert(!(!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops'), e.value);
         },
     },
     decode: () => {
         const d = decode(do_('add')(2, 3));
-        if (d.done) {
-            throw d;
-        }
-        if (d.command !== 'add') {
-            throw d.command;
-        }
-        if (d.payload[0] !== 2 || d.payload[1] !== 3) {
-            throw d.payload;
-        }
+        assert(!(d.done), d);
+        assertEq(d.command, 'add');
+        assert(!(d.payload[0] !== 2 || d.payload[1] !== 3), d.payload);
         assertPure(d.continuation(5), 5);
     },
     match: {
         done: () => {
             const r = next(pure(7));
-            if (r[0] !== 'done') {
-                throw r;
-            }
-            if (r[1] !== 7) {
-                throw r[1];
-            }
+            assert(r[0] === 'done', r);
+            assertEq(r[1], 7);
         },
         cont: () => {
             const r = next(do_('add')(2, 3));
-            if (r[0] !== 'cont') {
-                throw r;
-            }
-            if (r[1] !== 5) {
-                throw r[1];
-            }
+            assert(r[0] === 'cont', r);
+            assertEq(r[1], 5);
             const r2 = next(r[2](r[1]));
-            if (r2[0] !== 'done') {
-                throw r2;
-            }
-            if (r2[1] !== 5) {
-                throw r2[1];
-            }
+            assert(r2[0] === 'done', r2);
+            assertEq(r2[1], 5);
         },
     },
 };

package/fjs/emergent_testing/all.test.js

@@ -0,0 +1,4 @@
+import { runEffect } from '../effects/node/module.js';
+import { register } from './module.f.js';
+// we need `await` for Playwright.
+await runEffect(register);

package/{fs → fjs}/emergent_testing/example.f.d.ts

@@ -6,7 +6,7 @@ export declare const proof: {
     addTest: () => void;
     mulTest: (() => void)[];
     throw: {
-        todo: () => never;
+        todo: typeof todo;
         divByZero: () => bigint;
     };
     generateSqrTests: () => (() => void)[];

package/{fs → fjs}/emergent_testing/module.f.js

@@ -10,12 +10,12 @@
  *
  * @module
  */
-import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/module.f.js";
-import { all, awaitIfPromise, sandbox, test } from "../effects/node/module.f.js";
-import { pure } from "../effects/module.f.js";
-import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
-import { invert } from "../types/result/module.f.js";
-import { definedEntries } from "../types/object/module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from '../text/sgr/module.f.js';
+import { all, awaitIfPromise, sandbox, test } from '../effects/node/module.f.js';
+import { pure } from '../effects/module.f.js';
+import { loadModuleMap, shouldLoad } from '../dev/module.f.js';
+import { invert } from '../types/result/module.f.js';
+import { definedEntries } from '../types/object/module.f.js';
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {

package/{fs → fjs}/emergent_testing/proof.f.d.ts

@@ -27,24 +27,25 @@ export declare const helpers: {
         functionWithParamsReturnsEmpty: () => void;
     };
 };
+declare const defaultReporterExpectedToThrow: () => void;
 export declare const proof: {
-    flat: () => void;
-    nested: () => void;
-    throwKey: () => void;
-    throwKeyFail: () => void;
-    mixedPassFail: () => void;
-    returnValueSubTree: () => void;
-    arrayKeys: () => void;
-    nonTestFilesSkipped: () => void;
-    multipleFiles: () => void;
-    throwByFunctionName: () => void;
-    namedExports: () => void;
-    defaultReporterOutput: () => void;
-    defaultReporterOutputLargeDuration: () => void;
-    defaultReporterFailOutput: () => void;
-    githubReporterOutput: () => void;
-    registerSuffixes: () => void;
-    defaultReporterExpectedToThrow: () => void;
+    flat: typeof flat;
+    nested: typeof nested;
+    throwKey: typeof throwKey;
+    throwKeyFail: typeof throwKeyFail;
+    mixedPassFail: typeof mixedPassFail;
+    returnValueSubTree: typeof returnValueSubTree;
+    arrayKeys: typeof arrayKeys;
+    nonTestFilesSkipped: typeof nonTestFilesSkipped;
+    multipleFiles: typeof multipleFiles;
+    throwByFunctionName: typeof throwByFunctionName;
+    namedExports: typeof namedExports;
+    defaultReporterOutput: typeof defaultReporterOutput;
+    defaultReporterOutputLargeDuration: typeof defaultReporterOutputLargeDuration;
+    defaultReporterFailOutput: typeof defaultReporterFailOutput;
+    githubReporterOutput: typeof githubReporterOutput;
+    registerSuffixes: typeof registerSuffixes;
+    defaultReporterExpectedToThrow: typeof defaultReporterExpectedToThrow;
     helpers: {
         isInteger: () => void;
         isIdentifier: () => void;
@@ -59,3 +60,4 @@ export declare const proof: {
         };
     };
 };
+export {};

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

@@ -1,10 +1,10 @@
-import { log } from "../effects/node/module.f.js";
-import { defaultNodeProgramOptions, emptyState } from "../effects/node/virtual/module.f.js";
-import { virtual } from "../effects/node/virtual/module.f.js";
-import { assert, assertEq } from "../asserts/module.f.js";
-import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from "./module.f.js";
-import { run as mockRun } from "../effects/mock/module.f.js";
-import { shouldLoad } from "../dev/module.f.js";
+import { log } from '../effects/node/module.f.js';
+import { defaultNodeProgramOptions, emptyState } from '../effects/node/virtual/module.f.js';
+import { virtual } from '../effects/node/virtual/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
+import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from './module.f.js';
+import { run as mockRun } from '../effects/mock/module.f.js';
+import { shouldLoad } from '../dev/module.f.js';
 const writeEvent = (event) => log(JSON.stringify(event));
 const parseEvents = (stdout) => stdout === '' ? [] : stdout.trimEnd().split('\n').map(line => JSON.parse(line));
 const makeReporter = () => ({
@@ -42,7 +42,7 @@ export const flat = () => {
     const [e0, e1, e2] = events;
     assert(e0[0] === 'result' && e0[2][0] === 'a');
     assert(e1[0] === 'result' && e1[2][0] === 'b');
-    assertEq(e2[0], 'summary');
+    assert(e2[0] === 'summary');
     const [, pass, fail] = e2;
     assertEq(pass, 2);
     assertEq(fail, 0);
@@ -56,7 +56,7 @@ export const nested = () => {
     const [e0, e1, e2] = events;
     assert(e0[0] === 'result' && e0[2][1] === 'add');
     assert(e1[0] === 'result' && e1[2][1] === 'sub');
-    assertEq(e2[0], 'summary');
+    assert(e2[0] === 'summary');
     const [, pass, fail] = e2;
     assertEq(pass, 2);
     assertEq(fail, 0);
@@ -69,7 +69,7 @@ export const throwKey = () => {
     assertEq(exit, 0);
     const [e0, e1] = events;
     assert(e0[0] === 'result' && e0[2][0] === 'throw' && e0[2][1] === 'a');
-    assertEq(e1[0], 'summary');
+    assert(e1[0] === 'summary');
     const [, pass, fail] = e1;
     assertEq(pass, 1);
     assertEq(fail, 0);
@@ -81,7 +81,7 @@ export const throwKeyFail = () => {
     });
     assertEq(exit, 1);
     const [e0, e1] = events;
-    assertEq(e0[0], 'result');
+    assert(e0[0] === 'result');
     const [, pass, fail] = e1;
     assertEq(pass, 0);
     assertEq(fail, 1);
@@ -93,7 +93,7 @@ export const mixedPassFail = () => {
     });
     assertEq(exit, 1);
     const summary = events[events.length - 1];
-    assertEq(summary[0], 'summary');
+    assert(summary[0] === 'summary');
     const [, pass, fail] = summary;
     assertEq(pass, 1);
     assertEq(fail, 1);
@@ -245,12 +245,12 @@ export const registerSuffixes = () => {
     // Node (star = ''): no suffixes
     const [nodeNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ''));
     assertEq(nodeNames.length, 2);
-    assertEq(nodeNames[0], 'import("./a.f.ts").proof.ok()');
+    assert(nodeNames[0] === 'import("./a.f.ts").proof.ok()');
     assertEq(nodeNames[1], 'import("./a.f.ts").proof.throw.a()');
     // Bun/Playwright (star = ' ...'): ... on normal tests, path shows throw for throw-tests
     const [inlineNames] = runner([])(registerModule(noopCtx, './a.f.ts', proof, ' ...'));
     assertEq(inlineNames.length, 2);
-    assertEq(inlineNames[0], 'import("./a.f.ts").proof.ok() ...');
+    assert(inlineNames[0] === 'import("./a.f.ts").proof.ok() ...');
     assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()');
 };
 // direct unit tests for the pure path-format helpers

package/fjs/emergent_testing/scenarios/all.js

@@ -0,0 +1 @@
+import '../all.test.js';

package/{fs → fjs}/fsc/bnf.f.js

@@ -1,5 +1,5 @@
-import { range, remove, set, option } from "../bnf/module.f.js";
-import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from "./json.f.js";
+import { range, remove, set, option } from '../bnf/module.f.js';
+import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from './json.f.js';
 export const wsModule = () => [ws0, module];
 const module = () => ({
     json: [json, ws0],

package/{fs → fjs}/fsc/json.f.js

@@ -1,4 +1,4 @@
-import { join0Plus, rangeEncode, range, remove, repeat0Plus, set, option } from "../bnf/module.f.js";
+import { join0Plus, rangeEncode, range, remove, repeat0Plus, set, option } from '../bnf/module.f.js';
 // space
 const wsNoNewLineItem = set(' \t\r');
 export const wsNoNewLine0 = repeat0Plus(wsNoNewLineItem);

package/{fs → fjs}/fsc/module.f.js

@@ -3,13 +3,13 @@
  *
  * @module
  */
-import { strictEqual } from "../types/function/operator/module.f.js";
-import { merge as rangeMapMerge, fromRange, get, } from "../types/range_map/module.f.js";
-import { reduce as listReduce, toArray, map } from "../types/list/module.f.js";
-import { range as asciiRange } from "../text/ascii/module.f.js";
-import { fn } from "../types/function/module.f.js";
-import { one } from "../types/range/module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { strictEqual } from '../types/function/operator/module.f.js';
+import { merge as rangeMapMerge, fromRange, get, } from '../types/range_map/module.f.js';
+import { reduce as listReduce, toArray, map } from '../types/list/module.f.js';
+import { range as asciiRange } from '../text/ascii/module.f.js';
+import { fn } from '../types/function/module.f.js';
+import { one } from '../types/range/module.f.js';
+import { assertEq } from '../asserts/module.f.js';
 const fromCharCode = String.fromCharCode;
 const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol];
 const def = () => unexpectedSymbol;

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

@@ -1,7 +1,7 @@
-import { init, terminal } from "./module.f.js";
-import { one } from "../text/ascii/module.f.js";
-import { stringify } from "../json/module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { init, terminal } from './module.f.js';
+import { one } from '../text/ascii/module.f.js';
+import { stringify } from '../media/json/module.f.js';
+import { assertEq } from '../asserts/module.f.js';
 const s = stringify(i => i);
 const f = v => {
     const n = one(v);
@@ -15,24 +15,18 @@ Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
 export const proof = {
     a: () => {
         const x = f('1');
-        if (x !== '["1"]') {
-            throw x;
-        }
+        assertEq(x, '["1"]');
     },
     b: () => {
         // exercises toInit: terminal returns empty output and loops back to init
         const result = init(terminal);
-        if (result[0].length !== 0) {
-            throw result[0];
-        }
+        assertEq(result[0].length, 0, result[0]);
     },
     c: () => {
         // exercises unexpectedSymbol: next state after a token returns an error message
         const next = init(one('1'))[1];
         const result = next(42);
-        if (result[0][0] !== 'unexpected symbol 42') {
-            throw result[0][0];
-        }
+        assertEq(result[0][0], 'unexpected symbol 42');
     },
     fn: () => {
         const o = {
@@ -40,58 +34,42 @@ export const proof = {
         };
         const f = o["hello world!"];
         const { name } = f;
-        if (name !== "hello world!") {
-            throw name;
-        }
+        assertEq(name, "hello world!");
         //
         const f1 = { ["boring"]: () => undefined }["boring"];
-        if (f1.name !== "boring") {
-            throw f1.name;
-        }
+        assertEq(f1.name, "boring");
         //
         const x = fn(() => undefined, "hello").name;
-        if (x !== "") {
-            throw x;
-        }
+        assertEq(x, "");
         //
         const m = withName("boring2").name;
-        if (m !== "boring2") {
-            throw m;
-        }
+        assertEq(m, "boring2");
         //
         const a = function x() { return undefined; };
-        if (a.name !== "x") {
-            throw a.name;
-        }
+        assertEq(a.name, "x");
     },
     //
     f1: () => {
         const m1 = () => undefined;
-        if (m1.name !== "m1") {
-            throw m1.name;
-        }
+        assertEq(m1.name, "m1");
     },
     //
     f2: () => {
         const m11 = (() => undefined);
-        if (m11.name !== "m11") {
-            throw m11.name;
-        }
+        assertEq(m11.name, "m11");
     },
     //
     f3: () => {
         const m2 = true ? () => undefined : () => undefined;
         // for `bun` it is `m2`:
-        // if (m2.name !== "") { throw m2.name }
+        // assertEq(m2.name, "")
         // see also https://github.com/oven-sh/bun/issues/20398
     },
     f4: () => {
         const id = (i) => i;
         const f = id(() => undefined);
         // for `bun` it is `m2`:
-        if (f.name !== "") {
-            throw f.name;
-        }
+        assertEq(f.name, "");
     },
     chars: {
         whitespace: () => {

package/{fs → fjs}/fsm/module.f.js

@@ -3,15 +3,15 @@
  *
  * @module
  */
-import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from "../types/list/module.f.js";
-import { toRangeMap, union as byteSetUnion, one, empty, range } from "../types/byte_set/module.f.js";
-import { intersect, union as sortedSetUnion } from "../types/sorted_set/module.f.js";
-import { merge, get as rangeMapGet } from "../types/range_map/module.f.js";
-import { strictEqual } from "../types/function/operator/module.f.js";
-import { stringify } from "../json/module.f.js";
-import { identity } from "../types/function/module.f.js";
-import { stringToList } from "../text/utf16/module.f.js";
-import { cmp } from "../types/string/module.f.js";
+import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from '../types/list/module.f.js';
+import { toRangeMap, union as byteSetUnion, one, empty, range } from '../types/byte_set/module.f.js';
+import { intersect, union as sortedSetUnion } from '../types/sorted_set/module.f.js';
+import { merge, get as rangeMapGet } from '../types/range_map/module.f.js';
+import { strictEqual } from '../types/function/operator/module.f.js';
+import { stringify } from '../media/json/module.f.js';
+import { identity } from '../types/function/module.f.js';
+import { stringToList } from '../text/utf16/module.f.js';
+import { cmp } from '../types/string/module.f.js';
 const stringifyIdentity = stringify(identity);
 export const toRange = s => {
     const [b, e] = toArray(stringToList(s));