functionalscript 0.29.1 → 0.31.0

package/fs/ci/proof.f.js

@@ -1,12 +1,14 @@
 import { ci, main } from "./module.f.js";
+import { functionalscript } from "./config/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { empty as emptyVec, isVec } from "../types/bit_vec/module.f.js";
-import { test, parseGitHubAction } from "./common/module.f.js";
+import { test, ubuntu, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
 import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
+import { definedValues } from "../types/object/module.f.js";
+const hasRun = (cmd) => (gha) => definedValues(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
 const makeState = (rust, packageJson) => ({
     ...emptyState,
@@ -26,7 +28,7 @@ const workflow = (state) => {
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
 };
 const run = (rust, nodeExtra = () => []) => {
-    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra, denoExtra: [], bunExtra: [] }));
+    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));
     assert(result === 0, result);
     return workflow(state);
 };
@@ -36,6 +38,41 @@ const runDefault = (packageJson) => {
     return workflow(state);
 };
 export const proof = {
+    matrixShape: () => {
+        const gha = run(true);
+        assert(Object.keys(gha.jobs).length === 13, 'expected 13 CI jobs');
+        assert(gha.permissions.contents === 'read', 'expected read-only contents permission');
+        assert(Object.keys(gha.permissions).length === 1, 'expected least-privilege workflow permissions');
+        assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu')(gha), 'expected Ubuntu Intel i686 check');
+        assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu --release')(gha), 'expected Ubuntu Intel i686 release check');
+        assert(hasRunInJob('ubuntu-intel', 'cargo clippy --target i686-unknown-linux-gnu -- -D warnings')(gha), 'expected Ubuntu Intel i686 lint');
+        assert(hasRunInJob('ubuntu-intel', 'cargo clippy --target i686-unknown-linux-gnu --release -- -D warnings')(gha), 'expected Ubuntu Intel i686 release lint');
+        assert(hasRunInJob('ubuntu-arm', 'cargo test --release')(gha), 'expected native platform Rust release check');
+        assert(hasRunInJob('ubuntu-arm', 'cargo clippy -- -D warnings')(gha), 'expected native platform Rust lint');
+        assert(hasRunInJob('ubuntu-arm', 'cargo clippy --release -- -D warnings')(gha), 'expected native platform Rust release lint');
+        assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1 --release')(gha), 'expected target-specific WASM release check');
+        assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 -- -D warnings')(gha), 'expected target-specific WASM Rust lint');
+        assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 --release -- -D warnings')(gha), 'expected target-specific WASM release lint');
+        assert(hasRunInJob('node22', 'fjs t')(gha), 'expected Node 22 FunctionalScript smoke test');
+        assert(hasRunInJob('node26', 'npm pack')(gha), 'expected Node 26 package check');
+        assert(!hasRun('npm publish --dry-run')(gha), 'unexpected npm publish dry-run');
+        for (const id of [
+            'ubuntu-intel',
+            'ubuntu-arm',
+            'macos-intel',
+            'macos-arm',
+            'windows-intel',
+            'windows-arm',
+            'node22',
+            'node24',
+            'node26',
+            'playwright',
+        ]) {
+            assert(hasRunInJob(id, 'npm ci')(gha), `expected npm ci in ${id}`);
+        }
+        assert(!hasRunInJob('deno', 'npm ci')(gha), 'unexpected npm ci in deno job');
+        assert(!hasRunInJob('bun', 'npm ci')(gha), 'unexpected npm ci in bun job');
+    },
     rust: () => {
         assert(hasRun('cargo')(run(true)), 'expected Rust steps');
     },
@@ -62,46 +99,36 @@ export const proof = {
         },
     },
     defaultSetup: {
-        functionalscriptDemo: () => {
+        functionalscriptPackage: () => {
             const gha = runDefault('{"name":"functionalscript"}');
-            assert(hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'expected fjs demo compile');
             assert(hasRun('fjs t')(gha), 'expected fjs self-test');
-            assert(hasRun('deno task fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'expected deno demo compile');
-            assert(hasRun('deno task fjs t')(gha), 'expected deno self-test');
-            assert(hasRun('bun ./fs/fjs/module.ts t')(gha), 'expected bun self-test');
-        },
-        otherPackageNoDemo: () => {
-            const gha = runDefault('{"name":"other-package"}');
-            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
-            assert(!hasRun('fjs t')(gha), 'unexpected fjs self-test');
-            assert(!hasRun('deno task fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected deno demo compile');
-            assert(!hasRun('deno task fjs t')(gha), 'unexpected deno self-test');
-            assert(!hasRun('bun ./fs/fjs/module.ts t')(gha), 'unexpected bun self-test');
+            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected deno self-test');
+            assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected bun self-test');
         },
-        uninstallPackageName: () => {
+        otherPackage: () => {
             const gha = runDefault('{"name":"other-package"}');
-            assert(hasRun('npm uninstall other-package -g')(gha), 'expected package-specific uninstall');
-            assert(!hasRun('npm uninstall functionalscript -g')(gha), 'unexpected functionalscript uninstall');
+            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected canonical deno self-test');
+            assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected canonical bun self-test');
         },
-        malformedPackageJsonFallback: () => {
-            const gha = runDefault('{');
-            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
-            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+        configuredPackageVersion: () => {
+            const gha = runDefault('{"name":"other-package","version":"1.2.3"}');
+            assert(hasRun(`npm install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version platform install');
+            assert(hasRun(`deno install -g -A npm:functionalscript@${functionalscript}`)(gha), 'expected configured-version deno install cache');
+            assert(hasRun('deno install --frozen')(gha), 'expected deno lock install');
+            assert(hasRun(`deno run -A npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
+            assert(hasRun("deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='.*module\\.f\\.ts'")(gha), 'expected limited-permission deno coverage');
+            assert(hasRun(`bun install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version bun cache');
+            assert(hasRun('bun install --frozen-lockfile')(gha), 'expected bun lock install');
+            assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected configured-version bun install');
         },
-        missingPackageJsonFallback: () => {
+        missingPackageJson: () => {
             const gha = runDefault();
-            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
-            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
-        },
-        missingNameFallback: () => {
-            const gha = runDefault('{"version":"1.0.0"}');
-            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
-            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
-        },
-        nonObjectFallback: () => {
-            const gha = runDefault('[]');
-            assert(!hasRun('fjs compile issues/demo/data/tree.json _tree.f.js')(gha), 'unexpected fjs demo compile');
-            assert(hasRun('npm uninstall functionalscript -g')(gha), 'expected fallback uninstall');
+            assert(hasRun(`npm install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version install');
         },
     },
+    ubuntu: () => {
+        const job = ubuntu([test({ run: 'echo hi' })]);
+        assert(job['runs-on'] !== undefined, 'expected runs-on');
+        assert(job.steps.length > 0, 'expected steps');
+    },
 };

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

@@ -1,2 +1,3 @@
 import { type Architecture, type MetaStep, type Os } from '../common/module.f.ts';
-export declare const rustSteps: (v: Os, a: Architecture) => readonly MetaStep[];
+export declare const rustPlatformSteps: (v: Os, a: Architecture) => readonly MetaStep[];
+export declare const rustWasmSteps: readonly MetaStep[];

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

@@ -1,50 +1,67 @@
 /**
- * CI step builder for the Rust crate: `cargo fmt`, `cargo clippy`, native and
- * `--release` test runs, plus matrix entries for WASM targets (Wasmtime,
- * Wasmer) and the 32-bit `i686` targets.
+ * CI step builder for the Rust crate: platform compatibility jobs run native
+ * tests and Clippy, Intel jobs also run 32-bit target tests and Clippy, and the
+ * canonical WASM job installs Wasmtime and Wasmer before exercising every WASM
+ * target.
  *
  * @module
  */
 import { wasmer, wasmtime } from "../config/module.f.js";
 import { install, test, uses } from "../common/module.f.js";
-const cargoTest = (target, config) => {
+const cargoCommand = (tool, target, config) => {
     const to = target ? ` --target ${target}` : '';
     const co = config ? ` --config ${config}` : '';
-    const main = `cargo test${to}${co}`;
+    return `cargo ${tool}${to}${co}`;
+};
+const cargoTest = (target, config) => test({ run: cargoCommand('test', target, config) });
+const cargoClippy = (target) => test({ run: `${cargoCommand('clippy', target)} -- -D warnings` });
+const cargoReleaseClippy = (target) => test({ run: `${cargoCommand('clippy', target)} --release -- -D warnings` });
+const cargoTestPair = (target, config) => {
+    const main = cargoCommand('test', target, config);
     return [
-        test({ run: main }),
+        cargoTest(target, config),
         test({ run: `${main} --release` })
     ];
 };
-const customTarget = (target) => [
+const cargoReleaseTest = (target) => test({ run: `${cargoCommand('test', target)} --release` });
+const targetChecks = (target) => [
+    cargoTest(target),
+    cargoReleaseTest(target),
+    cargoClippy(target),
+    cargoReleaseClippy(target)
+];
+const rustTarget = (target) => [
     { type: 'rust', target },
-    ...cargoTest(target)
+    ...targetChecks(target)
 ];
 const wasmTarget = (target) => [
-    ...customTarget(target),
-    ...cargoTest(target, '.cargo/config.wasmer.toml')
+    { type: 'rust', target },
+    ...targetChecks(target),
+    ...cargoTestPair(target, '.cargo/config.wasmer.toml')
 ];
 const i686 = (a, v) => {
     if (a === 'intel') {
         switch (v) {
-            case 'windows': return customTarget('i686-pc-windows-msvc');
+            case 'windows': return rustTarget('i686-pc-windows-msvc');
             case 'ubuntu': return [
                 { type: 'apt-get', package: 'libc6-dev-i386' },
-                ...customTarget('i686-unknown-linux-gnu'),
+                ...rustTarget('i686-unknown-linux-gnu'),
             ];
         }
     }
     return [];
 };
-export const rustSteps = (v, a) => [
+export const rustPlatformSteps = (v, a) => [
+    { type: 'rust' },
+    ...targetChecks(),
+    ...i686(a, v),
+];
+export const rustWasmSteps = [
     test({ run: 'cargo fmt -- --check' }),
-    test({ run: 'cargo clippy -- -D warnings' }),
-    ...cargoTest(),
     install(uses('bytecodealliance/actions/wasmtime/setup', { version: wasmtime })),
     install(uses('wasmerio/setup-wasmer', { version: `v${wasmer}` })),
     ...wasmTarget('wasm32-wasip1'),
     ...wasmTarget('wasm32-wasip2'),
     ...wasmTarget('wasm32-unknown-unknown'),
     ...wasmTarget('wasm32-wasip1-threads'),
-    ...i686(a, v),
 ];

package/fs/cli/module.f.d.ts

@@ -1,9 +1,11 @@
 import { type NodeOp, type NodeProgramOptions, type Write } from '../effects/node/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
+type Handler<O extends NodeOp> = (options: NodeProgramOptions) => Effect<O, number>;
 export type Command<O extends NodeOp> = {
     readonly names: readonly string[];
     readonly description: string;
-    readonly handler: (options: NodeProgramOptions) => Effect<O, number>;
+    readonly handler: Handler<O> | Commands<O>;
 };
 export type Commands<O extends NodeOp> = readonly Command<O>[];
 export declare const dispatch: <O extends NodeOp>(commands: Commands<O>) => (options: NodeProgramOptions) => Effect<O | Write, number>;
+export {};

package/fs/cli/module.f.js

@@ -1,24 +1,34 @@
 import { errorExit, log } from "../effects/node/module.f.js";
 import { pure } from "../effects/module.f.js";
+import { at, fromEntries } from "../types/object/module.f.js";
 const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' };
 export const dispatch = (commands) => (options) => {
     const [cmd, ...rest] = options.args;
     const rows = [...commands, helpMeta];
-    const nameCol = rows.map(c => c.names.join(', '));
-    const width = Math.max(...nameCol.map(s => s.length));
-    const helpText = ['Available commands:', ...rows.map((c, i) => `  ${nameCol[i].padEnd(width)}  ${c.description}`)].join('\n');
-    const helpCommand = {
-        ...helpMeta,
-        handler: () => log(helpText).step(() => pure(0)),
-    };
-    const allCommands = [...commands, helpCommand];
-    const map = Object.fromEntries(allCommands.flatMap(c => c.names.map(n => [n, c])));
+    const nameCol = rows.map(({ names }) => names.join(', '));
+    const width = Math.max(...nameCol.map(({ length }) => length));
+    const helpText = [
+        'Available commands:',
+        ...rows.map(({ description }, i) => `  ${nameCol[i].padEnd(width)}  ${description}`)
+    ].join('\n');
+    const map = fromEntries(commands.flatMap(c => c.names.map(n => [n, c])));
     if (cmd === undefined) {
         return errorExit(`Error: command is required.\n${helpText}`);
     }
-    const found = map[cmd];
-    if (found === undefined) {
+    if (helpMeta.names.includes(cmd)) {
+        const [target] = rest;
+        if (target !== undefined) {
+            const targetCmd = at(target)(map);
+            if (targetCmd !== null && typeof targetCmd.handler !== 'function') {
+                return dispatch(targetCmd.handler)({ ...options, args: ['help'] });
+            }
+        }
+        return log(helpText).step(() => pure(0));
+    }
+    const found = at(cmd)(map);
+    if (found === null) {
         return errorExit(`Error: unknown command "${cmd}".\n${helpText}`);
     }
-    return found.handler({ ...options, args: rest });
+    const { handler } = found;
+    return (typeof handler === 'function' ? handler : dispatch(handler))({ ...options, args: rest });
 };

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

@@ -6,4 +6,9 @@ export declare const proof: {
     help: () => void;
     errorIncludesAvailable: () => void;
     handlerReceivesRemainingArgs: () => void;
+    nestedCommands: () => void;
+    nestedHelp: () => void;
+    prototypeNameIsUnknownCommand: () => void;
+    helpPrototypeSafe: () => void;
+    helpWithTarget: () => void;
 };

package/fs/cli/proof.f.js

@@ -5,6 +5,7 @@ import { dispatch } from "./module.f.js";
 const makeOptions = (args) => ({
     args,
     env: {},
+    home: '.',
     std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
     testContext: { test: async () => { } },
     bunTestContext: { test: async () => { } },
@@ -83,4 +84,79 @@ export const proof = {
             throw ['unexpected args', captured];
         }
     },
+    nestedCommands: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(42),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [, code] = run(outer)(['sub', 'ping']);
+        if (code !== 42) {
+            throw ['expected 42', code];
+        }
+    },
+    nestedHelp: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(0),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [state, code] = run(outer)(['sub', 'help']);
+        if (code !== 0) {
+            throw ['expected exit 0', code];
+        }
+        if (!state.stdout.includes('ping')) {
+            throw 'expected inner command in help';
+        }
+    },
+    prototypeNameIsUnknownCommand: () => {
+        const [state, code] = run(echoCommands)(['toString']);
+        if (code !== 1) {
+            throw ['expected exit 1 for prototype-name command', code];
+        }
+        if (!state.stderr.includes('unknown command')) {
+            throw 'expected unknown-command error in stderr';
+        }
+    },
+    helpPrototypeSafe: () => {
+        const [state, code] = run(echoCommands)(['help', 'toString']);
+        if (code !== 0) {
+            throw ['expected exit 0, not a throw', code];
+        }
+        if (!state.stdout.includes('echo')) {
+            throw 'expected top-level help for unknown target';
+        }
+    },
+    helpWithTarget: () => {
+        const inner = [{
+                names: ['ping'],
+                description: 'Inner ping',
+                handler: () => pure(0),
+            }];
+        const outer = [{
+                names: ['sub'],
+                description: 'Subcommand group',
+                handler: inner,
+            }];
+        const [state, code] = run(outer)(['help', 'sub']);
+        if (code !== 0) {
+            throw ['expected exit 0', code];
+        }
+        if (!state.stdout.includes('ping')) {
+            throw 'expected inner command in help';
+        }
+        if (state.stdout.includes('Subcommand group')) {
+            throw 'expected inner help, not outer';
+        }
+    },
 };

package/fs/crypto/hmac/proof.f.d.ts

@@ -3,4 +3,5 @@ export declare const proof: {
     sha256: () => void;
     sha384: () => void;
     sha512: () => void;
+    longKey: () => void;
 };

package/fs/crypto/hmac/proof.f.js

@@ -1,3 +1,4 @@
+import { assertEq } from "../../asserts/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
@@ -28,5 +29,12 @@ export const proof = {
         if (r !== vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an)) {
             throw r;
         }
+    },
+    // RFC 4231 Test Case 6: key (131 bytes of 0xaa = 1048 bits) exceeds SHA-256 block size (512 bits),
+    // so the key is first compressed via the hash function before use.
+    longKey: () => {
+        const key = vec(1048n)(BigInt('0x' + 'aa'.repeat(131)));
+        const r = hmac(sha256)(key)(utf8('Test Using Larger Than Block-Size Key - Hash Key First'));
+        assertEq(uint(r), 0x60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54n);
     }
 };

package/fs/crypto/secp/proof.f.d.ts

@@ -4,4 +4,5 @@ export declare const proof: {
     poker: () => {
         [k: string]: () => void;
     };
+    nullPointOps: () => void;
 };

package/fs/crypto/secp/proof.f.js

@@ -1,3 +1,4 @@
+import { assert } from "../../asserts/module.f.js";
 import { prime_field } from "../../types/prime_field/module.f.js";
 import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from "./module.f.js";
 const poker = (param) => () => {
@@ -131,5 +132,14 @@ export const proof = {
             //secp256r1,
         };
         return Object.fromEntries(Object.entries(c).map(([k, v]) => [k, poker(v)]));
+    },
+    // Cover null (point at infinity) branches in neg, add, and eq.
+    nullPointOps: () => {
+        const c = secp256k1;
+        assert(c.neg(null) === null);
+        assert(eq(null)(null));
+        assert(!eq(null)(c.g));
+        assert(!eq(c.g)(null));
+        assert(eq(c.add(c.g)(null))(c.g));
     }
 };

package/fs/crypto/sign/module.f.js

@@ -1,10 +1,7 @@
-import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
+import { bitLength, divUp8, roundUp8 } from "../../types/bigint/module.f.js";
 import { empty, length, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
 import { computeSync } from "../sha2/module.f.js";
-// qlen to rlen
-const roundUp8 = roundUp(8n);
-const divUp8 = divUp(8n);
 /**
  * Builds RFC6979 helper conversions for a subgroup order.
  *

package/fs/dev/module.f.d.ts

@@ -4,14 +4,13 @@
  * @module
  */
 import { type Access, type All, type Env, type Import, type Readdir } from '../effects/node/module.f.ts';
+import type { StringMap } from '../types/object/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
 };
-export type ModuleMap = {
-    readonly [k in string]: Module;
-};
+export type ModuleMap = StringMap<string, Module>;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -41,3 +40,6 @@ export type LoadModuleOperations = Access | Import | All | Readdir;
  * deterministic regardless of filesystem traversal order.
  */
 export declare const loadModuleMap: (env: Env) => Effect<LoadModuleOperations, ModuleMap>;
+export declare const proof: {
+    isSourceFile: () => void;
+};

package/fs/dev/module.f.js

@@ -7,7 +7,8 @@ import { all, import_, readdir } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { relativize, toPosix } from "../path/module.f.js";
+import { join, relativize, toPosix } from "../path/module.f.js";
+import { assert } from "../asserts/module.f.js";
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -32,7 +33,7 @@ const allFiles = (s, predicate) => {
             if (name.startsWith('.')) {
                 continue;
             }
-            const file = `${p}/${name}`;
+            const file = join(p, name);
             if (!i.isFile) {
                 if (name === 'node_modules') {
                     continue;
@@ -80,3 +81,13 @@ export const loadModuleMap = (env) => {
         .map(([k, v]) => [relativize(prefix, k), v])
         .toSorted(([a], [b]) => strCmp(a)(b)))));
 };
+export const proof = {
+    isSourceFile: () => {
+        assert(isSourceFile('module.js'));
+        assert(isSourceFile('module.ts'));
+        assert(isSourceFile('module.mts'));
+        assert(isSourceFile('module.mjs'));
+        assert(!isSourceFile('readme.md'));
+        assert(!isSourceFile('module.json'));
+    },
+};

package/fs/dev/package_json/proof.f.d.ts

@@ -1,5 +1,6 @@
 export declare const proof: {
     parseMetadata: () => void;
     malformedJson: () => void;
+    validationError: () => void;
     validatePreservesOriginalObject: () => void;
 };

package/fs/dev/package_json/proof.f.js

@@ -12,6 +12,11 @@ export const proof = {
         const result = validatePackageJsonText('{');
         assert(result[0] === 'error', result);
     },
+    validationError: () => {
+        // valid JSON but `name` is a number, not a string — validation should fail
+        const result = validatePackageJsonText('{"name": 42}');
+        assert(result[0] === 'error', result);
+    },
     validatePreservesOriginalObject: () => {
         const object = { name: 'x', version: '1.0.0', private: true };
         const metadata = unwrap(validatePackageJson(object));

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

@@ -1,4 +1,5 @@
 export declare const proof: {
+    shouldLoad: () => void;
     shouldPass: () => {
         then: () => undefined;
     };

package/fs/dev/proof.f.js

@@ -1,5 +1,16 @@
-import { todo } from "../asserts/module.f.js";
+import { assert, todo } from "../asserts/module.f.js";
+import { shouldLoad } from "./module.f.js";
 export const proof = {
+    shouldLoad: () => {
+        assert(shouldLoad('foo.f.ts'));
+        assert(shouldLoad('bar.f.js'));
+        assert(shouldLoad('proof.ts'));
+        assert(shouldLoad('proof.js'));
+        assert(shouldLoad('proof.mts'));
+        assert(shouldLoad('proof.mjs'));
+        assert(!shouldLoad('module.ts'));
+        assert(!shouldLoad('readme.md'));
+    },
     shouldPass: () => ({
         then: () => undefined
     }),

package/fs/djs/ast/module.f.d.ts

@@ -9,7 +9,7 @@ export type AstConst = Primitive | AstModuleRef | AstArray | AstObject;
 export type AstModuleRef = ['aref' | 'cref', number];
 export type AstArray = ['array', readonly AstConst[]];
 export type AstObject = {
-    readonly [k in string]: AstConst;
+    readonly [k in string]?: AstConst;
 };
 export type AstBody = readonly AstConst[];
 export declare const run: (body: AstBody) => (args: Array) => Unknown;

package/fs/djs/ast/proof.f.d.ts

@@ -4,4 +4,9 @@ export declare const proof: {
     testAref: () => void;
     testArray: () => void;
     testObj: () => void;
+    testBool: () => void;
+    testStr: () => void;
+    testNull: () => void;
+    testBigint: () => void;
+    testUndefined: () => void;
 };

package/fs/djs/ast/proof.f.js

@@ -1,6 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 export const proof = {
     test: () => {
         const djs = run([1])([]);
@@ -37,4 +38,20 @@ export const proof = {
             throw result;
         }
     },
+    testBool: () => {
+        assertEq(stringifyAsTree(sort)(run([true])([])), 'true');
+        assertEq(stringifyAsTree(sort)(run([false])([])), 'false');
+    },
+    testStr: () => {
+        assertEq(stringifyAsTree(sort)(run(['hello'])([])), '"hello"');
+    },
+    testNull: () => {
+        assertEq(stringifyAsTree(sort)(run([null])([])), 'null');
+    },
+    testBigint: () => {
+        assertEq(stringifyAsTree(sort)(run([42n])([])), '42n');
+    },
+    testUndefined: () => {
+        assertEq(stringifyAsTree(sort)(run([undefined])([])), 'undefined');
+    },
 };

package/fs/djs/module.f.d.ts

@@ -7,7 +7,7 @@ import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 import { type WriteFile, type ReadFile, type Write } from '../effects/node/module.f.ts';
 export type Object = {
-    readonly [k in string]: Unknown;
+    readonly [k in string]?: Unknown;
 };
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;

package/fs/djs/module.f.js

@@ -2,8 +2,7 @@ import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { writeFile, error, } from "../effects/node/module.f.js";
-import { utf8 } from "../text/module.f.js";
+import { writeUtf8File, error, } from "../effects/node/module.f.js";
 export const compile = args => {
     if (args.length < 2) {
         return error('Error: Requires 2 or more arguments')
@@ -20,7 +19,7 @@ export const compile = args => {
         const content = outputFileName.endsWith('.json')
             ? stringifyAsTree(sort)(result[1])
             : stringify(sort)(result[1]);
-        return writeFile(outputFileName, utf8(content))
+        return writeUtf8File(outputFileName, content)
             .step(() => pure(0));
     });
 };