functionalscript 0.9.2 → 0.10.0

package/bnf/data/test.f.d.ts

@@ -1,4 +1,6 @@
 declare const _default: {
+    rangeDecode: () => void;
+    rangeEncode: () => void;
     toData: (() => void)[];
     emptyTags: (() => void)[];
     variantTest: () => void;

package/bnf/data/test.f.js

@@ -3,7 +3,7 @@ import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, option, range, repeat0Plus, set } from "../module.f.js";
+import { join0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
@@ -12,6 +12,34 @@ const descentParserCpOnly = (m, name, cp) => {
     return m(name, cpm);
 };
 export default {
+    rangeDecode: () => {
+        const decoded1 = stringify(sort)(rangeDecode(0x000079_000087));
+        if (decoded1 !== '[121,135]') {
+            throw decoded1;
+        }
+        const decoded2 = stringify(sort)(rangeDecode(0x000080_000087));
+        if (decoded2 !== '[128,135]') {
+            throw decoded2;
+        }
+        const decoded3 = stringify(sort)(rangeDecode(0x10FFFF_10FFFF));
+        if (decoded3 !== '[1114111,1114111]') {
+            throw decoded3;
+        }
+    },
+    rangeEncode: () => {
+        const encoded1 = oneEncode(0x79);
+        if (encoded1 !== 0x000079_000079) {
+            throw encoded1;
+        }
+        const encoded2 = oneEncode(0x80);
+        if (encoded2 !== 0x000080_000080) {
+            throw encoded2;
+        }
+        const encoded3 = oneEncode(0x10FFFF);
+        if (encoded3 !== 0x10FFFF_10FFFF) {
+            throw encoded3;
+        }
+    },
     toData: [
         () => {
             const c = toData(classic());
@@ -281,7 +309,16 @@ export default {
             }
         },
         () => {
-            const terminalRangeRule = range('AF');
+            const terminalRangeRule = 0x000079_000087;
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = 0x000080_000087; //broken range
             const m = parser(terminalRangeRule);
             const mr = m("", [64]);
             const result = JSON.stringify(mr);

package/bnf/module.f.d.ts

@@ -9,7 +9,8 @@ import { type Array2 } from '../types/array/module.f.ts';
 export type TerminalRange = number;
 export declare const fullRange: TerminalRange;
 export declare const unicodeRange: TerminalRange;
-export declare const eof = 1114112;
+export declare const max: string;
+export declare const unicodeMax: string;
 /** A sequence of rules. */
 export type Sequence = readonly Rule[];
 /** A variant */
@@ -19,9 +20,9 @@ export type Variant = {
 export type DataRule = Variant | Sequence | TerminalRange | string;
 export type LazyRule = () => DataRule;
 export type Rule = DataRule | LazyRule;
-export declare const max: string;
 export declare const rangeEncode: (a: number, b: number) => TerminalRange;
 export declare const oneEncode: (a: number) => TerminalRange;
+export declare const eof: TerminalRange;
 export declare const rangeDecode: (r: number) => Array2<number>;
 export declare const toSequence: (s: string) => readonly TerminalRange[];
 export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;

package/bnf/module.f.js

@@ -3,7 +3,8 @@ import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
 export const fullRange = 0x000000_FFFFFF;
 export const unicodeRange = 0x000000_10FFFF;
-export const eof = 0x110000;
+export const max = codePointListToString([0xFFFFFF]);
+export const unicodeMax = codePointListToString([0x10FFFF]);
 // Internals:
 const { fromEntries, values } = Object;
 const { fromCodePoint } = String;
@@ -13,15 +14,15 @@ const { fromCodePoint } = String;
 const offset = 24;
 const mask = (1 << offset) - 1;
 const isValid = (r) => r >= 0 && r <= mask;
-export const max = codePointListToString([0x10FFFF]);
 export const rangeEncode = (a, b) => {
     if (!isValid(a) || !isValid(b) || a > b) {
         throw `Invalid range ${a} ${b}.`;
     }
-    return (a << offset) | b;
+    return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
 };
 export const oneEncode = (a) => rangeEncode(a, a);
-export const rangeDecode = (r) => [r >> offset, r & mask];
+export const eof = oneEncode(0x110000);
+export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), Number(BigInt(r) & BigInt(mask))];
 const mapOneEncode = map(oneEncode);
 export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
 export const str = (s) => {

package/cas/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Content-addressable storage utilities for hashing, addressing, and path parsing.
+ *
+ * @module
+ */
 import { type Sha2 } from "../crypto/sha2/module.f.ts";
 import type { Vec } from "../types/bit_vec/module.f.ts";
 import { type Effect, type Operations } from "../types/effect/module.f.ts";

package/cas/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Content-addressable storage utilities for hashing, addressing, and path parsing.
+ *
+ * @module
+ */
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";

package/ci/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Continuous integration helper commands for repository automation tasks.
+ *
+ * @module
+ */
 import { utf8 } from "../text/module.f.js";
 import { writeFile } from "../types/effect/node/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
@@ -5,15 +10,15 @@ const architecture = ['intel', 'arm'];
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
 const images = {
     ubuntu: {
-        intel: 'ubuntu-latest',
+        intel: 'ubuntu-24.04',
         arm: 'ubuntu-24.04-arm'
     },
     macos: {
-        intel: 'macos-15-intel',
-        arm: 'macos-latest'
+        intel: 'macos-26-intel',
+        arm: 'macos-26'
     },
     windows: {
-        intel: 'windows-latest',
+        intel: 'windows-2025',
         arm: 'windows-11-arm',
     }
 };
@@ -27,11 +32,7 @@ const installBun = installOnWindowsArm({
     name: 'bun',
     path: 'bun.sh'
 });
-const installDeno = installOnWindowsArm({
-    def: { uses: 'denoland/setup-deno@v2', with: { 'deno-version': '2' } },
-    name: 'deno',
-    path: 'deno.land'
-});
+const installDeno = install({ uses: 'denoland/setup-deno@v2', with: { 'deno-version': '2' } });
 const cargoTest = (target, config) => {
     const to = target ? ` --target ${target}` : '';
     const co = config ? ` --config ${config}` : '';
@@ -65,6 +66,9 @@ const node = (version) => (extra) => basicNode(version)([
     ...extra,
 ]);
 const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
+const playwrightVersion = '1.58.2';
+const playwrightAndVersion = `playwright@${playwrightVersion}`;
+const rustToolchain = '1.93.1';
 const toSteps = (m) => {
     const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
     const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');
@@ -73,9 +77,7 @@ const toSteps = (m) => {
     return [
         ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
         ...(rust ? [{
-                // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
-                // See https://github.com/sergey-shandar/wasmtime-crash
-                uses: 'dtolnay/rust-toolchain@1.93.0',
+                uses: `dtolnay/rust-toolchain@${rustToolchain}`,
                 with: {
                     components: 'rustfmt,clippy',
                     targets
@@ -94,11 +96,34 @@ const nodeSteps = (v) => [
     test({ run: `npm ${nodeTest(v)}` }),
 ];
 const ubuntu = (ms) => ({
-    'runs-on': 'ubuntu-latest',
+    'runs-on': 'ubuntu-24.04',
     steps: toSteps(ms)
 });
 const nodeVersions = Object.fromEntries(nodes.map(v => [`node${v}`, ubuntu(nodeSteps(v))]));
-const steps = (v) => (a) => {
+const defaultNodeVersion = '24';
+const playwright = ubuntu(basicNode(defaultNodeVersion)([
+    //install({ uses: 'actions/cache@v4', with: { path: '~/.cache/ms-playwright', key: `${images.ubuntu.intel}-${playwrightAndVersion}` } }),
+    install({ run: `npm install -g ${playwrightAndVersion}` }),
+    install({ run: 'playwright install --with-deps' }),
+    // we have to use `npx` to make sure that we respect `@playwright/test` version from
+    // the `package.json`.
+    ...['chromium', 'firefox', 'webkit'].map(browser => test({ run: `npx playwright test --browser=${browser}` })),
+]));
+const i686 = (a, v) => {
+    if (a === 'intel') {
+        switch (v) {
+            case 'windows': return customTarget('i686-pc-windows-msvc');
+            case 'ubuntu': return [
+                { type: 'apt-get', package: 'libc6-dev-i386' },
+                ...customTarget('i686-unknown-linux-gnu'),
+            ];
+        }
+    }
+    return [];
+};
+const job = (v) => (a) => {
+    const id = `${v}-${a}`;
+    const image = images[v][a];
     const result = [
         // Rust
         test({ run: 'cargo fmt -- --check' }),
@@ -110,23 +135,12 @@ const steps = (v) => (a) => {
         ...wasmTarget('wasm32-wasip2'),
         ...wasmTarget('wasm32-unknown-unknown'),
         ...wasmTarget('wasm32-wasip1-threads'),
-        ...(a !== 'intel' ? [] :
-            v === 'windows' ?
-                customTarget('i686-pc-windows-msvc') :
-                v === 'ubuntu' ? [
-                    { type: 'apt-get', package: 'libc6-dev-i386' },
-                    ...customTarget('i686-unknown-linux-gnu'),
-                ] :
-                    []),
+        ...i686(a, v),
         // Node.js
-        ...node('24')([
+        ...node(defaultNodeVersion)([
             // TypeScript Preview
             install({ run: 'npm install -g @typescript/native-preview' }),
             test({ run: 'tsgo' }),
-            // Playwright
-            install({ run: 'npm install -g playwright' }),
-            install({ run: 'playwright install --with-deps' }),
-            ...['chromium', 'firefox', 'webkit'].map(browser => (test({ run: `npx playwright test --browser=${browser}` }))),
             // publishing
             test({ run: 'npm pack' }),
             test({ run: `npm install -g ${findTgz(v)}` }),
@@ -136,7 +150,7 @@ const steps = (v) => (a) => {
         ]),
         // Deno
         ...clean([
-            installDeno(v)(a),
+            installDeno,
             test({ run: 'deno install' }),
             test({ run: 'deno task test' }),
             test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
@@ -150,16 +164,12 @@ const steps = (v) => (a) => {
             test({ run: 'bun ./fjs/module.ts t' }),
         ]),
     ];
-    return toSteps(result);
+    return [id, { 'runs-on': image, steps: toSteps(result) }];
 };
 const jobs = {
-    ...Object.fromEntries([
-        ...os.flatMap(v => architecture.map(a => [`${v}-${a}`, {
-                'runs-on': images[v][a],
-                steps: steps(v)(a),
-            }]))
-    ]),
+    ...Object.fromEntries(os.flatMap(v => architecture.map(job(v)))),
     ...nodeVersions,
+    playwright,
 };
 const gha = {
     name: 'CI',

package/ci/module.js

@@ -1,3 +1,3 @@
-import { nodeRun } from "../io/module.js";
-import run from "./module.f.js";
-await nodeRun(run);
+import run from "../io/module.js";
+import app from "./module.f.js";
+run(app);

package/crypto/hmac/test.f.js

@@ -1,5 +1,5 @@
 import { utf8 } from "../../text/module.f.js";
-import { length, uint, vec } from "../../types/bit_vec/module.f.js";
+import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { hmac } from "./module.f.js";
 export default {

package/crypto/sign/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Signing helpers built on secp256k1 and SHA-256 primitives.
+ *
+ * @module
+ */
 import type { Array2 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { Curve } from '../secp/module.f.ts';

package/crypto/sign/test.f.js

@@ -1,7 +1,7 @@
 import { utf8 } from "../../text/module.f.js";
 import { empty, msb, repeat, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
-import { curve, secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
+import { secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
 import { computeSync, sha224, sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { all, concat, computeK, fromCurve, sign } from "./module.f.js";
 const sample = utf8("sample");

package/dev/index/module.js

@@ -1,3 +1,3 @@
 import { index } from "../module.f.js";
-import node from "../../io/module.js";
-await node(index);
+import { legacyRun } from "../../io/module.js";
+legacyRun(index);

package/dev/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
 import { type Io } from '../io/module.f.ts';
 export declare const todo: () => never;
 export type Module = {

package/dev/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
 import { decodeUtf8, encodeUtf8 } from "../types/uint8array/module.f.js";

package/dev/tf/all.test.js

@@ -7,11 +7,11 @@ const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
 // Bun doesn't support nested tests yet.
 const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrihtFramework = async () => {
+const createPlaywrightFramework = async () => {
     const pwTest = (await import('@playwright/test')).test;
     return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
 };
-const framework = isPlaywright ? await createPlaywrihtFramework() :
+const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
 const parse = parseTestSet(io.tryCatch);

package/dev/tf/module.f.js

@@ -1,4 +1,9 @@
-import { entries, fold } from "../../types/list/module.f.js";
+/**
+ * Test-framework helpers for running and reporting FunctionalScript tests.
+ *
+ * @module
+ */
+import { fold } from "../../types/list/module.f.js";
 import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
 import { env, loadModuleMap } from "../module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
@@ -58,7 +63,7 @@ export const test = (input) => {
                     if (isGitHub) {
                         // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
                         // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                        error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
+                        error(`::error file=${k},line=1,title=${i}()::${r}`);
                     }
                     else {
                         error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);

package/dev/version/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Version management helpers for updating project package versions.
+ *
+ * @module
+ */
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { all } from "../../types/effect/module.f.js";
 import { readFile, writeFile } from "../../types/effect/node/module.f.js";

package/djs/ast/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * AST types and helpers for the DJS representation.
+ *
+ * @module
+ */
 import type { Primitive, Array, Unknown } from '../module.f.ts';
 export type AstModule = [readonly string[], AstBody];
 export type AstConst = Primitive | AstModuleRef | AstArray | AstObject;

package/djs/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * High-level DJS API for parsing, transpiling, and serializing modules.
+ *
+ * @module
+ */
 import type { Io } from '../io/module.f.ts';
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
 export type Object = {

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

@@ -1,3 +1,8 @@
+/**
+ * DJS parser that builds structured trees from DJS tokens.
+ *
+ * @module
+ */
 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';

package/djs/parser/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * DJS parser that builds structured trees from DJS tokens.
+ *
+ * @module
+ */
 import { error, ok } from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
 import { setReplace, at } from "../../types/ordered_map/module.f.js";

package/djs/parser-new/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Experimental DJS parser implementation.
+ *
+ * @module
+ */
 import { descentParser } from "../../bnf/data/module.f.js";
 import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
 import { todo } from "../../dev/module.f.js";
@@ -134,7 +139,6 @@ export const jsGrammar = () => {
             ]
         }
     ];
-    const endOfFile = oneEncode(eof);
     const token = {
         number,
         string,
@@ -143,7 +147,7 @@ export const jsGrammar = () => {
         operator,
         ws,
         newLine,
-        //endOfFile
+        eof
     };
     const tokens = repeat0Plus(token);
     return tokens;

package/djs/parser-new/test.f.js

@@ -15,9 +15,10 @@ export default {
                 const mr = descentParserCpOnly(m, '', cp);
                 const success = mr[1] && mr[2] === cp.length;
                 if (success !== expected) {
-                    throw mr;
+                    throw JSON.stringify([s, mr]);
                 }
             };
+            expect('"', false);
             expect('   true   ', true);
             expect('   tr2ue   ', true);
             expect('   2true   ', true);

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

@@ -1,3 +1,8 @@
+/**
+ * DJS serializer for formatting AST values back to source text.
+ *
+ * @module
+ */
 import type { Unknown } from '../module.f.ts';
 import type { Entry as ObjectEntry } from '../../types/object/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';

package/djs/transpiler/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * DJS transpiler for transforming parsed trees into JavaScript output.
+ *
+ * @module
+ */
 import { type Unknown } from '../module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';

package/djs/transpiler/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * DJS transpiler for transforming parsed trees into JavaScript output.
+ *
+ * @module
+ */
 import {} from "../module.f.js";
 import { error, ok } from "../../types/result/module.f.js";
 import { fold, drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";

package/fjs/module.f.d.ts

@@ -1,2 +1,7 @@
+/**
+ * FunctionalScript compiler entry points and command handlers.
+ *
+ * @module
+ */
 import { type Io } from '../io/module.f.ts';
 export declare const main: (io: Io) => Promise<number>;

package/fjs/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * FunctionalScript compiler entry points and command handlers.
+ *
+ * @module
+ */
 import { fromIo } from "../io/module.f.js";
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../dev/tf/module.f.js";

package/fjs/module.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { main } from "./module.f.js";
-import node from "../io/module.js";
-await node(main);
+import { legacyRun } from "../io/module.js";
+legacyRun(main);

package/fsc/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * FunctionalScript command utilities for compile workflows.
+ *
+ * @module
+ */
 import { strictEqual } from "../types/function/operator/module.f.js";
 import { merge as rangeMapMerge, fromRange, get, } from "../types/range_map/module.f.js";
 import { reduce as listReduce, toArray, map } from "../types/list/module.f.js";

package/fsm/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Finite state machine helpers used by parser and tokenizer logic.
+ *
+ * @module
+ */
 import { type List } from '../types/list/module.f.ts';
 import { type ByteSet } from '../types/byte_set/module.f.ts';
 import { type RangeMapArray } from '../types/range_map/module.f.ts';

package/fsm/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Finite state machine helpers used by parser and tokenizer logic.
+ *
+ * @module
+ */
 import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from "../types/list/module.f.js";
 import { toRangeMap, union as byteSetUnion, one, empty, range } from "../types/byte_set/module.f.js";
 import { intersect, union as sortedSetUnion } from "../types/sorted_set/module.f.js";

package/io/module.d.ts

@@ -1,8 +1,8 @@
 import { type Io, type Run } from './module.f.ts';
 import type { NodeProgram } from '../types/effect/node/module.f.ts';
 export declare const io: Io;
-declare const runDefault: Run;
-export default runDefault;
+export declare const legacyRun: Run;
 export type NodeRun = (p: NodeProgram) => Promise<number>;
 export declare const ioRun: (io: Io) => NodeRun;
-export declare const nodeRun: NodeRun;
+declare const effectRun: NodeRun;
+export default effectRun;

package/io/module.f.d.ts

@@ -104,4 +104,4 @@ export type Run = (f: App) => Promise<never>;
  * Handles errors by exiting with code 1
  */
 export declare const run: (io: Io) => Run;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;

package/io/module.f.js

@@ -26,9 +26,16 @@ const tc = async (f) => {
         return error(e);
     }
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }) => asyncRun({
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => asyncRun({
     error: async (message) => error(message),
     log: async (message) => log(message),
+    fetch: async (url) => tc(async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
+        }
+        return toVec(new Uint8Array(await response.arrayBuffer()));
+    }),
     mkdir: param => tc(async () => { await mkdir(...param); }),
     readFile: path => tc(async () => toVec(await readFile(path))),
     readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))

package/io/module.js

@@ -10,6 +10,7 @@ import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
 import { concat } from "../path/module.f.js";
+import { error, ok } from "../types/result/module.f.js";
 const prefix = 'file:///';
 export const io = {
     console,
@@ -24,26 +25,26 @@ export const io = {
     fetch,
     tryCatch: f => {
         try {
-            return ['ok', f()];
+            return ok(f());
         }
         catch (e) {
-            return ['error', e];
+            return error(e);
         }
     },
     asyncTryCatch: async (f) => {
         try {
-            return ['ok', await f()];
+            return ok(await f());
         }
         catch (e) {
-            return ['error', e];
+            return error(e);
         }
     },
 };
-const runDefault = run(io);
-export default runDefault;
+export const legacyRun = run(io);
 export const ioRun = (io) => {
     const r = fromIo(io);
     const { argv } = io.process;
     return p => r(p(argv));
 };
-export const nodeRun = ioRun(io);
+const effectRun = ioRun(io);
+export default effectRun;