functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/cas/module.f.d.ts

@@ -33,6 +33,16 @@ export type Cas<O extends Operation> = {
     /** Lists all stored content hashes. */
     readonly list: () => Effect<O, readonly Vec[]>;
 };
+/**
+ * Drains a `Cas<O>.read` chunk stream into a single `Vec`. Used by any caller
+ * that needs the whole blob at once (an MCP `content: true` fetch, an Evo
+ * revision decode): the chunk stream is concatenated and an error item is
+ * surfaced as the result. A single `Vec` cannot exceed `maxLength` bits;
+ * concatenating past it would overflow the runtime's `bigint` constraint, so
+ * that case is surfaced as an error item too, rather than crashing the
+ * process.
+ */
+export declare const collectRead: <O extends Operation>(stream: List<O, IoResult<Vec>>) => Effect<O, IoResult<Vec>>;
 export type FileCas = Cas<FileCasOperation> & {
     url: (v: Vec) => string;
 };

package/{fs → fjs}/cas/module.f.js

@@ -3,16 +3,16 @@
  *
  * @module
  */
-import { sha256 } from "../crypto/sha2/module.f.js";
-import { join, normalize, parse } from "../path/module.f.js";
-import { empty, length, maxLengthBytes, msb, vec } from "../types/bit_vec/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { foldStep, forEachStep, okStep, pure } from "../effects/module.f.js";
-import { access, createExclusive, isNotFound, mkdir, now, randomInt, readBytes, readdir, rename, rm, stat, writeBytes, } from "../effects/node/module.f.js";
-import { toOption } from "../types/nullable/module.f.js";
-import { error, ok, unwrap } from "../types/result/module.f.js";
-import { splitAt } from "../types/string/module.f.js";
-import { nonEmpty, empty as elEmpty } from "../effects/list/module.f.js";
+import { sha256 } from '../crypto/sha2/module.f.js';
+import { join, normalize, parse } from '../path/module.f.js';
+import { empty, length, maxLength, maxLengthBytes, msb, vec } from '../types/bit_vec/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
+import { foldStep, forEachStep, okStep, pure } from '../effects/module.f.js';
+import { access, createExclusive, isNotFound, mkdir, now, randomInt, readBytes, readdir, rename, rm, stat, writeBytes, } from '../effects/node/module.f.js';
+import { toOption } from '../types/nullable/module.f.js';
+import { error, ok, unwrap } from '../types/result/module.f.js';
+import { splitAt } from '../types/string/module.f.js';
+import { nonEmpty, empty as elEmpty } from '../effects/list/module.f.js';
 const split2 = splitAt(2);
 const prefix = '.cas';
 /** Converts a content key to its sharded relative CAS file path. */
@@ -22,6 +22,32 @@ export const toPath = (key) => {
     const [b, c] = split2(bc);
     return join(prefix, a, b, c);
 };
+/**
+ * Drains a `Cas<O>.read` chunk stream into a single `Vec`. Used by any caller
+ * that needs the whole blob at once (an MCP `content: true` fetch, an Evo
+ * revision decode): the chunk stream is concatenated and an error item is
+ * surfaced as the result. A single `Vec` cannot exceed `maxLength` bits;
+ * concatenating past it would overflow the runtime's `bigint` constraint, so
+ * that case is surfaced as an error item too, rather than crashing the
+ * process.
+ */
+export const collectRead = (stream) => {
+    const loop = (acc) => (s) => s.step((node) => {
+        if (node === undefined) {
+            return pure(ok(acc));
+        }
+        const { first, tail } = node;
+        const [t, v] = first;
+        if (t === 'error') {
+            return pure(first);
+        }
+        if (length(acc) + length(v) > maxLength) {
+            return pure(error(`cas blob exceeds maximum vector length of ${maxLength} bits`));
+        }
+        return loop(msb.concat(acc)(v))(tail);
+    });
+    return loop(empty)(stream);
+};
 /** Maximum chunk size for streaming reads: the largest `Vec` the runtime allows. */
 const chunkBytes = Number(maxLengthBytes);
 /** Staging directory under the store root; GC and every uploader share it. */

package/{fs → fjs}/cas/proof.f.d.ts

@@ -2,9 +2,11 @@ import { type FileCasOperation } from './module.f.ts';
 import { type Effect } from '../effects/module.f.ts';
 import { type ReadFile, type WriteFile, type Rm, type Mkdir } from '../effects/node/module.f.ts';
 type TestOp = FileCasOperation | WriteFile | ReadFile | Rm | Mkdir;
+declare const testAddBigFile: () => Effect<TestOp, void>;
+declare const testAddAndGetBigFile: () => Effect<TestOp, void>;
 export declare const proof: {
-    addBigFile: () => Effect<TestOp, void>;
-    addAndGetBigFile: () => Effect<TestOp, void>;
+    addBigFile: typeof testAddBigFile;
+    addAndGetBigFile: typeof testAddAndGetBigFile;
     casWriteRead: () => void;
     casReadMissingShard: () => void;
     casWriteMultiChunk: () => void;
@@ -14,5 +16,9 @@ export declare const proof: {
     casWriteGcReclaimsExpired: () => void;
     casUploadSuccess: () => void;
     casUploadFailureKeepsSource: () => void;
+    collectReadDrainsChunks: () => void;
+    collectReadPropagatesErrorItem: () => void;
+    collectReadOverflow: () => void;
+    casListPropagatesNonNotFoundAccessError: () => void;
 };
 export {};

package/{fs → fjs}/cas/proof.f.js

@@ -1,13 +1,14 @@
-import { length, maxLength, msb, vec, vec8 } from "../types/bit_vec/module.f.js";
-import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
-import { fileCas, casAddFile, casUpload } from "./module.f.js";
-import { pure } from "../effects/module.f.js";
-import { mkdir, writeFile, rm, readFile, access } from "../effects/node/module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
-import { join } from "../path/module.f.js";
-import { nonEmpty, empty } from "../effects/list/module.f.js";
+import { length, maxLength, msb, vec, vec8 } from '../types/bit_vec/module.f.js';
+import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
+import { computeSync, sha256 } from '../crypto/sha2/module.f.js';
+import { fileCas, casAddFile, collectRead, casUpload } from './module.f.js';
+import { decode, pure } from '../effects/module.f.js';
+import { mkdir, writeFile, rm, readFile, access } from '../effects/node/module.f.js';
+import { error, ok } from '../types/result/module.f.js';
+import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
+import { join } from '../path/module.f.js';
+import { nonEmpty, empty } from '../effects/list/module.f.js';
+import { assert, assertEq, assertNotNullish } from '../asserts/module.f.js';
 const testDir = './test-cas-cli';
 // Create a 128 KiB big file content (at the max Vec size limit)
 // This tests the boundary where files are at the chunk size limit
@@ -36,10 +37,7 @@ const testAddBigFile = () => mkdir(testDir, { recursive: true }).step(() => {
             }
             // Verify hash can be encoded/decoded
             const hashCBase32 = vecToCBase32(hash);
-            const decodedHash = cBase32ToVec(hashCBase32);
-            if (decodedHash === null) {
-                throw new Error('Failed to decode hash from base32');
-            }
+            assertNotNullish(cBase32ToVec(hashCBase32), new Error('Failed to decode hash from base32'));
             return rm(testDir).step(() => pure(undefined));
         });
     });
@@ -90,16 +88,10 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = nonEmpty(ok(content), empty());
         const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
         const hash = writeResult[1];
-        if (length(hash) !== 256n) {
-            throw ['expected 256-bit hash', length(hash)];
-        }
-        if (msb.cmp(hash)(computeSync(sha256)([content])) !== 0) {
-            throw 'write hash mismatch';
-        }
+        assertEq(length(hash), 256n, ['expected 256-bit hash', length(hash)]);
+        assertEq(msb.cmp(hash)(computeSync(sha256)([content])), 0, 'write hash mismatch');
         const drain = (acc) => (stream) => stream.step((node) => {
             if (node === undefined) {
                 return pure(ok(acc));
@@ -111,24 +103,16 @@ export const proof = {
             return drain([...acc, first[1]])(tail);
         });
         const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
-        if (msb.cmp(msb.listToVec(readResult[1]))(content) !== 0) {
-            throw 'read content mismatch';
-        }
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(content), 0, 'read content mismatch');
     },
     casReadMissingShard: () => {
         // A missing shard surfaces as an explicit error *item*, never as end-of-stream.
         const c = fileCas(sha256)('.');
         const hash = computeSync(sha256)([vec8(0x2an)]);
         const node = virtual(emptyState)(c.read(hash))[1];
-        if (node === undefined) {
-            throw 'missing shard must not be EOF';
-        }
-        if (node.first[0] !== 'error') {
-            throw ['expected error item', node.tail];
-        }
+        assert(node !== undefined, 'missing shard must not be EOF');
+        assert(node.first[0] === 'error', ['expected error item', node.tail]);
     },
     casWriteMultiChunk: () => {
         // A multi-chunk payload streams through `writeBytes` chunk-by-chunk (the lease is
@@ -138,13 +122,9 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = chunks.reduceRight((tail, chunk) => nonEmpty(ok(chunk), tail), empty());
         const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
+        assert(writeResult[0] === 'ok', ['expected write ok', writeResult]);
         const hash = writeResult[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'multi-chunk write hash mismatch';
-        }
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'multi-chunk write hash mismatch');
         const drain = (acc) => (stream) => stream.step((node) => {
             if (node === undefined) {
                 return pure(ok(acc));
@@ -156,13 +136,9 @@ export const proof = {
             return drain([...acc, first[1]])(tail);
         });
         const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
+        assert(readResult[0] === 'ok', ['expected read ok', readResult]);
         const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2]);
-        if (msb.cmp(msb.listToVec(readResult[1]))(expected) !== 0) {
-            throw 'multi-chunk read content mismatch';
-        }
+        assertEq(msb.cmp(msb.listToVec(readResult[1]))(expected), 0, 'multi-chunk read content mismatch');
     },
     casWriteDedup: () => {
         // Same content ⇒ same hash; the second upload's replace-`rename` publishes over the
@@ -172,16 +148,10 @@ export const proof = {
         const payload = () => nonEmpty(ok(content), empty());
         const [state1, w1] = virtual(emptyState)(c.write(payload()));
         const [state2, w2] = virtual(state1)(c.write(payload()));
-        if (w1[0] !== 'ok' || w2[0] !== 'ok') {
-            throw ['expected both writes ok', w1, w2];
-        }
-        if (msb.cmp(w1[1])(w2[1]) !== 0) {
-            throw 'dedup hash mismatch';
-        }
+        assert(!(w1[0] !== 'ok' || w2[0] !== 'ok'), ['expected both writes ok', w1, w2]);
+        assertEq(msb.cmp(w1[1])(w2[1]), 0, 'dedup hash mismatch');
         const [, hashes] = virtual(state2)(c.list());
-        if (hashes.length !== 1) {
-            throw ['expected one shard after dedup', hashes.length];
-        }
+        assertEq(hashes.length, 1, ['expected one shard after dedup', hashes.length]);
     },
     casWriteErrorItemAborts: () => {
         // An error item mid-stream deletes the partial staging file and fails; nothing is
@@ -191,13 +161,9 @@ export const proof = {
         const errItem = error({ code: 'BOOM' });
         const payload = nonEmpty(okItem, nonEmpty(errItem, empty()));
         const [state1, result] = virtual(emptyState)(c.write(payload));
-        if (result[0] !== 'error') {
-            throw ['expected write error', result];
-        }
+        assert(result[0] === 'error', ['expected write error', result]);
         const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on abort', hashes];
-        }
+        assertEq(hashes.length, 0, ['expected nothing published on abort', hashes]);
     },
     casWriteReadExceedsMaxLength: () => {
         // The point of streaming: a payload larger than a single `Vec`'s `maxLength`
@@ -211,13 +177,9 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const payload = chunks.reduceRight((tl, chunk) => nonEmpty(ok(chunk), tl), empty());
         const [state1, w] = virtual(emptyState)(c.write(payload));
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
+        assert(w[0] === 'ok', ['expected write ok', w]);
         const hash = w[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'oversized write hash mismatch';
-        }
+        assertEq(msb.cmp(hash)(computeSync(sha256)(chunks)), 0, 'oversized write hash mismatch');
         // Fold the read stream straight into a fresh SHA-2 state — never one `Vec`.
         const rehash = (state) => (stream) => stream.step((node) => {
             if (node === undefined) {
@@ -230,12 +192,8 @@ export const proof = {
             return rehash(sha256.append(first[1])(state))(tail);
         });
         const [, readBack] = virtual(state1)(rehash(sha256.init)(c.read(hash)));
-        if (readBack[0] !== 'ok') {
-            throw ['expected read ok', readBack];
-        }
-        if (msb.cmp(readBack[1])(hash) !== 0) {
-            throw 'oversized read-back hash mismatch';
-        }
+        assert(readBack[0] === 'ok', ['expected read ok', readBack]);
+        assertEq(msb.cmp(readBack[1])(hash), 0, 'oversized read-back hash mismatch');
     },
     casWriteGcReclaimsExpired: () => {
         // A staging file whose deadline is in the past is reclaimed by the GC that `write`
@@ -250,45 +208,78 @@ export const proof = {
         const c = fileCas(sha256)('.');
         const x = c.write(nonEmpty(ok(content), empty()));
         const [state1, w] = virtual(state0)(x);
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
+        assert(w[0] === 'ok', ['expected write ok', w]);
         const [, present] = virtual(state1)(access(stalePath));
-        if (present[0] !== 'error') {
-            throw 'expected GC to reclaim the expired staging file';
-        }
+        assert(present[0] === 'error', 'expected GC to reclaim the expired staging file');
     },
     casUploadSuccess: () => {
         // A successful upload returns the hash and deletes the source file from cas_upload/.
         const content = vec8(0x2an);
         const state0 = { ...emptyState, root: { 'cas_upload': { 'myfile': [content] } } };
         const [state1, result] = virtual(state0)(casUpload('.')('myfile'));
-        if (result[0] !== 'ok') {
-            throw ['expected casUpload ok', result];
-        }
-        if (length(result[1]) !== 256n) {
-            throw ['expected 256-bit hash', length(result[1])];
-        }
+        assert(result[0] === 'ok', ['expected casUpload ok', result]);
+        assertEq(length(result[1]), 256n, ['expected 256-bit hash', length(result[1])]);
         // Source must be deleted after successful publish.
         const srcPath = join('.', 'cas_upload', 'myfile');
         const [, srcAccess] = virtual(state1)(access(srcPath));
-        if (srcAccess[0] !== 'error') {
-            throw 'expected source to be deleted after successful upload';
-        }
+        assert(srcAccess[0] === 'error', 'expected source to be deleted after successful upload');
     },
     casUploadFailureKeepsSource: () => {
         // A missing source file causes write to fail; casUpload returns error and the
         // source is left in place (trivially: it was never there, but the upload is not published).
         const state0 = { ...emptyState, root: {} };
         const [state1, result] = virtual(state0)(casUpload('.')('nonexistent'));
-        if (result[0] !== 'error') {
-            throw ['expected casUpload to fail on missing source', result];
-        }
+        assert(result[0] === 'error', ['expected casUpload to fail on missing source', result]);
         // Nothing published to the store.
         const c = fileCas(sha256)('.');
         const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on failed upload', hashes];
+        assertEq(hashes.length, 0, ['expected nothing published on failed upload', hashes]);
+    },
+    collectReadDrainsChunks: () => {
+        // The common path: every chunk is `ok`, so collectRead concatenates them all
+        // and returns the whole blob as one `Vec`.
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(ok(vec8(0x22n)), empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'ok');
+    },
+    collectReadPropagatesErrorItem: () => {
+        // An error item mid-stream short-circuits collectRead with that same error.
+        const boom = error('boom');
+        const stream = nonEmpty(ok(vec8(0x11n)), nonEmpty(boom, empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'error');
+        assertEq(d.result[1], 'boom');
+    },
+    // A single `Vec` cannot exceed `maxLength` bits — feed a pure stream whose second
+    // chunk pushes the running total just over the limit so the overflow guard fires
+    // without any real I/O.
+    collectReadOverflow: () => {
+        const half = maxLength / 2n;
+        const v1 = vec(half)(0n);
+        const v2 = vec(half + 1n)(0n);
+        const stream = nonEmpty(ok(v1), nonEmpty(ok(v2), empty()));
+        const d = decode(collectRead(stream));
+        assert(d.done, 'expected collectRead to finish without issuing a command');
+        assertEq(d.result[0], 'error');
+    },
+    casListPropagatesNonNotFoundAccessError: () => {
+        // A non-ENOENT `access` failure (permissions, corruption) is a genuine storage
+        // error and must propagate out of `list`, not be swallowed as an empty store.
+        const c = fileCas(sha256)('.');
+        const boom = { code: 'EACCES' };
+        const d = decode(c.list());
+        assert(!d.done, 'expected list() to issue an access command first');
+        assertEq(d.command, 'access');
+        const continuation = d.continuation;
+        let threw;
+        try {
+            continuation(error(boom));
+        }
+        catch (e) {
+            threw = e;
         }
+        assertEq(threw, boom);
     },
 };

package/{fs → fjs}/ci/bun/module.f.js

@@ -4,8 +4,8 @@
  *
  * @module
  */
-import { bun } from "../config/module.f.js";
-import { clean, install, test, uses } from "../common/module.f.js";
+import { bun } from '../config/module.f.js';
+import { clean, install, test, uses } from '../common/module.f.js';
 export const bunSteps = (version) => clean([
     install(uses('oven-sh/setup-bun', { 'bun-version': bun })),
     install({ run: `bun install -g functionalscript@${version}` }),

package/{fs → fjs}/ci/common/module.f.d.ts

@@ -7,9 +7,9 @@
  */
 import { actions, images } from '../config/module.f.ts';
 import { type Ts } from '../../types/rtti/ts/module.f.ts';
-export declare const os: readonly ["ubuntu", "macos", "windows"];
+export declare const os: readonly ['ubuntu', 'macos', 'windows'];
 export type Os = typeof os[number];
-export declare const architecture: readonly ["intel", "arm"];
+export declare const architecture: readonly ['intel', 'arm'];
 export type Architecture = typeof architecture[number];
 export type Image = typeof images[Os][Architecture];
 export declare const stepSchema: {

package/{fs → fjs}/ci/common/module.f.js

@@ -5,10 +5,10 @@
  *
  * @module
  */
-import { actions, images } from "../config/module.f.js";
-import { option, array, record, string } from "../../types/rtti/module.f.js";
-import {} from "../../types/rtti/ts/module.f.js";
-import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
+import { actions, images } from '../config/module.f.js';
+import { option, array, record, string } from '../../types/rtti/module.f.js';
+import {} from '../../types/rtti/ts/module.f.js';
+import { parse as rttiParse } from '../../types/rtti/parse/module.f.js';
 export const os = ['ubuntu', 'macos', 'windows'];
 export const architecture = ['intel', 'arm'];
 export const stepSchema = {

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

@@ -0,0 +1,42 @@
+/**
+ * Centralized version pins and OS images used by the CI generator: runner
+ * images, tool versions (Bun, Deno, Playwright, Rust, Node, Wasmtime, Wasmer,
+ * TSGO).
+ *
+ * @module
+ */
+export declare const images: {
+    readonly ubuntu: {
+        readonly intel: 'ubuntu-26.04';
+        readonly arm: 'ubuntu-26.04-arm';
+    };
+    readonly macos: {
+        readonly intel: 'macos-26-intel';
+        readonly arm: 'macos-26';
+    };
+    readonly windows: {
+        readonly intel: 'windows-2025';
+        readonly arm: 'windows-11-arm';
+    };
+};
+export declare const functionalscript: '0.37.0';
+export declare const bun = "1.3.14";
+export declare const deno = "2.9.3";
+export declare const playwright = "1.61.1";
+export declare const node: {
+    readonly default: '26.5.0';
+    readonly node22: '22.23.1';
+    readonly node24: '24.18.0';
+};
+export declare const wasmtime = "47.0.2";
+export declare const wasmer = "7.2.0";
+export declare const actions: {
+    readonly 'actions/checkout': 'v7';
+    readonly 'actions/setup-node': 'v7.0.0';
+    readonly 'actions/cache': 'v6.1.0';
+    readonly 'denoland/setup-deno': 'v2.0.5';
+    readonly 'oven-sh/setup-bun': 'v2.2.0';
+    readonly 'bytecodealliance/actions/wasmtime/setup': 'v1.1.3';
+    readonly 'wasmerio/setup-wasmer': 'v3.1';
+    readonly 'dtolnay/rust-toolchain': '1.97.1';
+};

package/{fs → fjs}/ci/config/module.f.js

@@ -24,25 +24,23 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.35.2';
+export const functionalscript = '0.37.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.9.1';
+export const deno = '2.9.3';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.61.1';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.4.0',
+    default: '26.5.0',
     node22: '22.23.1',
     node24: '24.18.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '46.0.1';
+export const wasmtime = '47.0.2';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.2.0';
-// https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260707.2';
 // 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]}` ``.
@@ -51,7 +49,7 @@ export const actions = {
     // https://github.com/marketplace/actions/checkout
     'actions/checkout': 'v7',
     // https://github.com/marketplace/actions/setup-node-js-environment
-    'actions/setup-node': 'v6.4.0',
+    'actions/setup-node': 'v7.0.0',
     // https://github.com/marketplace/actions/cache
     'actions/cache': 'v6.1.0',
     // https://github.com/marketplace/actions/setup-deno
@@ -63,5 +61,5 @@ export const actions = {
     // https://github.com/wasmerio/setup-wasmer
     'wasmerio/setup-wasmer': 'v3.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.96.1',
+    'dtolnay/rust-toolchain': '1.97.1',
 };

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

@@ -0,0 +1,20 @@
+/**
+ * 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';
+const denoTest = 'deno test --allow-read --allow-env --allow-sys';
+export const denoSteps = (version) => clean([
+    install(uses('denoland/setup-deno', { 'deno-version': deno })),
+    // We need --minimum-dependency-age=0 for functionalscript because we would like to use
+    // the latest version of the package even if it is not yet 24 hours old,
+    // which is the default minimum dependency age for Deno installs.
+    // This way we can test the latest version of the package in CI without waiting for 24 hours.
+    install({ run: `deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${version}` }),
+    test({ run: `deno run -A --minimum-dependency-age=0 npm:functionalscript@${version} t` }),
+    test({ run: 'deno install --frozen' }),
+    test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
+]);

package/{fs → fjs}/ci/module.f.js

@@ -3,15 +3,15 @@
  *
  * @module
  */
-import { pure } from "../effects/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";
+import { pure } from '../effects/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) => (o) => (a) => {
     const id = `${o}-${a}`;
     const image = images[o][a];

package/{fs → fjs}/ci/node/module.f.d.ts

@@ -3,4 +3,4 @@ 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 nodeMainSteps: (version: string) => readonly MetaStep[];
+export declare const nodeMainSteps: typeof platformNodeSteps;

package/{fs → fjs}/ci/node/module.f.js

@@ -1,11 +1,11 @@
 /**
  * CI step builders for Node.js: setup-node installation, platform smoke tests,
- * per-version canonical jobs, and the main TSGO step.
+ * per-version canonical jobs.
  *
  * @module
  */
-import { node, tsgo } from "../config/module.f.js";
-import { clean, install, test, ubuntuArm, uses } from "../common/module.f.js";
+import { node } from '../config/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) => [
@@ -33,9 +33,7 @@ const node24Steps = clean([
 ]);
 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' }),
 ]);

package/{fs → fjs}/ci/playwright/module.f.js

@@ -4,9 +4,9 @@
  *
  * @module
  */
-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";
+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.arm;
 export const playwrightJob = {
     'runs-on': playwrightImage,