functionalscript 0.29.1 → 0.31.0

package/fs/cbase32/module.f.js

@@ -4,32 +4,11 @@
  * @module
  */
 import { msb, lsb, length, vec, empty } from "../types/bit_vec/module.f.js";
+import { baseN } from "../base_n/module.f.js";
 //                         0123456789abcdef
 const m = '0123456789abcdefghjkmnpqrstvwxyz';
-const { popFront, concat } = msb;
+const { concat } = msb;
 const popBack1 = lsb.popFront(1n);
-const popFront5 = popFront(5n);
-export const vec5xToCBase32 = (v) => {
-    let result = '';
-    while (true) {
-        const len = length(v);
-        if (len === 0n) {
-            break;
-        }
-        const [r, rest] = popFront5(v);
-        result += m[Number(r)];
-        v = rest;
-    }
-    return result;
-};
-export const vecToCBase32 = (v) => {
-    const len = length(v);
-    const extraLen = 5n - len % 5n;
-    const last = 1n << (extraLen - 1n);
-    const padded = concat(v)(vec(extraLen)(last));
-    return vec5xToCBase32(padded);
-};
-const vec5 = vec(5n);
 const normalizeChar = (c) => {
     const lower = c.toLowerCase();
     switch (lower) {
@@ -47,30 +26,30 @@ const normalizeChar = (c) => {
         }
     }
 };
-const toCrockfordIndex = (c) => m.indexOf(normalizeChar(c));
-export const cBase32ToVec5x = (s) => {
-    let result = empty;
-    for (const c of s) {
-        const index = toCrockfordIndex(c);
-        if (index < 0) {
-            return null;
-        }
-        const v = vec5(BigInt(index));
-        result = concat(result)(v);
-    }
-    return result;
+const codec = baseN(5n, m, normalizeChar);
+export const vec5xToCBase32 = codec.vecToString;
+export const cBase32ToVec5x = codec.stringToVec;
+export const vecToCBase32 = (v) => {
+    const len = length(v);
+    const extraLen = 5n - len % 5n;
+    const last = 1n << (extraLen - 1n);
+    const padded = concat(v)(vec(extraLen)(last));
+    return vec5xToCBase32(padded);
 };
 export const cBase32ToVec = (s) => {
     let v = cBase32ToVec5x(s);
-    if (v === null || v === empty) {
+    if (v === null) {
         return null;
     }
-    // TODO: replace with a function that computes trailing zeros.
-    while (true) {
-        const [last, v0] = popBack1(v);
-        v = v0;
+    // Strip the padding: trailing zeros up to and including the sentinel `1` bit.
+    // A string with no sentinel — only zero symbols (`0`/`o`), or empty — exhausts
+    // to `empty` and is rejected as `null` rather than looping forever.
+    while (v !== empty) {
+        const [last, rest] = popBack1(v);
+        v = rest;
         if (last === 1n) {
             return v;
         }
     }
+    return null;
 };

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

@@ -3,4 +3,5 @@ export declare const proof: {
     roundtrip: () => void;
     unalignedBits: () => void;
     caseInsensitive: () => void;
+    unterminated: () => void;
 };

package/fs/cbase32/proof.f.js

@@ -70,5 +70,20 @@ export const proof = {
         if (cBase32ToVec5x("u") !== null) {
             throw 'should error on invalid character';
         }
+    },
+    unterminated: () => {
+        // No sentinel `1` bit → invalid; must return null, not loop forever.
+        if (cBase32ToVec("") !== null) {
+            throw 'empty must be null';
+        }
+        if (cBase32ToVec("0") !== null) {
+            throw 'single zero symbol must be null';
+        }
+        if (cBase32ToVec("00") !== null) {
+            throw 'all-zero symbols must be null';
+        }
+        if (cBase32ToVec("o") !== null) {
+            throw 'o (maps to 0) must be null';
+        }
     }
 };

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,16 +19,18 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
+export declare const functionalscript: "0.30.0";
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.2";
-export declare const playwright = "1.60.0";
+export declare const deno = "2.8.3";
+export declare const playwright = "1.61.0";
 export declare const node: {
     readonly default: "26.3.0";
-    readonly others: readonly ["24.16.0"];
+    readonly node22: "22.22.3";
+    readonly node24: "24.16.0";
 };
-export declare const wasmtime = "45.0.0";
+export declare const wasmtime = "45.0.2";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260606.1";
+export declare const tsgo = "7.0.0-dev.20260615.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";

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

@@ -20,23 +20,29 @@ 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.30.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.2';
+export const deno = '2.8.3';
 // https://www.npmjs.com/package/playwright
-export const playwright = '1.60.0';
+export const playwright = '1.61.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.3.0',
-    others: ['24.16.0'],
+    node22: '22.22.3',
+    node24: '24.16.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '45.0.0';
+export const wasmtime = '45.0.2';
 // 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.20260606.1';
+export const tsgo = '7.0.0-dev.20260615.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/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 --allow-sys';
+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 run -A npm:functionalscript@${version} t` }),
     test({ run: 'deno install --frozen' }),
-    test({ run: 'deno task test' }),
-    ...extra,
+    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
 ]);

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

@@ -1,10 +1,13 @@
+/**
+ * Continuous integration helper commands for repository automation tasks.
+ *
+ * @module
+ */
 import { type Effect } from '../effects/module.f.ts';
 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,37 @@
  *
  * @module
  */
-import { utf8, utf8ToString } from "../text/module.f.js";
-import { validatePackageJsonText } from "../dev/package_json/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, writeUtf8File } 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 +41,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, '  ')))
+    return writeUtf8File('.github/workflows/ci.yml', 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,29 +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))
-]));
-const tsgoName = `@typescript/native-preview@${tsgo}`;
-export const nodeMainSteps = (extra) => nodeTests(node.default)([
-    // TypeScript Preview
-    install({ run: `npm cache add ${tsgoName}` }),
-    test({ run: `npx npm:${tsgoName}` }),
-    // extra
-    ...extra,
+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' }),
+    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,10 @@ 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;
     };
+    ubuntu: () => void;
 };