functionalscript 0.22.0 → 0.23.0

package/fs/asn.1/module.f.js

@@ -4,9 +4,10 @@
  *
  * @module
  */
-import { bitLength, max } from "../types/bigint/module.f.js";
+import { bitLength } from "../types/bigint/module.f.js";
 import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { identity } from "../types/function/module.f.js";
+import { max } from "../types/function/compare/module.f.js";
 import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
 const { popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);

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

@@ -1,4 +1,13 @@
 export declare const proof: {
+    mainAdd: () => void;
+    mainAddWrongArgs: () => void;
+    mainGetFound: () => void;
+    mainGetNotFound: () => void;
+    mainGetWrongArgs: () => void;
+    mainGetInvalidHash: () => void;
+    mainList: () => void;
+    mainNoCmd: () => void;
+    mainUnknownCmd: () => void;
     casWrite: () => void;
     casReadPassthrough: () => void;
 };

package/fs/cas/proof.f.js

@@ -1,9 +1,103 @@
-import { cas } from "./module.f.js";
+import { cas, main } from "./module.f.js";
 import { sha256 } from "../crypto/sha2/module.f.js";
-import { empty, length } from "../types/bit_vec/module.f.js";
+import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
 import { pure } from "../types/effects/module.f.js";
 import { run } from "../types/effects/mock/module.f.js";
+import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
 export const proof = {
+    mainAdd: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [finalState, exitCode] = virtual(state)(main(['add', 'myfile']));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+        if (finalState.stdout.length === 0) {
+            throw 'expected hash in stdout';
+        }
+    },
+    mainAddWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['add']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetFound: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1, exitCode1] = virtual(state)(main(['add', 'myfile']));
+        if (exitCode1 !== 0) {
+            throw ['expected add exit 0', exitCode1];
+        }
+        const hashStr = state1.stdout.trim();
+        const [, exitCode2] = virtual(state1)(main(['get', hashStr, 'output']));
+        if (exitCode2 !== 0) {
+            throw ['expected get exit 0', exitCode2];
+        }
+    },
+    mainGetNotFound: () => {
+        // valid cBase32 hash that has not been stored
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1] = virtual(state)(main(['add', 'myfile']));
+        const hashStr = state1.stdout.trim();
+        // use an empty store so the hash is not found
+        const [finalState, exitCode] = virtual(emptyState)(main(['get', hashStr, 'output']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['get']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetInvalidHash: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['get', 'not-a-valid-hash', 'output']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainList: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1] = virtual(state)(main(['add', 'myfile']));
+        const [, exitCode] = virtual(state1)(main(['list']));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+    },
+    mainNoCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main([]));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainUnknownCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['bogus']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
     casWrite: () => {
         const store = {
             read: (_key) => pure(undefined),

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

@@ -20,7 +20,7 @@ export declare const images: {
     };
 };
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.1";
+export declare const deno = "2.8.2";
 export declare const playwright = "1.60.0";
 export declare const node: {
     readonly default: "26.3.0";
@@ -28,7 +28,7 @@ export declare const node: {
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260601.1";
+export declare const tsgo = "7.0.0-dev.20260604.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";

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

@@ -23,7 +23,7 @@ export const images = {
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.1';
+export const deno = '2.8.2';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
 // https://nodejs.org/en/download
@@ -36,7 +36,7 @@ export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260601.1';
+export const tsgo = '7.0.0-dev.20260604.1';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.

package/fs/crypto/pow/module.f.d.ts

@@ -0,0 +1,37 @@
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nullable } from '../../types/nullable/module.f.ts';
+import { type Sha2 } from '../sha2/module.f.ts';
+/** Genesis-block compact target (`0x1d00ffff`). */
+export declare const genesisNBits = 486604799n;
+/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
+export declare const genesisTarget = 26959535291011309493156476344723991336010898738574164086137773096960n;
+/**
+ * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
+ *
+ * - `exponent = nBits >> 24`
+ * - `mantissa = nBits & 0xffffff`
+ * - `target = mantissa × 2^(8 × (exponent − 3))`
+ *
+ * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
+ * sign bit, overflow, target wider than 256 bits).
+ *
+ * @param nBits - Compact target encoding.
+ * @returns Decoded target, or `null` when **nBits** is invalid.
+ */
+export declare const targetFromNBits: (nBits: bigint) => Nullable<bigint>;
+export type Pow = {
+    /** Hash `data` with the configured `Sha2`; digest as big-endian uint256. */
+    readonly hashInt: (data: Vec) => bigint;
+    /** Whether `hashInt(data) <= targetFromNBits(nBits)`; `false` when **nBits** is invalid. */
+    readonly meets: (nBits: bigint) => (data: Vec) => boolean;
+};
+/**
+ * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
+ *
+ * @param hash - SHA-2 configuration whose digest is compared as uint256.
+ */
+export declare const pow: (hash: Sha2) => Pow;
+/** SHA-256 proof-of-work (`pow(sha256)`). */
+export declare const sha256Pow: Pow;
+/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
+export declare const bitcoinPow: Pow;

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

@@ -0,0 +1,72 @@
+/**
+ * Bitcoin-style proof-of-work: compact **nBits** target decoding and
+ * hash-vs-target verification using an injected SHA-2 hash.
+ *
+ * @module
+ */
+import { mask } from "../../types/bigint/module.f.js";
+import { uint } from "../../types/bit_vec/module.f.js";
+import { computeSync, sha256 } from "../sha2/module.f.js";
+const nBitsMantissa = mask(24n);
+const mantissaSign = 0x00800000n;
+const mantissaBody = 0x007fffffn;
+const exponentShift = 24n;
+const uint256Mask = mask(256n);
+/** Genesis-block compact target (`0x1d00ffff`). */
+export const genesisNBits = 0x1d00ffffn;
+/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
+export const genesisTarget = 0x00000000ffff0000000000000000000000000000000000000000000000000000n;
+const decodeShift = (exponent) => 8n * (exponent - 3n);
+const compactTarget = (exponent) => (mantissa) => {
+    const shift = decodeShift(exponent);
+    return shift >= 0n ? mantissa << shift : mantissa >> -shift;
+};
+const negativeNBits = (mantissa) => mantissa !== 0n && (mantissa & mantissaSign) !== 0n;
+const overflowNBits = (exponent) => (mantissa) => (target) => target !== 0n &&
+    (exponent > 34n || (mantissa !== 0n && (mantissa & mantissaBody) === 0n));
+/**
+ * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
+ *
+ * - `exponent = nBits >> 24`
+ * - `mantissa = nBits & 0xffffff`
+ * - `target = mantissa × 2^(8 × (exponent − 3))`
+ *
+ * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
+ * sign bit, overflow, target wider than 256 bits).
+ *
+ * @param nBits - Compact target encoding.
+ * @returns Decoded target, or `null` when **nBits** is invalid.
+ */
+export const targetFromNBits = (nBits) => {
+    const exponent = nBits >> exponentShift;
+    const mantissa = nBits & nBitsMantissa;
+    if (negativeNBits(mantissa)) {
+        return null;
+    }
+    const target = compactTarget(exponent)(mantissa);
+    if (overflowNBits(exponent)(mantissa)(target)) {
+        return null;
+    }
+    if (target > uint256Mask) {
+        return null;
+    }
+    return target;
+};
+/**
+ * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
+ *
+ * @param hash - SHA-2 configuration whose digest is compared as uint256.
+ */
+export const pow = (hash) => {
+    const c = computeSync(hash);
+    const hashInt = (data) => uint(c([data]));
+    const meets = (nBits) => (data) => {
+        const target = targetFromNBits(nBits);
+        return target !== null && hashInt(data) <= target;
+    };
+    return { hashInt, meets };
+};
+/** SHA-256 proof-of-work (`pow(sha256)`). */
+export const sha256Pow = pow(sha256);
+/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
+export const bitcoinPow = sha256Pow;

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

@@ -0,0 +1,33 @@
+export declare const proof: {
+    targetFromNBits: {
+        genesis: () => void;
+        block0HashWithinGenesisTarget: () => void;
+        exponent3: () => void;
+        exponent2: () => void;
+        hardTargetOne: () => void;
+        zero: () => void;
+        negative: () => void;
+        negativeHighMantissa: () => void;
+        overflowExponent: () => void;
+        exceeds256: () => void;
+    };
+    meets: {
+        easy: () => void;
+        hard: () => void;
+        genesisFailsSample: () => void;
+        zeroTargetRejectsSample: () => void;
+        invalidNBits: () => void;
+        hashLeqTarget: () => void;
+    };
+    hashInt: {
+        sha256Sample: () => void;
+        sha256Empty: () => void;
+        sha224: () => void;
+        stable: () => void;
+    };
+    pow: {
+        sha256Pow: () => void;
+        bitcoinPow: () => void;
+        independentInstances: () => void;
+    };
+};

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

@@ -0,0 +1,161 @@
+import { utf8 } from "../../text/module.f.js";
+import { empty, uint } from "../../types/bit_vec/module.f.js";
+import { computeSync, sha224, sha256 } from "../sha2/module.f.js";
+import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from "./module.f.js";
+const p256 = sha256Pow;
+const p224 = pow(sha224);
+const sample = utf8('functionalscript pow proof');
+const emptyData = empty;
+/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
+const easyNBits = 0x207fffffn;
+/** Compact encoding for target `1` (`0x03000001`). */
+const hardNBits = 0x03000001n;
+/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
+const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
+/** Bitcoin block #0 header hash as big-endian uint256. */
+const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
+const expectNull = (nBits) => {
+    if (targetFromNBits(nBits) !== null) {
+        throw nBits;
+    }
+};
+export const proof = {
+    targetFromNBits: {
+        genesis: () => {
+            if (targetFromNBits(genesisNBits) !== genesisTarget) {
+                throw 'genesis target';
+            }
+        },
+        block0HashWithinGenesisTarget: () => {
+            if (block0Hash > genesisTarget) {
+                throw 'block0 hash exceeds genesis target';
+            }
+        },
+        exponent3: () => {
+            if (targetFromNBits(0x030000ffn) !== 0xffn) {
+                throw 'exponent 3';
+            }
+        },
+        exponent2: () => {
+            if (targetFromNBits(0x02008000n) !== 0x80n) {
+                throw 'exponent 2';
+            }
+        },
+        hardTargetOne: () => {
+            if (targetFromNBits(hardNBits) !== 1n) {
+                throw 'hard target';
+            }
+        },
+        zero: () => {
+            if (targetFromNBits(0n) !== 0n) {
+                throw 'zero nBits';
+            }
+        },
+        negative: () => {
+            expectNull(0x01800001n);
+        },
+        negativeHighMantissa: () => {
+            expectNull(0x22ffffffn);
+        },
+        overflowExponent: () => {
+            expectNull(0x23000001n);
+        },
+        exceeds256: () => {
+            expectNull(0x227fffffn);
+        },
+    },
+    meets: {
+        easy: () => {
+            if (!p256.meets(easyNBits)(sample)) {
+                throw 'easy nBits should pass';
+            }
+        },
+        hard: () => {
+            if (p256.meets(hardNBits)(sample)) {
+                throw 'target 1 should fail';
+            }
+        },
+        genesisFailsSample: () => {
+            if (p256.meets(genesisNBits)(sample)) {
+                throw 'genesis target too hard for sample';
+            }
+        },
+        zeroTargetRejectsSample: () => {
+            if (p256.meets(0n)(sample)) {
+                throw 'non-zero hash vs zero target';
+            }
+        },
+        invalidNBits: () => {
+            if (p256.meets(0x01800001n)(sample)) {
+                throw 'invalid nBits should not pass';
+            }
+        },
+        hashLeqTarget: () => {
+            const h = p256.hashInt(sample);
+            const target = targetFromNBits(easyNBits);
+            if (target === null) {
+                throw 'easy nBits decode';
+            }
+            if (h > target) {
+                throw 'hash above easy target';
+            }
+            if (!(h <= target)) {
+                throw 'hash <= target';
+            }
+        },
+    },
+    hashInt: {
+        sha256Sample: () => {
+            const digest = computeSync(sha256)([sample]);
+            if (p256.hashInt(sample) !== uint(digest)) {
+                throw 'sha256 sample';
+            }
+        },
+        sha256Empty: () => {
+            if (p256.hashInt(emptyData) !== sha256EmptyHash) {
+                throw 'sha256 empty constant';
+            }
+            const digest = computeSync(sha256)([emptyData]);
+            if (p256.hashInt(emptyData) !== uint(digest)) {
+                throw 'sha256 empty';
+            }
+        },
+        sha224: () => {
+            const digest = computeSync(sha224)([sample]);
+            if (p224.hashInt(sample) !== uint(digest)) {
+                throw 'sha224';
+            }
+        },
+        stable: () => {
+            if (p256.hashInt(sample) !== p256.hashInt(sample)) {
+                throw 'stable';
+            }
+        },
+    },
+    pow: {
+        sha256Pow: () => {
+            const built = pow(sha256);
+            if (sha256Pow.hashInt(sample) !== built.hashInt(sample)) {
+                throw 'hashInt';
+            }
+            if (sha256Pow.meets(easyNBits)(sample) !== built.meets(easyNBits)(sample)) {
+                throw 'meets';
+            }
+        },
+        bitcoinPow: () => {
+            if (bitcoinPow.hashInt(sample) !== sha256Pow.hashInt(sample)) {
+                throw 'bitcoinPow';
+            }
+        },
+        independentInstances: () => {
+            const a = pow(sha256);
+            const b = pow(sha256);
+            if (a.hashInt(sample) !== b.hashInt(sample)) {
+                throw 'hashInt';
+            }
+            if (a.meets(easyNBits)(sample) !== b.meets(easyNBits)(sample)) {
+                throw 'meets';
+            }
+        },
+    },
+};

package/fs/dev/module.f.js

@@ -7,7 +7,7 @@ import { begin, pure } from "../types/effects/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
-import { relativize } from "../path/module.f.js";
+import { relativize, toPosix } from "../path/module.f.js";
 export const env = ({ process: { env } }) => a => {
     const r = Object.getOwnPropertyDescriptor(env, a);
     return r === undefined ? undefined :
@@ -74,7 +74,7 @@ const { fromEntries } = Object;
  */
 export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
-    const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
+    const s = initCwd === undefined ? '.' : toPosix(initCwd);
     const prefix = s === '.' ? '' : s;
     // TODO: there are multiple `all` effects here,
     //       we should consider optimize them by ALIQ technique or something similar.

package/fs/emergent_testing/all.test.d.ts

@@ -1 +1 @@
-export {};
+import './module.ts';

package/fs/emergent_testing/all.test.js

@@ -1,3 +1,3 @@
-import { run } from "./module.js";
+import "./module.js";
 // we need `await` for Playwright.
-await run();
+// await run()

package/fs/emergent_testing/example.f.d.ts

@@ -0,0 +1,13 @@
+export declare const add: (a: number, b: number) => number;
+export declare const mul: (a: number, b: number) => number;
+export declare const sqr: (a: number) => number;
+export declare const todo: () => never;
+export declare const proof: {
+    addTest: () => void;
+    mulTest: (() => void)[];
+    throw: {
+        todo: () => never;
+        divByZero: () => bigint;
+    };
+    generateSqrTests: () => (() => void)[];
+};

package/fs/emergent_testing/example.f.js

@@ -0,0 +1,31 @@
+export const add = (a, b) => a + b;
+export const mul = (a, b) => a * b;
+export const sqr = (a) => mul(a, a);
+export const todo = () => { throw "not implemented"; };
+const checkMul = (a, b, r) => {
+    if (mul(a, b) !== r) {
+        throw `mul(${a}, ${b}) !== ${r}`;
+    }
+};
+export const proof = {
+    addTest: () => {
+        if (add(2, 2) !== 4) {
+            throw "something wrong with the math";
+        }
+    },
+    mulTest: [
+        () => checkMul(2, 3, 6),
+        () => checkMul(22, 34, 748),
+        () => checkMul(-2, 3, -6),
+        () => checkMul(-2, -3, 6),
+    ],
+    throw: {
+        todo,
+        divByZero: () => 5n / 0n,
+    },
+    generateSqrTests: () => [1, 2, 3, 5].map(a => () => {
+        if (sqr(a) !== a * a) {
+            throw `sqr(${a})`;
+        }
+    })
+};

package/fs/emergent_testing/module.d.ts

@@ -1 +1 @@
-export declare const run: () => Promise<number>;
+export {};

package/fs/emergent_testing/module.js

@@ -1,4 +1,4 @@
-import { io } from "../io/module.js";
+import { runEffect } from "../io/module.js";
 import { register } from "./module.f.js";
-import { runProgram } from "../io/module.f.js";
-export const run = () => runProgram(io)([])(register);
+// we need `await` for Playwright.
+await runEffect(register);

package/fs/emergent_testing/scenarios/all.d.ts

@@ -1 +1 @@
-export {};
+import '../module.ts';

package/fs/emergent_testing/scenarios/all.js

@@ -1,3 +1 @@
-import { run } from "../module.js";
-// we need `await` for Playwright.
-await run();
+import "../module.js";

package/fs/fjs/module.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { main } from "./module.f.js";
-import effectRun from "../io/module.js";
-effectRun(main);
+import run from "../io/module.js";
+run(main);

package/fs/io/module.d.ts

@@ -5,5 +5,23 @@ export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
 export declare const io: Io;
 export type NodeRun = (p: NodeProgram) => Promise<never>;
-declare const effectRun: NodeRun;
-export default effectRun;
+/**
+ * Runs a `NodeProgram` against the real Node `io` and process arguments,
+ * resolving to its exit code **without** terminating the process.
+ *
+ * Use this when the caller must stay alive afterwards — e.g. when proofs are
+ * registered under an external test runner (Node `--test`, Bun, Playwright)
+ * that owns the process lifecycle. For a standalone CLI entry point that should
+ * exit with the program's code, use the default {@link run} export instead.
+ */
+export declare const runEffect: (p: NodeProgram) => Promise<number>;
+/**
+ * CLI entry point: runs a `NodeProgram` via {@link runEffect}, then calls
+ * `process.exit` with its exit code. The `Promise<never>` return type reflects
+ * that control never returns to the caller — the process terminates.
+ *
+ * This is the default export so a `bin` script can simply
+ * `import run from '.../io/module.js'; run(main)`.
+ */
+declare const run: NodeRun;
+export default run;

package/fs/io/module.js

@@ -125,8 +125,23 @@ export const io = {
     playwrightTestContext,
     engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
 };
-const effectRun = async (p) => {
-    const code = await runProgram(io)(io.process.argv.slice(2))(p);
-    return process.exit(code);
-};
-export default effectRun;
+/**
+ * Runs a `NodeProgram` against the real Node `io` and process arguments,
+ * resolving to its exit code **without** terminating the process.
+ *
+ * Use this when the caller must stay alive afterwards — e.g. when proofs are
+ * registered under an external test runner (Node `--test`, Bun, Playwright)
+ * that owns the process lifecycle. For a standalone CLI entry point that should
+ * exit with the program's code, use the default {@link run} export instead.
+ */
+export const runEffect = runProgram(io)(io.process.argv.slice(2));
+/**
+ * CLI entry point: runs a `NodeProgram` via {@link runEffect}, then calls
+ * `process.exit` with its exit code. The `Promise<never>` return type reflects
+ * that control never returns to the caller — the process terminates.
+ *
+ * This is the default export so a `bin` script can simply
+ * `import run from '.../io/module.js'; run(main)`.
+ */
+const run = async (p) => process.exit(await runEffect(p));
+export default run;

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

@@ -4,6 +4,10 @@
  * @module
  */
 import type { Reduce, Unary } from '../types/function/operator/module.f.ts';
+/**
+ * Converts Windows separators (`\`) to POSIX separators (`/`).
+ */
+export declare const toPosix: (path: string) => string;
 /**
  * Splits a path into normalized segments.
  *

package/fs/path/module.f.js

@@ -21,6 +21,10 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
+/**
+ * Converts Windows separators (`\`) to POSIX separators (`/`).
+ */
+export const toPosix = (path) => path.replaceAll('\\', '/');
 /**
  * Splits a path into normalized segments.
  *
@@ -29,7 +33,7 @@ const foldNormalizeOp = input => state => {
  * separators are converted to POSIX separators.
  */
 export const parse = (path) => {
-    const split = path.replaceAll('\\', '/').split('/');
+    const split = toPosix(path).split('/');
     return toArray(fold(foldNormalizeOp)([])(split));
 };
 /**

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

@@ -2,4 +2,5 @@ export declare const proof: {
     normalizeTest: (() => void)[];
     concatTest: (() => void)[];
     relativizeTest: (() => void)[];
+    toPosixTest: (() => void)[];
 };

package/fs/path/proof.f.js

@@ -1,4 +1,4 @@
-import { concat, normalize, relativize } from "./module.f.js";
+import { concat, normalize, relativize, toPosix } from "./module.f.js";
 const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
@@ -65,4 +65,30 @@ const relativizeTest = [
         }
     },
 ];
-export const proof = { normalizeTest, concatTest, relativizeTest };
+const toPosixTest = [
+    () => {
+        const p = toPosix('a\\b\\c');
+        if (p !== 'a/b/c') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('a/b/c');
+        if (p !== 'a/b/c') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('C:\\Users\\x');
+        if (p !== 'C:/Users/x') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('');
+        if (p !== '') {
+            throw p;
+        }
+    },
+];
+export const proof = { normalizeTest, concatTest, relativizeTest, toPosixTest };

package/fs/types/bigint/module.f.d.ts

@@ -13,7 +13,6 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
- * const m = min(3n)(13n) // 3n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
@@ -130,20 +129,6 @@ export declare const bitLength: (v: bigint) => bigint;
  * ```
  */
 export declare const mask: (len: bigint) => bigint;
-/**
- * Returns the smaller of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the smaller value.
- */
-export declare const min: (a: bigint) => (b: bigint) => bigint;
-/**
- * Returns the larger of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the larger value.
- */
-export declare const max: (a: bigint) => (b: bigint) => bigint;
 /**
  * Calculates the partial factorial `b!/a!`.
  *

package/fs/types/bigint/module.f.js

@@ -13,7 +13,6 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
- * const m = min(3n)(13n) // 3n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
@@ -174,20 +173,6 @@ export const bitLength = (v) => log2(abs(v)) + 1n;
  * ```
  */
 export const mask = (len) => (1n << len) - 1n;
-/**
- * Returns the smaller of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the smaller value.
- */
-export const min = (a) => (b) => a < b ? a : b;
-/**
- * Returns the larger of two `bigint` values.
- *
- * @param a - The first bigint.
- * @returns A function that takes the second bigint and returns the larger value.
- */
-export const max = (a) => (b) => a < b ? b : a;
 /**
  * Calculates the partial factorial `b!/a!`.
  *

package/fs/types/bigint/proof.f.js

@@ -1,4 +1,5 @@
-import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial, divUp, roundUp } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, divUp, roundUp } from "./module.f.js";
+import { min } from "../function/compare/module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;

package/fs/types/bit_vec/module.f.js

@@ -21,12 +21,12 @@
  *
  * @module
  */
-import { bitLength, divUp, mask, max, min, xor } from "../bigint/module.f.js";
+import { bitLength, divUp, mask, xor } from "../bigint/module.f.js";
 import { flip, identity } from "../function/module.f.js";
 import { fold, iterable, map } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
-import { cmp } from "../function/compare/module.f.js";
+import { cmp, max, min } from "../function/compare/module.f.js";
 /**
  * An empty vector of bits.
  */

package/fs/types/function/compare/module.f.d.ts

@@ -24,6 +24,18 @@ export type Cmp2<A, B> = [
     B
 ] extends [bigint, bigint] ? bigint : never;
 export declare const cmp: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => Sign;
+/**
+ * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `min(1)("a")`) at compile time.
+ */
+export declare const min: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
+/**
+ * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `max(1)("a")`) at compile time.
+ */
+export declare const max: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
 /**
  * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
  * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a

package/fs/types/function/compare/module.f.js

@@ -4,6 +4,18 @@ export const index5 = cmp => ([v0, v1]) => {
     return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
 };
 export const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+ * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `min(1)("a")`) at compile time.
+ */
+export const min = (a) => (b) => cmp(a)(b) < 0 ? a : b;
+/**
+ * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
+ * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
+ * types (e.g. `max(1)("a")`) at compile time.
+ */
+export const max = (a) => (b) => cmp(a)(b) > 0 ? a : b;
 /**
  * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
  * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a

package/fs/types/function/compare/proof.f.js

@@ -1,4 +1,4 @@
-import { cmp } from "./module.f.js";
+import { cmp, min, max } from "./module.f.js";
 export const proof = () => {
     {
         const result = cmp(true)(false);
@@ -37,4 +37,34 @@ export const proof = () => {
         // const f = (a: string|number, b: string|number) => cmp(a)(b) // compilation error
         // const f = (a: number, b: string|number) => cmp(a)(b) // compilation error
     }
+    {
+        if (min(3)(5) !== 3) {
+            throw 'min(3)(5)';
+        }
+        if (min(7)(2) !== 2) {
+            throw 'min(7)(2)';
+        }
+        if (min(3n)(13n) !== 3n) {
+            throw 'min(3n)(13n)';
+        }
+        if (min("a")("b") !== "a") {
+            throw 'min("a")("b")';
+        }
+        // const _ = min(1)("a") // compilation error
+    }
+    {
+        if (max(3)(5) !== 5) {
+            throw 'max(3)(5)';
+        }
+        if (max(7)(2) !== 7) {
+            throw 'max(7)(2)';
+        }
+        if (max(3n)(13n) !== 13n) {
+            throw 'max(3n)(13n)';
+        }
+        if (max("a")("b") !== "b") {
+            throw 'max("a")("b")';
+        }
+        // const _ = max(1)("a") // compilation error
+    }
 };

package/fs/types/function/operator/module.f.d.ts

@@ -18,7 +18,5 @@ export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<
 export type Reduce<T> = Fold<T, T>;
 export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
 export declare const addition: Reduce<number>;
-export declare const min: Reduce<number>;
-export declare const max: Reduce<number>;
 export declare const increment: (b: number) => number;
 export declare const counter: () => (b: number) => number;

package/fs/types/function/operator/module.f.js

@@ -12,7 +12,5 @@ export const foldToScan = (fold) => (prior) => i => {
 };
 export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
 export const addition = a => b => a + b;
-export const min = a => b => a < b ? a : b;
-export const max = a => b => a > b ? a : b;
 export const increment = addition(1);
 export const counter = () => increment;

package/fs/types/function/operator/proof.f.d.ts

@@ -4,8 +4,6 @@ export declare const proof: {
     logicalNotTest: () => void;
     strictEqualTest: () => void;
     additionTest: () => void;
-    minTest: () => void;
-    maxTest: () => void;
     incrementTest: () => void;
     foldToScanTest: () => void;
     reduceToScanTest: () => void;

package/fs/types/function/operator/proof.f.js

@@ -1,4 +1,4 @@
-import { join, concat, logicalNot, strictEqual, addition, min, max, increment, foldToScan, reduceToScan, } from "./module.f.js";
+import { join, concat, logicalNot, strictEqual, addition, increment, foldToScan, reduceToScan, } from "./module.f.js";
 const joinTest = () => {
     const result = join(', ')('world')('hello');
     if (result !== 'hello, world') {
@@ -33,22 +33,6 @@ const additionTest = () => {
         throw result;
     }
 };
-const minTest = () => {
-    if (min(3)(5) !== 3) {
-        throw 'min(3)(5)';
-    }
-    if (min(7)(2) !== 2) {
-        throw 'min(7)(2)';
-    }
-};
-const maxTest = () => {
-    if (max(3)(5) !== 5) {
-        throw 'max(3)(5)';
-    }
-    if (max(7)(2) !== 7) {
-        throw 'max(7)(2)';
-    }
-};
 const incrementTest = () => {
     if (increment(4) !== 5) {
         throw 'increment(4)';
@@ -79,4 +63,4 @@ const reduceToScanTest = () => {
         throw v1;
     }
 };
-export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, minTest, maxTest, incrementTest, foldToScanTest, reduceToScanTest };
+export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, foldToScanTest, reduceToScanTest };

package/fs/types/number/module.f.js

@@ -5,11 +5,11 @@
  * @module
  */
 import { reduce } from "../list/module.f.js";
-import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
-import { cmp as uCmp } from "../function/compare/module.f.js";
+import { addition } from "../function/operator/module.f.js";
+import { cmp as uCmp, min as uMin, max as uMax } from "../function/compare/module.f.js";
 export const sum = reduce(addition)(0);
-export const min = reduce(minOp)(null);
-export const max = reduce(maxOp)(null);
+export const min = reduce((uMin))(null);
+export const max = reduce((uMax))(null);
 export const cmp = uCmp;
 const mo = [
     [0x5555_5555, 1],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "type": "module",
   "files": [
     "**/*.js",