functionalscript 0.29.0 → 0.30.0

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

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

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

@@ -1,22 +1,15 @@
 /**
- * CI step builder for Bun: installs the pinned Bun version (with a PowerShell
- * fallback for Windows ARM) and runs `bun install` and `bun test`.
+ * CI step builder for Bun: installs the pinned Bun version and runs the
+ * FunctionalScript package smoke test plus Bun coverage in one canonical job.
  *
  * @module
  */
 import { bun } from "../config/module.f.js";
 import { clean, install, test, uses } from "../common/module.f.js";
-const installOnWindowsArm = ({ def, name, path }) => (v) => (a) => install(v === 'windows' && a === 'arm'
-    ? { run: `irm ${path}/install.ps1 | iex; "$env:USERPROFILE\\.${name}\\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append` }
-    : def);
-const installBun = installOnWindowsArm({
-    def: uses('oven-sh/setup-bun', { 'bun-version': bun }),
-    name: 'bun',
-    path: 'bun.sh',
-});
-export const bunSteps = (extra) => (v, a) => clean([
-    installBun(v)(a),
+export const bunSteps = (version) => clean([
+    install(uses('oven-sh/setup-bun', { 'bun-version': bun })),
+    install({ run: `bun install -g functionalscript@${version}` }),
     test({ run: 'bun install --frozen-lockfile' }),
-    test({ run: 'bun test --timeout 20000' }),
-    ...extra,
+    test({ run: `bunx functionalscript@${version} t` }),
+    test({ run: 'bun test --coverage' }),
 ]);

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

@@ -39,6 +39,7 @@ export declare const gitHubActionSchema: {
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
         readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
+    readonly permissions: import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>;
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
         readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
@@ -58,6 +59,7 @@ export declare const parseGitHubAction: import("../../types/rtti/parse/module.f.
         readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
         readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
+    readonly permissions: import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>;
     readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
         readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
         readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
@@ -84,4 +86,4 @@ export declare const test: (step: Step) => MetaStep;
 export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
-export declare const findTgz: (v: Os) => "(Get-ChildItem *.tgz).FullName" | "./*.tgz";
+export declare const ubuntuArm: (ms: readonly MetaStep[]) => Job;

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

@@ -27,6 +27,7 @@ export const gitHubActionSchema = {
         pull_request: option({}),
         merge_group: option({})
     },
+    permissions: record(string),
     jobs: jobsSchema
 };
 export const parseGitHubAction = rttiParse(gitHubActionSchema);
@@ -47,7 +48,10 @@ export const toSteps = (m) => {
     const targets = m.flatMap(v => v.type === 'rust' && v.target !== undefined ? [v.target] : []).join(',');
     return [
         ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
-        ...(needRust ? [uses('dtolnay/rust-toolchain', { components: 'rustfmt,clippy', targets })] : []),
+        ...(needRust ? [uses('dtolnay/rust-toolchain', {
+                components: 'rustfmt,clippy',
+                ...(targets === '' ? {} : { targets }),
+            })] : []),
         ...filter('install'),
         uses('actions/checkout'),
         ...filter('test'),
@@ -57,4 +61,7 @@ export const ubuntu = (ms) => ({
     'runs-on': images.ubuntu.intel,
     steps: toSteps(ms)
 });
-export const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
+export const ubuntuArm = (ms) => ({
+    'runs-on': images.ubuntu.arm,
+    steps: toSteps(ms)
+});

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

@@ -19,12 +19,14 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
+export declare const functionalscript: "0.29.1";
 export declare const bun = "1.3.14";
 export declare const deno = "2.8.2";
 export declare const playwright = "1.60.0";
 export declare const node: {
     readonly default: "26.3.0";
-    readonly others: readonly ["24.16.0"];
+    readonly node22: "22.22.2";
+    readonly node24: "24.16.0";
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";

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

@@ -20,6 +20,11 @@ export const images = {
         arm: 'windows-11-arm',
     }
 };
+// Bootstrap package version used by generated smoke tests. Keep this on a
+// published FunctionalScript release; do not tie it to package.json's current
+// in-repo version. A separate maintenance job advances this pin.
+// https://www.npmjs.com/package/functionalscript
+export const functionalscript = '0.29.1';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
@@ -29,7 +34,8 @@ export const playwright = '1.60.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.3.0',
-    others: ['24.16.0'],
+    node22: '22.22.2',
+    node24: '24.16.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '45.0.0';

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

@@ -1,2 +1,2 @@
 import { type MetaStep } from '../common/module.f.ts';
-export declare const denoSteps: (extra: readonly MetaStep[]) => readonly MetaStep[];
+export declare const denoSteps: (version: string) => readonly MetaStep[];

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

@@ -1,14 +1,16 @@
 /**
- * CI step builder for Deno: installs the pinned Deno version and runs
- * `deno install` followed by `deno task test`.
+ * CI step builder for Deno: installs the pinned Deno version and runs the
+ * FunctionalScript package smoke test plus Deno coverage in one canonical job.
  *
  * @module
  */
 import { deno } from "../config/module.f.js";
 import { clean, install, test, uses } from "../common/module.f.js";
-export const denoSteps = (extra) => clean([
+const denoTest = 'deno test --allow-read --allow-env';
+export const denoSteps = (version) => clean([
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
+    install({ run: `deno install -g -A npm:functionalscript@${version}` }),
     test({ run: 'deno install --frozen' }),
-    test({ run: 'deno task test' }),
-    ...extra,
+    test({ run: `deno run -A npm:functionalscript@${version} t` }),
+    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
 ]);

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

@@ -3,8 +3,6 @@ import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';
 export type Setup = {
     readonly nodeExtra: (os: Os) => readonly MetaStep[];
-    readonly denoExtra: readonly MetaStep[];
-    readonly bunExtra: readonly MetaStep[];
 };
-export declare const ci: ({ nodeExtra, denoExtra, bunExtra }: Setup) => Effect<NodeOp, number>;
+export declare const ci: ({ nodeExtra }: Setup) => Effect<NodeOp, number>;
 export declare const main: () => Effect<NodeOp, number>;

package/fs/ci/module.f.js

@@ -3,48 +3,38 @@
  *
  * @module
  */
-import { utf8, utf8ToString } from "../text/module.f.js";
-import { validatePackageJsonText } from "../dev/package_json/module.f.js";
+import { utf8 } from "../text/module.f.js";
 import { pure } from "../effects/module.f.js";
-import { access, readFile, writeFile } from "../effects/node/module.f.js";
-import { images } from "./config/module.f.js";
-import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
-import { rustSteps } from "./rust/module.f.js";
-import { nodeMainSteps, nodeVersions } from "./node/module.f.js";
+import { access, writeFile } from "../effects/node/module.f.js";
+import { functionalscript, images } from "./config/module.f.js";
+import { architecture, os, toSteps, ubuntuArm } from "./common/module.f.js";
+import { rustPlatformSteps, rustWasmSteps } from "./rust/module.f.js";
+import { nodeMainSteps, nodeVersionJobs } from "./node/module.f.js";
 import { playwrightJob } from "./playwright/module.f.js";
 import { bunSteps } from "./bun/module.f.js";
 import { denoSteps } from "./deno/module.f.js";
-const job = (rust, nodeExtra, denoExtra, bunExtra) => (o) => (a) => {
+const job = (rust, nodeExtra) => (o) => (a) => {
     const id = `${o}-${a}`;
     const image = images[o][a];
     const result = [
-        ...(rust ? rustSteps(o, a) : []),
-        ...nodeMainSteps(nodeExtra),
-        ...denoSteps(denoExtra),
-        ...bunSteps(bunExtra)(o, a),
+        ...(rust ? rustPlatformSteps(o, a) : []),
+        ...nodeMainSteps(functionalscript),
+        ...nodeExtra,
     ];
     return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
-const functionalscriptPackageName = 'functionalscript';
-const fallbackPackageInfo = {
-    name: functionalscriptPackageName,
-    functionalscript: false,
-};
-const packageInfoFromPackageJson = ({ name }) => name !== undefined
-    ? { name, functionalscript: name === functionalscriptPackageName }
-    : fallbackPackageInfo;
-const packageInfoFromText = (text) => {
-    const result = validatePackageJsonText(text);
-    return result[0] === 'ok' ? packageInfoFromPackageJson(result[1]) : fallbackPackageInfo;
-};
-const readPackageInfo = readFile('package.json')
-    .step(result => pure(result[0] === 'ok' ? packageInfoFromText(utf8ToString(result[1])) : fallbackPackageInfo));
-export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').step(result => {
+const canonicalJobs = (rust) => ({
+    ...(rust ? { wasm: ubuntuArm(rustWasmSteps) } : {}),
+    deno: ubuntuArm(denoSteps(functionalscript)),
+    bun: ubuntuArm(bunSteps(functionalscript)),
+    ...nodeVersionJobs(functionalscript),
+    playwright: playwrightJob,
+});
+export const ci = ({ nodeExtra }) => access('Cargo.toml').step(result => {
     const rust = result[0] === 'ok';
     const jobs = {
-        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o), denoExtra, bunExtra)(o)))),
-        ...nodeVersions,
-        playwright: playwrightJob,
+        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o))(o)))),
+        ...canonicalJobs(rust),
     };
     const gha = {
         name: 'CI',
@@ -52,31 +42,12 @@ export const ci = ({ nodeExtra, denoExtra, bunExtra }) => access('Cargo.toml').s
             pull_request: {},
             merge_group: {},
         },
+        permissions: {
+            contents: 'read',
+        },
         jobs,
     };
     return writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
         .step(() => pure(0));
 });
-const demoCompile = [
-    test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
-    test({ run: 'fjs t' }),
-];
-const denoDemoCompile = [
-    test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
-    test({ run: 'deno task fjs t' }),
-];
-const bunDemoCompile = [
-    test({ run: 'bun ./fs/fjs/module.ts t' }),
-];
-const defaultNodeExtra = ({ name, functionalscript }) => (o) => [
-    test({ run: 'npm pack' }),
-    test({ run: `npm install -g ${findTgz(o)}` }),
-    ...(functionalscript ? demoCompile : []),
-    test({ run: `npm uninstall ${name} -g` }),
-];
-const defaultEffect = (info) => ci({
-    nodeExtra: defaultNodeExtra(info),
-    denoExtra: info.functionalscript ? [...denoDemoCompile] : [],
-    bunExtra: info.functionalscript ? bunDemoCompile : [],
-});
-export const main = () => readPackageInfo.step(defaultEffect);
+export const main = () => ci({ nodeExtra: () => [] });

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

@@ -1,6 +1,6 @@
 import { type Jobs, type MetaStep } from '../common/module.f.ts';
 export declare const major: (v: string) => string;
 export declare const basicNode: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
-export declare const nodeTests: (version: string) => (extra: readonly MetaStep[]) => readonly MetaStep[];
-export declare const nodeVersions: Jobs;
-export declare const nodeMainSteps: (extra: readonly MetaStep[]) => readonly MetaStep[];
+export declare const platformNodeSteps: (version: string) => readonly MetaStep[];
+export declare const nodeVersionJobs: (version: string) => Jobs;
+export declare const nodeMainSteps: (version: string) => readonly MetaStep[];

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

@@ -1,11 +1,11 @@
 /**
- * CI step builders for Node.js: setup-node installation, common npm
- * install/test sequences, per-version job matrices, and the main TSGO step.
+ * CI step builders for Node.js: setup-node installation, platform smoke tests,
+ * per-version canonical jobs, and the main TSGO step.
  *
  * @module
  */
 import { node, tsgo } from "../config/module.f.js";
-import { clean, findTgz, install, test, ubuntu, uses } from "../common/module.f.js";
+import { clean, install, test, ubuntuArm, uses } from "../common/module.f.js";
 export const major = (v) => v.split('.')[0];
 const installNode = (version) => uses('actions/setup-node', { 'node-version': version });
 const nodeInstall = (v) => [
@@ -16,28 +16,33 @@ export const basicNode = (version) => (extra) => clean([
     ...nodeInstall(version),
     ...extra,
 ]);
-const basicTests = [
-    test({ run: 'npx tsc' }),
-    test({ run: 'npm test' }),
-    test({ run: 'node --test' }),
-    test({ run: 'npm run cov' }),
+const fjsGlobalInstall = (version) => install({ run: `npm install -g functionalscript@${version}` });
+export const platformNodeSteps = (version) => [
+    ...nodeInstall(node.default),
+    fjsGlobalInstall(version),
+    test({ run: 'fjs t' }),
 ];
-export const nodeTests = (version) => (extra) => basicNode(version)([
-    ...basicTests,
-    ...extra,
+const node22Steps = (version) => clean([
+    ...nodeInstall(node.node22),
+    fjsGlobalInstall(version),
+    test({ run: 'fjs t' }),
 ]);
-const nodeSteps = (v) => [
-    ...nodeInstall(v),
-    ...basicTests,
-];
-export const nodeVersions = Object.fromEntries(node.others.map(v => [
-    `node${major(v)}`,
-    ubuntu(nodeSteps(v))
-]));
-export const nodeMainSteps = (extra) => nodeTests(node.default)([
-    // TypeScript Preview
+const node24Steps = clean([
+    ...nodeInstall(node.node24),
+    test({ run: 'node --test' }),
+]);
+const node26Steps = clean([
+    ...nodeInstall(node.default),
     install({ run: `npm install -g @typescript/native-preview@${tsgo}` }),
+    test({ run: 'npx tsc' }),
     test({ run: 'tsgo' }),
-    // extra
-    ...extra,
+    test({ run: 'npm run cov' }),
+    test({ run: 'npm pack' }),
 ]);
+const nodeJob = (steps) => ubuntuArm(steps);
+export const nodeVersionJobs = (version) => ({
+    [`node${major(node.node22)}`]: nodeJob(node22Steps(version)),
+    [`node${major(node.node24)}`]: nodeJob(node24Steps),
+    [`node${major(node.default)}`]: nodeJob(node26Steps),
+});
+export const nodeMainSteps = platformNodeSteps;

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

@@ -7,7 +7,7 @@
 import { images, node, playwright } from "../config/module.f.js";
 import { install, test, toSteps, uses } from "../common/module.f.js";
 import { basicNode } from "../node/module.f.js";
-const playwrightImage = images.ubuntu.intel;
+const playwrightImage = images.ubuntu.arm;
 export const playwrightJob = {
     'runs-on': playwrightImage,
     steps: toSteps(basicNode(node.default)([

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

@@ -1,4 +1,5 @@
 export declare const proof: {
+    matrixShape: () => void;
     rust: () => void;
     noRust: () => void;
     extra: {
@@ -6,12 +7,9 @@ export declare const proof: {
         osSpecific: () => void;
     };
     defaultSetup: {
-        functionalscriptDemo: () => void;
-        otherPackageNoDemo: () => void;
-        uninstallPackageName: () => void;
-        malformedPackageJsonFallback: () => void;
-        missingPackageJsonFallback: () => void;
-        missingNameFallback: () => void;
-        nonObjectFallback: () => void;
+        functionalscriptPackage: () => void;
+        otherPackage: () => void;
+        configuredPackageVersion: () => void;
+        missingPackageJson: () => void;
     };
 };

package/fs/ci/proof.f.js

@@ -1,4 +1,5 @@
 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";
@@ -26,7 +27,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 +37,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 +98,31 @@ 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 --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');
         },
     },
 };

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/emergent_testing/module.f.js

@@ -130,6 +130,8 @@ const runModule = ({ result, test }) => (k, v) => (ts) => {
         .step(delta => pure(mergeState(ts, delta)));
 };
 const { entries } = Object;
+const proofEntries = (moduleMap) => entries(moduleMap)
+    .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
 /**
  * Runs all test modules in `moduleMap` whose names pass `isTest`, accumulates
  * pass/fail/time via `reporter`, and returns an exit code (0 = all passed,
@@ -137,8 +139,7 @@ const { entries } = Object;
  */
 export const runModuleMap = (reporter) => (moduleMap) => {
     const { summary } = reporter;
-    const modules = entries(moduleMap)
-        .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
+    const modules = proofEntries(moduleMap);
     return all(...modules.map(([k, v]) => runModule(reporter)(k, v)(zero)))
         .step(m => pure(m.reduce(mergeState, zero)))
         .step(ts => summary(ts.pass, ts.fail, ts.time)
@@ -155,8 +156,7 @@ export const testAll = (reporter) => options => loadModuleMap(options.env).step(
  * `ctx`. Delegates to `registerModule` for each matching entry.
  */
 const registerModuleMap = (ctx, star) => (moduleMap) => {
-    const modules = entries(moduleMap)
-        .flatMap(([k, v]) => v.proof !== undefined ? [[k, v.proof]] : []);
+    const modules = proofEntries(moduleMap);
     if (modules.length === 0) {
         return pure(undefined);
     }

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

@@ -1,3 +1,4 @@
 export declare const proof: {
     range: () => void;
+    oneThrowsOnEmpty: () => void;
 };

package/fs/text/ascii/proof.f.js

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

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

@@ -26,7 +26,13 @@ export type PrimeField = {
     readonly pow3: Unary;
     /** Reduces an arbitrary `bigint` into `[0, p)`. */
     readonly reduce: Unary;
-    /** Euler criterion: `true` when `x` is a quadratic residue mod `p`. */
+    /**
+     * `true` when `x` is a square modulo `p`, including `0`.
+     *
+     * Nonzero values are tested with Euler's criterion:
+     * `x^((p - 1) / 2) === 1 (mod p)`.
+     * For `p === 2n`, both field elements are squares.
+     */
     readonly quadRes: (x: bigint) => boolean;
 };
 /**

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

@@ -42,12 +42,19 @@ export const prime_field = (p) => {
         const r = x % p;
         return r < 0n ? add(p)(r) : r;
     };
-    const half = (p - 1n) / 2n;
-    const quadRes = (x) => pow(half)(reduce(x)) === 1n;
+    const max = p - 1n;
+    // Euler's exponent is `(p - 1) / 2`; use `max`, not `p`, so `p === 2n`
+    // gives exponent `0n` instead of `1n`.
+    // 0 is a square mod p; Euler's criterion needs a separate case because 0^e = 0.
+    const powHalf = pow(max >> 1n);
+    const quadRes = (x) => {
+        const v = reduce(x);
+        return v === 0n || powHalf(v) === 1n;
+    };
     return {
         p,
         middle,
-        max: p - 1n,
+        max,
         neg: a => a === 0n ? 0n : p - a,
         sub,
         add,

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

@@ -153,12 +153,25 @@ export const proof = {
                 }
             },
             quadRes: () => {
+                if (!f.quadRes(0n)) {
+                    throw 0n;
+                }
                 if (!f.quadRes(1n)) {
                     throw 1n;
                 }
+                if (!f.quadRes(p)) {
+                    throw p;
+                }
                 if (f.quadRes(3n)) {
                     throw 3n;
                 }
+                const f2 = prime_field(2n);
+                if (!f2.quadRes(0n)) {
+                    throw '0 mod 2';
+                }
+                if (!f2.quadRes(1n)) {
+                    throw '1 mod 2';
+                }
             },
             modSqrt: () => {
                 const root = modSqrt(f);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -18,7 +18,7 @@
     "website": "npm run prepack && npm run index-html"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "bin": {
     "fjs": "fs/fjs/module.js"