functionalscript 0.32.3 → 0.33.0

package/fs/cas/proof.f.js

@@ -1,25 +1,17 @@
-import { cas, commands } from "./module.f.js";
-import { sha256 } from "../crypto/sha2/module.f.js";
+import { commands } from "./module.f.js";
+import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
 import { pure } from "../effects/module.f.js";
 import { run } from "../effects/mock/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { dispatch } from "../cli/module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+import { assert } from "../asserts/module.f.js";
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const main = dispatch(commands);
 export const proof = {
     mainAdd: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode !== 0) {
             throw ['expected exit 0', exitCode];
@@ -39,7 +31,7 @@ export const proof = {
     },
     mainGetFound: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         if (exitCode1 !== 0) {
             throw ['expected add exit 0', exitCode1];
@@ -53,7 +45,7 @@ export const proof = {
     mainGetNotFound: () => {
         // valid cBase32 hash that has not been stored
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         const hashStr = state1.stdout.trim();
         // use an empty store so the hash is not found
@@ -85,7 +77,7 @@ export const proof = {
     },
     mainList: () => {
         const content = vec8(0x2an);
-        const state = { ...emptyState, root: { myfile: content } };
+        const state = { ...emptyState, root: { myfile: [content] } };
         const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])));
         const [, exitCode] = virtual(state1)(main(makeOptions(['list'])));
         if (exitCode !== 0) {
@@ -106,7 +98,7 @@ export const proof = {
     mainListCorruptStore: () => {
         // `.cas` exists but is a file, not a directory: a real storage error
         // that must surface, not be masked as an empty list.
-        const state = { ...emptyState, root: { '.cas': vec8(0x2an) } };
+        const state = { ...emptyState, root: { '.cas': [vec8(0x2an)] } };
         let threw = false;
         try {
             virtual(state)(main(makeOptions(['list'])));
@@ -137,26 +129,25 @@ export const proof = {
         }
     },
     casWrite: () => {
-        const store = {
+        const c = {
             read: (_key) => pure(undefined),
-            write: (_key, _value) => pure(undefined),
+            write: (value) => pure(computeSync(sha256)([value])),
             list: () => pure([]),
         };
-        const c = cas(sha256)(store);
         const [, hash] = run({})(undefined)(c.write(empty));
         // sha256 of empty input produces a 256-bit hash
+        assert(hash !== undefined);
         if (length(hash) !== 256n) {
             throw ['expected 256-bit hash', length(hash)];
         }
     },
     casReadPassthrough: () => {
         const stored = empty;
-        const store = {
+        const c = {
             read: (_key) => pure(stored),
-            write: (_key, _value) => pure(undefined),
+            write: (value) => pure(computeSync(sha256)([value])),
             list: () => pure([stored]),
         };
-        const c = cas(sha256)(store);
         const [, readResult] = run({})(undefined)(c.read(empty));
         if (readResult !== stored) {
             throw ['read should pass through', readResult];

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

@@ -19,20 +19,20 @@ export declare const images: {
         readonly arm: "windows-11-arm";
     };
 };
-export declare const functionalscript: "0.30.0";
+export declare const functionalscript: "0.32.4";
 export declare const bun = "1.3.14";
 export declare const deno = "2.8.3";
 export declare const playwright = "1.61.0";
 export declare const node: {
-    readonly default: "26.3.0";
-    readonly node22: "22.22.3";
-    readonly node24: "24.16.0";
+    readonly default: "26.3.1";
+    readonly node22: "22.23.0";
+    readonly node24: "24.17.0";
 };
 export declare const wasmtime = "45.0.2";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260615.1";
+export declare const tsgo = "7.0.0-dev.20260620.1";
 export declare const actions: {
-    readonly 'actions/checkout': "v6";
+    readonly 'actions/checkout': "v7";
     readonly 'actions/setup-node': "v6";
     readonly 'actions/cache': "v5";
     readonly 'denoland/setup-deno': "v2";

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

@@ -24,7 +24,7 @@ export const images = {
 // 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';
+export const functionalscript = '0.32.4';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
@@ -33,23 +33,23 @@ export const deno = '2.8.3';
 export const playwright = '1.61.0';
 // https://nodejs.org/en/download
 export const node = {
-    default: '26.3.0',
-    node22: '22.22.3',
-    node24: '24.16.0',
+    default: '26.3.1',
+    node22: '22.23.0',
+    node24: '24.17.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 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.20260615.1';
+export const tsgo = '7.0.0-dev.20260620.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]}` ``.
 // Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
 export const actions = {
     // https://github.com/marketplace/actions/checkout
-    'actions/checkout': 'v6',
+    'actions/checkout': 'v7',
     // https://github.com/marketplace/actions/setup-node-js-environment
     'actions/setup-node': 'v6',
     // https://github.com/marketplace/actions/cache

package/fs/ci/proof.f.js

@@ -14,18 +14,20 @@ const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
         '.github': { workflows: {} },
-        ...(packageJson !== undefined ? { 'package.json': utf8(packageJson) } : {}),
-        ...(rust ? { 'Cargo.toml': emptyVec } : {}),
+        ...(packageJson !== undefined ? { 'package.json': [utf8(packageJson)] } : {}),
+        ...(rust ? { 'Cargo.toml': [emptyVec] } : {}),
     },
 });
 const workflow = (state) => {
     const dotGithub = state.root['.github'];
-    assert(typeof dotGithub === 'object', dotGithub);
+    assert(typeof dotGithub === 'object' && !Array.isArray(dotGithub), dotGithub);
     const workflows = dotGithub['workflows'];
-    assert(typeof workflows === 'object', workflows);
+    assert(typeof workflows === 'object' && !Array.isArray(workflows), workflows);
     const file = workflows['ci.yml'];
-    assert(isVec(file), file);
-    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
+    if (!Array.isArray(file) || file.length === 0) {
+        throw file;
+    }
+    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file[0]))));
 };
 const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));

package/fs/cli/proof.f.js

@@ -1,17 +1,7 @@
 import { pure } from "../effects/module.f.js";
-import {} from "../effects/node/module.f.js";
-import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
+import { defaultNodeProgramOptions, emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { dispatch } from "./module.f.js";
-const makeOptions = (args) => ({
-    args,
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY: false }, stderr: { isTTY: false } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const echoCommands = [
     {
         names: ['echo', 'e'],

package/fs/djs/parser/module.f.d.ts

@@ -6,13 +6,8 @@
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
-import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
-export type ParseContext = {
-    readonly complete: OrderedMap<Result<AstModule, string>>;
-    readonly stack: List<string>;
-};
 export type ParseError = {
     readonly message: string;
     readonly metadata: TokenMetadata | null;

package/fs/djs/proof.f.js

@@ -1,13 +1,12 @@
 import { compile } from "./module.f.js";
 import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
-import { isVec } from "../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {
     const file = root[path];
-    if (!isVec(file)) {
+    if (!Array.isArray(file) || file.length === 0) {
         throw `${path} is not a file`;
     }
-    return utf8ToString(file);
+    return utf8ToString(file[0]);
 };
 export const proof = {
     tooFewArgs: {
@@ -31,7 +30,7 @@ export const proof = {
         },
     },
     success: () => {
-        const root = { 'input.f.js': utf8('export default 42') };
+        const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;
@@ -42,7 +41,7 @@ export const proof = {
         }
     },
     jsonOutput: () => {
-        const root = { 'input.f.js': utf8('export default 42') };
+        const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.json']));
         if (code !== 0) {
             throw code;
@@ -62,7 +61,7 @@ export const proof = {
         }
     },
     parseError: () => {
-        const root = { 'bad.f.js': utf8('export default @') };
+        const root = { 'bad.f.js': [utf8('export default @')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['bad.f.js', 'output.f.js']));
         if (code !== 0) {
             throw code;

package/fs/djs/serializer/module.f.d.ts

@@ -8,9 +8,7 @@ import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export declare const undefinedSerialize: string[];
 type RefCounter = readonly [number, number];
-type Entry = ObjectEntry<Unknown>;
-type Entries = List<Entry>;
-type MapEntries = (entries: Entries) => Entries;
+type MapEntries = (entries: List<ObjectEntry<Unknown>>) => List<ObjectEntry<Unknown>>;
 type Refs = ReadonlyMap<Unknown, RefCounter>;
 export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: Unknown) => List<string>;
 export declare const stringify: (sort: MapEntries) => (djs: Unknown) => string;

package/fs/djs/tokenizer-new/module.f.js

@@ -20,7 +20,8 @@ export const jsGrammar = () => {
             escape: [
                 '\\',
                 {
-                    ...set('"\\/bfnrt'),
+                    ...set('"\\bfnrt'),
+                    solidus: '/',
                     u: [
                         'u',
                         ...repeat(4)({

package/fs/djs/tokenizer-new/proof.f.d.ts

@@ -3,6 +3,7 @@ export declare const proof: {
     tokenizer: (() => void)[];
     djs: (() => void)[];
     operators: (() => void)[];
+    ws: (() => void)[];
     throw: {
         parse: () => void;
     };

package/fs/djs/tokenizer-new/proof.f.js

@@ -38,6 +38,8 @@ const scanFunc = (input, state) => {
             return [null, state];
         if (isNlTag(input) && isWsTag(state[0]))
             return [null, [input, []]];
+        if (isWsTag(input) && isNlTag(state[0]))
+            return [null, state];
         const newState = [input, []];
         if (state[0] === '') {
             return [null, newState];
@@ -53,7 +55,7 @@ const operatorTags = new Set([
     '>>>=', '>>>', '>>=', '>>', '>=', '>',
     '<<<=', '<<<', '<<=', '<<', '<=', '<',
     '+=', '++', '+', '-=', '--', '-',
-    '**=', '**', '*=', '*', '/=', '%=', '%',
+    '**=', '**', '*=', '*', '/=', '/', '%=', '%', // TODO: '/' here causes multi-char line comments (e.g. //ab\n) to fall through as two '/' operator tokens because the oneline rule only consumes one non-newline character (option vs repeat0Plus). Fix the comment rule to use repeat0Plus, or make filterFunc distinguish operator-branch '/' from slash characters inside comments.
     '&&=', '&&', '&=', '&', '||=', '||', '|=', '|',
     '^=', '^', '~', '??=', '??', '?.', '?',
     '[', ']', '{', '}', '(', ')', ',', ':'
@@ -664,76 +666,108 @@ export const proof = {
         //         const result = tokenizeString('=a')
         //         if (result !== '[{"kind":"="},{"kind":"id","value":"a"},{"kind":"eof"}]') { throw result }
         //     },
-        //     () => {
-        //         const result = tokenizeString('-')
-        //         if (result !== '[{"kind":"-"},{"kind":"eof"}]') { throw result }
-        //     },
+        () => {
+            const result = tokenizeString('-');
+            if (result !== '[{"kind":"-"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
         //     () => {
         //         const result = tokenizeString('1*2')
         //         if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"kind":"*"},{"bf":[2n,0],"kind":"number","value":"2"},{"kind":"eof"}]') { throw result }
         //     },
-        //     () => {
-        //         const result = tokenizeString('( )')
-        //         if (result !== '[{"kind":"("},{"kind":"ws"},{"kind":")"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('== != === !== > >= < <=')
-        //         if (result !== '[{"kind":"=="},{"kind":"ws"},{"kind":"!="},{"kind":"ws"},{"kind":"==="},{"kind":"ws"},{"kind":"!=="},{"kind":"ws"},{"kind":">"},{"kind":"ws"},{"kind":">="},{"kind":"ws"},{"kind":"<"},{"kind":"ws"},{"kind":"<="},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('+ - * / % ++ -- **')
-        //         if (result !== '[{"kind":"+"},{"kind":"ws"},{"kind":"-"},{"kind":"ws"},{"kind":"*"},{"kind":"ws"},{"kind":"/"},{"kind":"ws"},{"kind":"%"},{"kind":"ws"},{"kind":"++"},{"kind":"ws"},{"kind":"--"},{"kind":"ws"},{"kind":"**"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('= += -= *= /= %= **=')
-        //         if (result !== '[{"kind":"="},{"kind":"ws"},{"kind":"+="},{"kind":"ws"},{"kind":"-="},{"kind":"ws"},{"kind":"*="},{"kind":"ws"},{"kind":"/="},{"kind":"ws"},{"kind":"%="},{"kind":"ws"},{"kind":"**="},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('& | ^ ~ << >> >>>')
-        //         if (result !== '[{"kind":"&"},{"kind":"ws"},{"kind":"|"},{"kind":"ws"},{"kind":"^"},{"kind":"ws"},{"kind":"~"},{"kind":"ws"},{"kind":"<<"},{"kind":"ws"},{"kind":">>"},{"kind":"ws"},{"kind":">>>"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('&= |= ^= <<= >>= >>>=')
-        //         if (result !== '[{"kind":"&="},{"kind":"ws"},{"kind":"|="},{"kind":"ws"},{"kind":"^="},{"kind":"ws"},{"kind":"<<="},{"kind":"ws"},{"kind":">>="},{"kind":"ws"},{"kind":">>>="},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('&& || ! ??')
-        //         if (result !== '[{"kind":"&&"},{"kind":"ws"},{"kind":"||"},{"kind":"ws"},{"kind":"!"},{"kind":"ws"},{"kind":"??"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('&&= ||= ??=')
-        //         if (result !== '[{"kind":"&&="},{"kind":"ws"},{"kind":"||="},{"kind":"ws"},{"kind":"??="},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('? ?. . =>')
-        //         if (result !== '[{"kind":"?"},{"kind":"ws"},{"kind":"?."},{"kind":"ws"},{"kind":"."},{"kind":"ws"},{"kind":"=>"},{"kind":"eof"}]') { throw result }
-        //     },
-        // ],
-        // ws: [
-        //     () => {
-        //         const result = tokenizeString(' ')
-        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('\t')
-        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString(' \t')
-        //         if (result !== '[{"kind":"ws"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('\n')
-        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString('\r')
-        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-        //     },
-        //     () => {
-        //         const result = tokenizeString(' \t\n\r ')
-        //         if (result !== '[{"kind":"nl"},{"kind":"eof"}]') { throw result }
-        //     },
+        () => {
+            const result = tokenizeString('( )');
+            if (result !== '[{"kind":"("},{"kind":"ws"},{"kind":")"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('== != === !== > >= < <=');
+            if (result !== '[{"kind":"=="},{"kind":"ws"},{"kind":"!="},{"kind":"ws"},{"kind":"==="},{"kind":"ws"},{"kind":"!=="},{"kind":"ws"},{"kind":">"},{"kind":"ws"},{"kind":">="},{"kind":"ws"},{"kind":"<"},{"kind":"ws"},{"kind":"<="},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('+ - * / % ++ -- **');
+            if (result !== '[{"kind":"+"},{"kind":"ws"},{"kind":"-"},{"kind":"ws"},{"kind":"*"},{"kind":"ws"},{"kind":"/"},{"kind":"ws"},{"kind":"%"},{"kind":"ws"},{"kind":"++"},{"kind":"ws"},{"kind":"--"},{"kind":"ws"},{"kind":"**"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('= += -= *= /= %= **=');
+            if (result !== '[{"kind":"="},{"kind":"ws"},{"kind":"+="},{"kind":"ws"},{"kind":"-="},{"kind":"ws"},{"kind":"*="},{"kind":"ws"},{"kind":"/="},{"kind":"ws"},{"kind":"%="},{"kind":"ws"},{"kind":"**="},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('& | ^ ~ << >> >>>');
+            if (result !== '[{"kind":"&"},{"kind":"ws"},{"kind":"|"},{"kind":"ws"},{"kind":"^"},{"kind":"ws"},{"kind":"~"},{"kind":"ws"},{"kind":"<<"},{"kind":"ws"},{"kind":">>"},{"kind":"ws"},{"kind":">>>"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('&= |= ^= <<= >>= >>>=');
+            if (result !== '[{"kind":"&="},{"kind":"ws"},{"kind":"|="},{"kind":"ws"},{"kind":"^="},{"kind":"ws"},{"kind":"<<="},{"kind":"ws"},{"kind":">>="},{"kind":"ws"},{"kind":">>>="},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('&& || ! ??');
+            if (result !== '[{"kind":"&&"},{"kind":"ws"},{"kind":"||"},{"kind":"ws"},{"kind":"!"},{"kind":"ws"},{"kind":"??"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('&&= ||= ??=');
+            if (result !== '[{"kind":"&&="},{"kind":"ws"},{"kind":"||="},{"kind":"ws"},{"kind":"??="},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('? ?. . =>');
+            if (result !== '[{"kind":"?"},{"kind":"ws"},{"kind":"?."},{"kind":"ws"},{"kind":"."},{"kind":"ws"},{"kind":"=>"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+    ],
+    ws: [
+        () => {
+            const result = tokenizeString(' ');
+            if (result !== '[{"kind":"ws"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('\t');
+            if (result !== '[{"kind":"ws"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString(' \t');
+            if (result !== '[{"kind":"ws"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('\n');
+            if (result !== '[{"kind":"nl"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString('\r');
+            if (result !== '[{"kind":"nl"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = tokenizeString(' \t\n\r ');
+            if (result !== '[{"kind":"nl"},{"kind":"eof"}]') {
+                throw result;
+            }
+        },
     ],
     // id: [
     //     () => {

package/fs/djs/transpiler/proof.f.js

@@ -9,7 +9,7 @@ const run = (root) => (path) => {
 };
 export const proof = {
     parse: () => {
-        const result = run({ a: utf8('export default 1') })('a');
+        const result = run({ a: [utf8('export default 1')] })('a');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -19,7 +19,7 @@ export const proof = {
         }
     },
     parseWithSubModule: () => {
-        const result = run({ a: { b: utf8('import c from "c"\nexport default c'), c: utf8('export default 2') } })('a/b');
+        const result = run({ a: { b: [utf8('import c from "c"\nexport default c')], c: [utf8('export default 2')] } })('a/b');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -30,10 +30,10 @@ export const proof = {
     },
     parseWithSubModules: () => {
         const result = run({
-            a: utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
-            b: utf8('import d from "d"\nexport default [0,d]'),
-            c: utf8('import d from "d"\nexport default [1,d]'),
-            d: utf8('export default 2'),
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import d from "d"\nexport default [0,d]')],
+            c: [utf8('import d from "d"\nexport default [1,d]')],
+            d: [utf8('export default 2')],
         })('a');
         if (result[0] === 'error') {
             throw result[1];
@@ -44,7 +44,7 @@ export const proof = {
         }
     },
     parseWithFileNotFoundError: () => {
-        const result = run({ a: utf8('import b from "b"\nexport default b') })('a');
+        const result = run({ a: [utf8('import b from "b"\nexport default b')] })('a');
         if (result[0] !== 'error') {
             throw result;
         }
@@ -54,9 +54,9 @@ export const proof = {
     },
     parseWithCycleError: () => {
         const result = run({
-            a: utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
-            b: utf8('import c from "c"\nexport default c'),
-            c: utf8('import b from "b"\nexport default b'),
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import c from "c"\nexport default c')],
+            c: [utf8('import b from "b"\nexport default b')],
         })('a');
         if (result[0] !== 'error') {
             throw result;

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

@@ -67,6 +67,12 @@ export declare const writeFile: Func<WriteFile>;
 export declare const writeUtf8File: (path: string, content: string) => Effect<WriteFile, IoResult<void>>;
 export type Rm = readonly ['rm', (path: string) => IoResult<void>];
 export declare const rm: Func<Rm>;
+export type Rename = readonly ['rename', (src: string, dst: string) => IoResult<void>];
+export declare const rename: Func<Rename>;
+export type ReadBytes = readonly ['readBytes', (path: string, offset: number, size: number) => IoResult<Vec>];
+export declare const readBytes: Func<ReadBytes>;
+export type RandomInt = readonly ['randomInt', () => number];
+export declare const randomInt: Func<RandomInt>;
 export type ExecResult = {
     readonly stdout: string;
     readonly stderr: string;
@@ -75,7 +81,7 @@ export type Exec = readonly ['exec', (command: string, stdin?: string) => IoResu
 export declare const exec: Func<Exec>;
 export type Access = readonly ['access', (path: string) => IoResult<void>];
 export declare const access: Func<Access>;
-export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec | Access;
+export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
 export type Headers = StringMap<string, string>;
 export type IncomingMessage = {
@@ -210,7 +216,7 @@ export type TestContext = {
 /** Effect operation that registers a named test with the active `TestContext`. */
 export type Test = readonly ['test', (ctx: TestContext, name: string, expectFailure: boolean, test: (t: TestContext) => Effect<Test | All | Await, void>) => void];
 export declare const test: Func<Test>;
-export type NodeOp = All | Await | Fetch | Fs | Http | Forever | Import | MemOp | Now | Read | Sandbox | Write | Test;
+export type NodeOp = All | Await | Fetch | Fs | Http | Forever | Import | MemOp | Now | RandomInt | Read | Sandbox | Write | Test;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 /**
  * Writes an error line to `stderr` and yields exit code `1`. The canonical

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

@@ -48,6 +48,9 @@ export const writeFile = do_('writeFile');
 /** Writes a string to `path` as UTF-8 bytes. */
 export const writeUtf8File = (path, content) => writeFile(path, utf8(content));
 export const rm = do_('rm');
+export const rename = do_('rename');
+export const readBytes = do_('readBytes');
+export const randomInt = do_('randomInt');
 export const exec = do_('exec');
 export const access = do_('access');
 export const createServer = do_('createServer');