functionalscript 0.43.0 → 0.44.0

package/fjs/ci/nix/proof.f.js

@@ -1,109 +0,0 @@
-/**
- * Proofs for generated CI flakes.
- *
- * @module
- */
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { step } from '../../effects/module.f.js';
-import { readUtf8File } from '../../effects/node/module.f.js';
-import { emptyState, virtual } from '../../effects/node/virtual/module.f.js';
-import { nixpkgs } from '../config/module.f.js';
-import { nodeNixJobs } from '../node/module.f.js';
-import { flakePath, flakeText, generatedDirectory, nixDevelop, nixDevelopAll, nixFlakes, nixInstall, } from './module.f.js';
-const { commit } = nixpkgs;
-const plain = {
-    id: 'node24',
-    system: 'aarch64-linux',
-    packages: ['nodejs_24'],
-};
-const withShellHook = {
-    ...plain,
-    id: 'node22',
-    packages: ['nodejs_22'],
-    shellHook: `export NPM_CONFIG_PREFIX="$HOME/.npm-global"`,
-};
-const plainFlake = `{
-    inputs.nixpkgs.url = "github:NixOS/nixpkgs/${commit}";
-    outputs = { nixpkgs, ... }: {
-        devShells.aarch64-linux.default = let
-            pkgs = import nixpkgs {
-                system = "aarch64-linux";
-            };
-        in
-        pkgs.mkShell {
-            packages = [ pkgs.nodejs_24 ];
-        };
-    };
-}
-`;
-const shellHookFlake = `{
-    inputs.nixpkgs.url = "github:NixOS/nixpkgs/${commit}";
-    outputs = { nixpkgs, ... }: {
-        devShells.aarch64-linux.default = let
-            pkgs = import nixpkgs {
-                system = "aarch64-linux";
-            };
-        in
-        pkgs.mkShell {
-            packages = [ pkgs.nodejs_22 ];
-            shellHook = ''
-                export NPM_CONFIG_PREFIX="$HOME/.npm-global"
-            '';
-        };
-    };
-}
-`;
-const generated = (jobs, id) => {
-    const written = step(nixFlakes(jobs), () => readUtf8File(`${generatedDirectory}/${id}/flake.nix`));
-    const [, [tag, result]] = virtual(emptyState)(written);
-    assert(tag === 'ok', result);
-    return result;
-};
-export const proof = {
-    flakeText: {
-        plain: () => assertEq(flakeText(plain), plainFlake),
-        shellHook: () => assertEq(flakeText(withShellHook), shellHookFlake),
-    },
-    nixFlakes: {
-        write: () => assertEq(generated([plain], plain.id), plainFlake),
-        every: () => {
-            for (const job of nodeNixJobs) {
-                assertEq(generated(nodeNixJobs, job.id), flakeText(job));
-            }
-        },
-        nodeShellHook: () => {
-            const [node22] = nodeNixJobs;
-            assert(node22.shellHook !== undefined, 'expected a Node 22 shell hook');
-            assert(generated(nodeNixJobs, node22.id).includes('$HOME/.npm-global'), 'expected the Node 22 global installation prefix');
-        },
-        packages: () => {
-            for (const { id, packages } of nodeNixJobs) {
-                assertEq(packages.length, 1);
-                assertEq(packages[0], `nodejs_${id.slice('node'.length)}`);
-            }
-        },
-        // Job data only ever reaches quotable positions, so an unusual package
-        // name is escaped rather than rejected.
-        quotedPackage: () => assert(flakeText({ ...plain, packages: ['not an identifier'] })
-            .includes('pkgs."not an identifier"'), 'expected a quoted attribute name'),
-        multiplePackages: () => assert(flakeText({ ...plain, packages: ['nodejs_24', 'git'] })
-            .includes('[ pkgs.nodejs_24 pkgs.git ]'), 'expected both packages in the shell'),
-    },
-    workflow: {
-        // The path a workflow passes to `nix develop` must be the directory the
-        // generator wrote the flake into.
-        flakePath: () => assertEq(flakePath(plain.id), `./${generatedDirectory}/node24`),
-        nixDevelop: () => assertEq(nixDevelop(plain.id, 'node --version'), 'nix develop ./nix/generated/node24 --command node --version'),
-        nixDevelopAll: {
-            sequence: () => assertEq(nixDevelopAll(plain.id, ['npm ci', 'node --test']), `nix develop ./nix/generated/node24 --command bash -euo pipefail -c 'npm ci && node --test'`),
-            // A command carrying its own quote must not end the outer one: the
-            // shell has to see the script back exactly as it was written.
-            quote: () => assertEq(nixDevelopAll(plain.id, [`printf '%s' 'a b'`]), `nix develop ./nix/generated/node24 --command bash -euo pipefail -c 'printf '\\''%s'\\'' '\\''a b'\\'''`),
-        },
-        nixInstall: () => {
-            assertEq(nixInstall.type, 'install');
-            assert(nixInstall.type === 'install'
-                && nixInstall.step.uses?.startsWith('cachix/install-nix-action@') === true, 'expected the pinned Nix installer action');
-        },
-    },
-};

package/fjs/ci/node/module.f.d.ts

@@ -1,28 +0,0 @@
-import { type Job, type Jobs, type MetaStep } from '../common/module.f.ts';
-import { type NixJob } from '../nix/module.f.ts';
-export declare const major: (v: string) => string;
-export declare const basicNode: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
-export declare const platformNodeSteps: (version: string) => readonly MetaStep[];
-export declare const nodeVersionJobs: (version: string) => Jobs;
-export declare const nixSystem: 'aarch64-linux';
-/** Generated development environments for the canonical Node jobs. */
-export declare const nodeNixJobs: readonly NixJob[];
-/**
- * Version-check steps for the canonical Node jobs' generated flakes, one per
- * job. Collected into the shared temporary `nix-flakes` job in
- * `fjs/ci/module.f.ts`.
- */
-export declare const nodeNixVersionSteps: readonly MetaStep[];
-/**
- * Temporary job that instantiates every generated flake.
- *
- * Nothing else in CI evaluates the generated files, so a broken flake — or one
- * whose snapshot moved to a different Node — would only surface once a real job
- * started using it. It deliberately stays separate from the canonical Node jobs:
- * those keep their current `setup-node` runtime until they are migrated one at a
- * time. When the last one migrates and this job goes away, each migrated job
- * must check its own Node version inside the `nix develop` invocation, or the
- * guarantee is lost.
- */
-export declare const nodeNixFlakeJob: Job;
-export declare const nodeMainSteps: typeof platformNodeSteps;

package/fjs/ci/node/module.f.js

@@ -1,92 +0,0 @@
-/**
- * CI step builders for Node.js: setup-node installation, platform smoke tests,
- * per-version canonical jobs.
- *
- * @module
- */
-import { node } from '../config/module.f.js';
-import { install, test, ubuntuArm, uses } from '../common/module.f.js';
-import { nixInstall, nixVersionCheckStep } from '../nix/module.f.js';
-export const major = (v) => v.split('.')[0];
-const jobId = (version) => `node${major(version)}`;
-const installNode = (version) => uses('actions/setup-node', { 'node-version': version });
-const nodeInstall = (v) => [
-    install(installNode(v)),
-    test({ run: 'npm ci' }),
-];
-export const basicNode = (version) => (extra) => [
-    ...nodeInstall(version),
-    ...extra,
-];
-const fjsGlobalInstall = (version) => install({ run: `npm install -g functionalscript@${version}` });
-export const platformNodeSteps = (version) => [
-    ...nodeInstall(node.default),
-    fjsGlobalInstall(version),
-    test({ run: 'fjs t' }),
-];
-const node22Steps = (version) => [
-    ...nodeInstall(node.node22),
-    fjsGlobalInstall(version),
-    test({ run: 'fjs t' }),
-    test({ run: 'node --test' }),
-];
-const node24Steps = [
-    ...nodeInstall(node.node24),
-    test({ run: 'node --test' }),
-];
-const node26Steps = [
-    ...nodeInstall(node.default),
-    test({ run: 'npm run ci-update' }),
-    test({ run: 'git add -A && git diff --cached --exit-code' }),
-    test({ run: 'npx tsc' }),
-    test({ run: 'npm run cov' }),
-    test({ run: 'npm pack' }),
-];
-const nodeJob = (steps) => ubuntuArm(steps);
-export const nodeVersionJobs = (version) => ({
-    [jobId(node.node22)]: nodeJob(node22Steps(version)),
-    [jobId(node.node24)]: nodeJob(node24Steps),
-    [jobId(node.default)]: nodeJob(node26Steps),
-});
-// The canonical Node jobs run on the Ubuntu ARM runner.
-export const nixSystem = 'aarch64-linux';
-// Keeps `npm install -g functionalscript` writable and puts the installed `fjs`
-// on `PATH` for the rest of the same `nix develop` invocation.
-const npmGlobalShellHook = `export NPM_CONFIG_PREFIX="$HOME/.npm-global"
-export PATH="$NPM_CONFIG_PREFIX/bin:$PATH"
-mkdir -p "$NPM_CONFIG_PREFIX"`;
-// Versions of the canonical Node jobs, in job order.
-const nixVersions = [node.node22, node.node24, node.default];
-const nixJob = (version) => ({
-    id: jobId(version),
-    system: nixSystem,
-    packages: [`nodejs_${major(version)}`],
-});
-/** Generated development environments for the canonical Node jobs. */
-export const nodeNixJobs = [
-    { ...nixJob(node.node22), shellHook: npmGlobalShellHook },
-    nixJob(node.node24),
-    nixJob(node.default),
-];
-/**
- * Version-check steps for the canonical Node jobs' generated flakes, one per
- * job. Collected into the shared temporary `nix-flakes` job in
- * `fjs/ci/module.f.ts`.
- */
-export const nodeNixVersionSteps = nixVersions.map(version => nixVersionCheckStep(jobId(version), version));
-/**
- * Temporary job that instantiates every generated flake.
- *
- * Nothing else in CI evaluates the generated files, so a broken flake — or one
- * whose snapshot moved to a different Node — would only surface once a real job
- * started using it. It deliberately stays separate from the canonical Node jobs:
- * those keep their current `setup-node` runtime until they are migrated one at a
- * time. When the last one migrates and this job goes away, each migrated job
- * must check its own Node version inside the `nix develop` invocation, or the
- * guarantee is lost.
- */
-export const nodeNixFlakeJob = ubuntuArm([
-    nixInstall,
-    ...nodeNixVersionSteps,
-]);
-export const nodeMainSteps = platformNodeSteps;

package/fjs/ci/node/proof.f.js

@@ -1,17 +0,0 @@
-import { basicNode } from './module.f.js';
-import { test } from '../common/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    basicNode: () => {
-        const extra = [test({ run: 'echo extra' })];
-        const steps = basicNode('22.0.0')(extra);
-        assertEq(steps.length, 3);
-        const [setupNode, npmCi, extraStep] = steps;
-        assertEq(setupNode.type, 'install');
-        assertEq(setupNode.type === 'install' ? setupNode.step.uses : undefined, 'actions/setup-node@v7.0.0');
-        assertEq(setupNode.type === 'install' ? setupNode.step.with?.['node-version'] : undefined, '22.0.0');
-        assertEq(npmCi.type, 'test');
-        assertEq(npmCi.type === 'test' ? npmCi.step.run : undefined, 'npm ci');
-        assertEq(extraStep, extra[0]);
-    },
-};

package/fjs/ci/proof.f.d.ts

@@ -1,18 +0,0 @@
-export declare const proof: {
-    matrixShape: () => void;
-    rust: () => void;
-    noRust: () => void;
-    extra: {
-        allOs: () => void;
-        osSpecific: () => void;
-    };
-    defaultSetup: {
-        functionalscriptPackage: () => void;
-        otherPackage: () => void;
-        configuredPackageVersion: () => void;
-        missingPackageJson: () => void;
-    };
-    nixFlakes: () => void;
-    nixFlakeJob: () => void;
-    ubuntu: () => void;
-};

package/fjs/ci/proof.f.js

@@ -1,182 +0,0 @@
-import { ci, main } from './module.f.js';
-import { functionalscript, node } from './config/module.f.js';
-import { nodeNixJobs } from './node/module.f.js';
-import { coverageInclude } from './deno/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, ubuntu, parseGitHubAction } from './common/module.f.js';
-import { assert, assertEq } from '../asserts/module.f.js';
-import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
-import { parse as jsonParse } from '../media/json/module.f.js';
-import { unwrap } from '../types/result/module.f.js';
-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 hasExactRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run === cmd) ?? false;
-const makeState = (rust, packageJson) => ({
-    ...emptyState,
-    root: {
-        '.github': { workflows: {} },
-        ...(packageJson !== undefined ? { 'package.json': [utf8(packageJson)] } : {}),
-        ...(rust ? { 'Cargo.toml': [emptyVec] } : {}),
-    },
-});
-const subDir = (dir, name) => {
-    const entity = dir[name];
-    assert(typeof entity === 'object' && !Array.isArray(entity), entity);
-    return entity;
-};
-const text = (dir, name) => {
-    const file = dir[name];
-    assert(!(!Array.isArray(file) || file.length === 0), file);
-    return utf8ToString(file[0]);
-};
-const path = (dir, names) => names.reduce(subDir, dir);
-const workflow = (state) => {
-    const workflows = path(state.root, ['.github', 'workflows']);
-    return unwrap(parseGitHubAction(unwrap(jsonParse(text(workflows, 'ci.yml')))));
-};
-const flake = (state, id) => text(path(state.root, ['nix', 'generated', id]), 'flake.nix');
-const run = (rust, nodeExtra = () => []) => {
-    const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));
-    assertEq(result, 0);
-    return workflow(state);
-};
-const runDefault = (packageJson) => {
-    const [state, result] = virtual(makeState(false, packageJson))(main());
-    assertEq(result, 0);
-    return workflow(state);
-};
-export const proof = {
-    matrixShape: () => {
-        const gha = run(true);
-        assertEq(Object.keys(gha.jobs).length, 13, 'expected 13 CI jobs');
-        assertEq(gha.permissions.contents, 'read', 'expected read-only contents permission');
-        assertEq(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');
-        // Wasmtime 47 removed wasi-threads: the threads target must run under
-        // Wasmer only, while Clippy (no runner) stays.
-        assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --config .cargo/config.wasmer.toml')(gha), 'expected Wasmer WASM threads check');
-        assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1-threads -- -D warnings')(gha), 'expected WASM threads lint');
-        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads')(gha), 'unexpected Wasmtime WASM threads check');
-        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --release')(gha), 'unexpected Wasmtime WASM threads release check');
-        assert(hasRunInJob('node22', 'fjs t')(gha), 'expected Node 22 FunctionalScript smoke test');
-        assert(hasRunInJob('node26', 'npm pack')(gha), 'expected Node 26 package check');
-        assert(hasRunInJob('node26', 'npm run ci-update')(gha), 'expected Node 26 workflow regeneration');
-        assert(hasRunInJob('node26', 'git add -A && git diff --cached --exit-code')(gha), 'expected Node 26 generated-file drift 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',
-        ]) {
-            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');
-    },
-    noRust: () => {
-        assert(!hasRun('cargo')(run(false)), 'unexpected Rust steps');
-    },
-    extra: {
-        allOs: () => {
-            const cmd = 'echo hello';
-            const gha = run(false, () => [test({ run: cmd })]);
-            for (const o of ['ubuntu', 'macos', 'windows']) {
-                for (const a of ['intel', 'arm']) {
-                    assert(hasRunInJob(`${o}-${a}`, cmd)(gha), `missing extra step in ${o}-${a}`);
-                }
-            }
-        },
-        osSpecific: () => {
-            const gha = run(false, o => o === 'ubuntu' ? [test({ run: 'echo ubuntu-only' })] : []);
-            for (const a of ['intel', 'arm']) {
-                assert(hasRunInJob(`ubuntu-${a}`, 'echo ubuntu-only')(gha), `missing step in ubuntu-${a}`);
-                assert(!hasRunInJob(`macos-${a}`, 'echo ubuntu-only')(gha), `unexpected step in macos-${a}`);
-                assert(!hasRunInJob(`windows-${a}`, 'echo ubuntu-only')(gha), `unexpected step in windows-${a}`);
-            }
-        },
-    },
-    defaultSetup: {
-        functionalscriptPackage: () => {
-            const gha = runDefault('{"name":"functionalscript"}');
-            assert(hasRun('fjs t')(gha), 'expected fjs self-test');
-            assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected deno self-test');
-            assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected bun self-test');
-        },
-        otherPackage: () => {
-            const gha = runDefault('{"name":"other-package"}');
-            assert(hasRun(`deno run -A --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected canonical deno self-test');
-            assert(hasRun(`bunx functionalscript@${functionalscript} t`)(gha), 'expected canonical bun self-test');
-        },
-        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 --minimum-dependency-age=0 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 --minimum-dependency-age=0 npm:functionalscript@${functionalscript} t`)(gha), 'expected configured-version deno install');
-            assert(hasRun(`deno test --allow-read --allow-env --allow-sys --coverage && deno coverage --include='${coverageInclude}'`)(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');
-        },
-        missingPackageJson: () => {
-            const gha = runDefault();
-            assert(hasRun(`npm install -g functionalscript@${functionalscript}`)(gha), 'expected configured-version install');
-        },
-    },
-    nixFlakes: () => {
-        const [state, result] = virtual(makeState(false))(main());
-        assertEq(result, 0);
-        for (const { id, packages } of nodeNixJobs) {
-            const [nodePackage] = packages;
-            assert(flake(state, id).includes(`pkgs.${nodePackage}`), `expected ${nodePackage} in the ${id} flake`);
-        }
-    },
-    nixFlakeJob: () => {
-        const gha = run(false);
-        const job = gha.jobs['nix-flakes'];
-        assert(job !== undefined, 'expected the temporary flake job');
-        assert(job.steps.some(step => step.uses?.startsWith('cachix/install-nix-action@') === true), 'expected a pinned Nix installer');
-        // Exactly one check per unmigrated flake: none goes unchecked, and no
-        // check outlives the flake it was written for. A migrated job checks its
-        // own flake by running through it, so it is not covered here.
-        assertEq(job.steps.filter(step => step.run !== undefined).length, nodeNixJobs.length);
-        for (const { id } of nodeNixJobs) {
-            assert(hasRunInJob('nix-flakes', `nix develop ./nix/generated/${id} --command node --version`)(gha), `expected the ${id} flake to be instantiated`);
-        }
-        // Since the flakes no longer assert their own version, this job is the
-        // only place the Nix runtime is tied to the version `setup-node` installs.
-        for (const version of [node.node22, node.node24, node.default]) {
-            assert(hasRunInJob('nix-flakes', `= v${version}`)(gha), `expected the flake job to check Node ${version}`);
-        }
-        // The canonical Node jobs keep their current runtime setup until they
-        // are migrated one at a time.
-        for (const { id } of nodeNixJobs) {
-            assert(!hasRunInJob(id, 'nix develop')(gha), `unexpected nix develop in ${id}`);
-        }
-    },
-    ubuntu: () => {
-        const job = ubuntu([test({ run: 'echo hi' })]);
-        assert(job['runs-on'] !== undefined, 'expected runs-on');
-        assert(job.steps.length > 0, 'expected steps');
-    },
-};

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

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

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

@@ -1,75 +0,0 @@
-/**
- * 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 cargoCommand = (tool, target, config) => {
-    const to = target ? ` --target ${target}` : '';
-    const co = config ? ` --config ${config}` : '';
-    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 [
-        cargoTest(target, config),
-        test({ run: `${main} --release` })
-    ];
-};
-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 },
-    ...targetChecks(target)
-];
-const wasmTarget = (target) => [
-    { type: 'rust', target },
-    ...targetChecks(target),
-    ...cargoTestPair(target, '.cargo/config.wasmer.toml')
-];
-// Wasmtime 47 removed wasi-threads, so the threads target runs under Wasmer
-// only; Clippy needs no runner and stays. See todo/blocked/wasmtime-threads.md.
-const wasmerOnlyTarget = (target) => [
-    { type: 'rust', target },
-    cargoClippy(target),
-    cargoReleaseClippy(target),
-    ...cargoTestPair(target, '.cargo/config.wasmer.toml')
-];
-const i686 = (a, v) => {
-    if (a === 'intel') {
-        switch (v) {
-            case 'windows': return rustTarget('i686-pc-windows-msvc');
-            case 'ubuntu': return [
-                { type: 'apt-get', package: 'libc6-dev-i386' },
-                ...rustTarget('i686-unknown-linux-gnu'),
-            ];
-        }
-    }
-    return [];
-};
-export const rustPlatformSteps = (v, a) => [
-    { type: 'rust' },
-    ...targetChecks(),
-    ...i686(a, v),
-];
-export const rustWasmSteps = [
-    test({ run: 'cargo fmt -- --check' }),
-    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'),
-    ...wasmerOnlyTarget('wasm32-wasip1-threads'),
-];

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

@@ -1,11 +0,0 @@
-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: 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/fjs/cli/module.f.js

@@ -1,34 +0,0 @@
-import { errorExit, log } from '../effects/node/module.f.js';
-import { pure, step } 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(({ 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}`);
-    }
-    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 step(log(helpText), () => pure(0));
-    }
-    const found = at(cmd)(map);
-    if (found === null) {
-        return errorExit(`Error: unknown command "${cmd}".\n${helpText}`);
-    }
-    const { handler } = found;
-    return (typeof handler === 'function' ? handler : dispatch(handler))({ ...options, args: rest });
-};

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

@@ -1,14 +0,0 @@
-export declare const proof: {
-    knownCommand: () => void;
-    alias: () => void;
-    noArgs: () => void;
-    unknownCommand: () => void;
-    help: () => void;
-    errorIncludesAvailable: () => void;
-    handlerReceivesRemainingArgs: () => void;
-    nestedCommands: () => void;
-    nestedHelp: () => void;
-    prototypeNameIsUnknownCommand: () => void;
-    helpPrototypeSafe: () => void;
-    helpWithTarget: () => void;
-};