functionalscript 0.16.1 → 0.17.0

package/fs/asn.1/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * ASN.1 BER/DER encoding and decoding over bit vectors. Includes tag/class
+ * helpers, length-prefixed payloads, and OID conversion via Base-128.
+ *
+ * @module
+ */
 import { bitLength, max } from "../types/bigint/module.f.js";
 import { empty, isVec, length, listToVec, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { identity } from "../types/function/module.f.js";

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

@@ -1,3 +1,9 @@
+/**
+ * CI step builder for Bun: installs the pinned Bun version (with a PowerShell
+ * fallback for Windows ARM) and runs `bun install` and `bun test`.
+ *
+ * @module
+ */
 import { bun } from "../config/module.f.js";
 import { clean, install, test } from "../common/module.f.js";
 const installOnWindowsArm = ({ def, name, path }) => (v) => (a) => install(v === 'windows' && a === 'arm'

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

@@ -1,3 +1,10 @@
+/**
+ * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
+ * `MetaStep` representation used by tool-specific modules, and assemblers like
+ * `install`, `test`, `clean`, `ubuntu`, and `toSteps`.
+ *
+ * @module
+ */
 import { images } from '../config/module.f.ts';
 import { type Ts } from '../../types/rtti/ts/module.f.ts';
 export declare const os: readonly ["ubuntu", "macos", "windows"];

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

@@ -1,3 +1,10 @@
+/**
+ * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
+ * `MetaStep` representation used by tool-specific modules, and assemblers like
+ * `install`, `test`, `clean`, `ubuntu`, and `toSteps`.
+ *
+ * @module
+ */
 import { images, rust } from "../config/module.f.js";
 import { option, array, record, string } from "../../types/rtti/module.f.js";
 import {} from "../../types/rtti/ts/module.f.js";

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

@@ -1,3 +1,10 @@
+/**
+ * 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-24.04";

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

@@ -1,3 +1,10 @@
+/**
+ * Centralized version pins and OS images used by the CI generator: runner
+ * images, tool versions (Bun, Deno, Playwright, Rust, Node, Wasmtime, Wasmer,
+ * TSGO).
+ *
+ * @module
+ */
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
 export const images = {
     ubuntu: {

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

@@ -1,3 +1,9 @@
+/**
+ * CI step builder for Deno: installs the pinned Deno version and runs
+ * `deno install` followed by `deno task test`.
+ *
+ * @module
+ */
 import { deno } from "../config/module.f.js";
 import { clean, install, test } from "../common/module.f.js";
 export const denoSteps = (extra) => clean([

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

@@ -1,3 +1,9 @@
+/**
+ * CI step builders for Node.js: setup-node installation, common npm
+ * install/test sequences, per-version job matrices, and the main TSGO step.
+ *
+ * @module
+ */
 import { node, tsgo } from "../config/module.f.js";
 import { clean, findTgz, install, test, ubuntu } from "../common/module.f.js";
 export const major = (v) => v.split('.')[0];

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

@@ -1,3 +1,9 @@
+/**
+ * CI job that installs Playwright (with a browser-cache step) and runs the
+ * test suite against Chromium, Firefox, and WebKit.
+ *
+ * @module
+ */
 import { images, node, playwright } from "../config/module.f.js";
 import { install, test, toSteps } from "../common/module.f.js";
 import { basicNode } from "../node/module.f.js";

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

@@ -1,3 +1,10 @@
+/**
+ * CI step builder for the Rust crate: `cargo fmt`, `cargo clippy`, native and
+ * `--release` test runs, plus matrix entries for WASM targets (Wasmtime,
+ * Wasmer) and the 32-bit `i686` targets.
+ *
+ * @module
+ */
 import { wasmer, wasmtime } from "../config/module.f.js";
 import { install, test } from "../common/module.f.js";
 const cargoTest = (target, config) => {

package/fs/crypto/secp/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Short Weierstrass elliptic-curve arithmetic over a prime field: `curve`
+ * builds point negation, addition, and scalar multiplication for any
+ * `secp`-family curve from its `(p, a, g, n)` parameters.
+ *
+ * @module
+ */
 import type { Equal, Fold, Reduce } from '../../types/function/operator/module.f.ts';
 import { type PrimeField } from '../../types/prime_field/module.f.ts';
 /**

package/fs/dev/index/module.f.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Entry point for the `index` developer program: re-exports `index4` from the
+ * parent `dev` module as the default `NodeProgram`.
+ *
+ * @module
+ */
 import { index4 } from '../module.f.ts';
 export default index4;

package/fs/dev/index/module.f.js

@@ -1,2 +1,8 @@
+/**
+ * Entry point for the `index` developer program: re-exports `index4` from the
+ * parent `dev` module as the default `NodeProgram`.
+ *
+ * @module
+ */
 import { index4 } from "../module.f.js";
 export default index4;

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

@@ -4,7 +4,7 @@
  * @module
  */
 import { type Io } from '../io/module.f.ts';
-import { type All, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
+import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
 import { type Effect } from '../types/effects/module.f.ts';
 export declare const todo: () => never;
 export declare const assert: (v: boolean, msg?: unknown) => asserts v;
@@ -18,5 +18,6 @@ export type ModuleMap = {
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
 export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
+export declare const loadModuleMap2: (env: Env) => Effect<Access | Import | All | Readdir, ModuleMap>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -63,15 +63,14 @@ const loadFile = (f) => {
     }
     return pure([]);
 };
-export const loadModuleMap = async (io) => {
-    const { process: { env } } = io;
+export const loadModuleMap2 = (env) => {
     const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
-    const effect = allFiles(s)
+    return allFiles(s)
         .step(files => all(...files.map(loadFile)))
         .step(entries => pure(Object.fromEntries(entries.flat().toSorted(cmp))));
-    return fromIo(io)(effect);
 };
+export const loadModuleMap = async (io) => fromIo(io)(loadModuleMap2(io.process.env));
 const denoJson = './deno.json';
 const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = begin

package/fs/dev/tf/module.f.d.ts

@@ -1,24 +1,8 @@
-import { type CsiConsole } from '../../text/sgr/module.f.ts';
-import type * as Result from '../../types/result/module.f.ts';
-import type { Io, Performance, TryCatch } from '../../io/module.f.ts';
-import { type ModuleMap } from '../module.f.ts';
-type Log<T> = CsiConsole;
-type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
-type Input<T> = {
-    readonly moduleMap: ModuleMap;
-    readonly log: Log<T>;
-    readonly error: Log<T>;
-    readonly measure: Measure<T>;
-    readonly state: T;
-    readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
-    readonly env: (n: string) => string | undefined;
-};
+import type { Io } from '../../io/module.f.ts';
+import type { SandboxResult } from '../../types/effects/node/module.f.ts';
 export declare const isTest: (s: string) => boolean;
 export type Test = () => unknown;
 export type TestSet = Test | readonly (readonly [string, unknown])[];
-export declare const parseTestSet: (t: TryCatch) => (throws: boolean) => (x: unknown) => TestSet;
-export declare const test: <T>(input: Input<T>) => readonly [number, T];
+export declare const parseTestSet: (sandbox: <R>(f: () => R) => SandboxResult<R>) => (throws: boolean) => (x: unknown) => TestSet;
 export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
-export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];
 export declare const main: (io: Io) => Promise<number>;
-export {};

package/fs/dev/tf/module.f.js

@@ -18,7 +18,7 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (t) => (throws) => (x) => {
+export const parseTestSet = (sandbox) => (throws) => (x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
@@ -30,7 +30,7 @@ export const parseTestSet = (t) => (throws) => (x) => {
                 // enclosing tree node is named 'throw' (so any function reference
                 // works, not only inline ones whose inferred name is 'throw').
                 return () => {
-                    const [tag, value] = t(xt);
+                    const { result: [tag, value] } = sandbox(xt);
                     if (tag === 'ok') {
                         throw value;
                     }
@@ -48,17 +48,20 @@ export const parseTestSet = (t) => (throws) => (x) => {
     }
     return [];
 };
-export const test = (input) => {
-    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
-    const isGitHub = env('GITHUB_ACTION') !== undefined;
-    const parse = parseTestSet(tryCatch);
+const test = async (io) => {
+    const moduleMap = await loadModuleMap(io);
+    const log = stdio(io);
+    const error = stderr(io);
+    const { sandbox } = io;
+    const env_ = env(io);
+    const isGitHub = env_('GITHUB_ACTION') !== undefined;
+    const parse = parseTestSet(sandbox);
     const f = ([k, v]) => {
-        const test = i => throws => v => ([ts, state]) => {
+        const test = i => throws => v => ts => {
             const next = test(`${i}| `);
             const set = parse(throws)(v);
             if (typeof set === 'function') {
-                const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
-                state = state0;
+                const { result: [s, r], duration: delta } = sandbox(set);
                 if (s !== 'ok') {
                     ts = addFail(delta)(ts);
                     if (isGitHub) {
@@ -76,23 +79,23 @@ export const test = (input) => {
                     log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
                     // The result of a function is walked as a fresh sub-tree;
                     // the parent's `throws` flag does not propagate into it.
-                    [ts, state] = next(false)(r)([ts, state]);
+                    ts = next(false)(r)(ts);
                 }
             }
             else {
-                const f = ([k, v]) => ([time, state]) => {
+                const f = ([k, v]) => ts => {
                     log(`${i}${k}:`);
-                    [time, state] = next(throws || k === 'throw')(v)([time, state]);
-                    return [time, state];
+                    ts = next(throws || k === 'throw')(v)(ts);
+                    return ts;
                 };
-                [ts, state] = fold(f)([ts, state])(set);
+                ts = fold(f)(ts)(set);
             }
-            return [ts, state];
+            return ts;
         };
-        return ([ts, state]) => {
+        return ts => {
             if (isTest(k)) {
                 log(`testing ${k}`);
-                [ts, state] = test('| ')(false)(v.default)([ts, state]);
+                ts = test('| ')(false)(v.default)(ts);
                 // Non-default exports are walked as a sibling test group so
                 // a test file can spread its tests across multiple named
                 // exports (see issue 27 in `issues/README.md`). Skip exports
@@ -101,35 +104,21 @@ export const test = (input) => {
                 const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
                     (typeof val === 'object' && val !== null))));
                 if (Object.keys(others).length !== 0) {
-                    [ts, state] = test('| ')(false)(others)([ts, state]);
+                    ts = test('| ')(false)(others)(ts);
                 }
             }
-            return [ts, state];
+            return ts;
         };
     };
     let ts = { time: 0, pass: 0, fail: 0 };
-    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
+    ts = fold(f)(ts)(Object.entries(moduleMap));
     const fgFail = ts.fail === 0 ? fgGreen : fgRed;
     log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
     log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
-    return [ts.fail !== 0 ? 1 : 0, state];
+    return ts.fail !== 0 ? 1 : 0;
 };
 export const anyLog = (f) => (s) => (state) => {
     f(s);
     return state;
 };
-export const measure = (p) => (f) => (state) => {
-    const b = p.now();
-    const r = f();
-    const e = p.now();
-    return [r, e - b, state];
-};
-export const main = async (io) => test({
-    moduleMap: await loadModuleMap(io),
-    log: stdio(io), // anyLog(io.console.log),
-    error: stderr(io), // anyLog(io.console.error),
-    measure: measure(io.performance),
-    tryCatch: io.tryCatch,
-    env: env(io),
-    state: undefined,
-})[0];
+export const main = test;

package/fs/dev/tf/module.js

@@ -1,8 +1,9 @@
 import { io } from "../../io/module.js";
-import { loadModuleMap } from "../module.f.js";
+import { loadModuleMap2 } from "../module.f.js";
 import { isTest, parseTestSet } from "./module.f.js";
 import * as nodeTest from 'node:test';
 import { asyncImport } from "../../io/module.js";
+import { fromIo } from "../../io/module.f.js";
 const isBun = typeof Bun !== 'undefined';
 const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
@@ -15,7 +16,7 @@ const createPlaywrightFramework = async () => {
 const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
-const parse = parseTestSet(io.tryCatch);
+const parse = parseTestSet(io.sandbox);
 const scanModule = (x) => async (subTestRunner) => {
     let subTests = [x];
     while (true) {
@@ -44,7 +45,7 @@ const scanModule = (x) => async (subTestRunner) => {
     }
 };
 export const run = async () => {
-    const x = await loadModuleMap(io);
+    const x = await fromIo(io)(loadModuleMap2(io.process.env));
     for (const [i, v] of Object.entries(x)) {
         if (isTest(i)) {
             framework(i, scanModule(['', v.default, false]));

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

@@ -3,12 +3,15 @@
  *
  * @module
  */
-import type { Io } from '../io/module.f.ts';
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
+import { type Effect } from '../types/effects/module.f.ts';
+import { type Error, type WriteFile, type ReadFile } from '../types/effects/node/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
 };
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;
 export type Unknown = Primitive | Object | Array;
-export declare const compile: ({ console: { error }, fs }: Io) => (args: readonly string[]) => Promise<number>;
+type CompileOp = ReadFile | WriteFile | Error;
+export declare const compile: (args: readonly string[]) => Effect<CompileOp, number>;
+export {};

package/fs/djs/module.f.js

@@ -1,31 +1,23 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-import { encodeUtf8 } from "../types/uint8array/module.f.js";
-export const compile = ({ console: { error }, fs }) => (args) => {
+import { encodeUtf8, toVec } from "../types/uint8array/module.f.js";
+import { pure } from "../types/effects/module.f.js";
+import { error, writeFile, } from "../types/effects/node/module.f.js";
+export const compile = args => {
     if (args.length < 2) {
-        error('Error: Requires 2 or more arguments');
-        return Promise.resolve(1);
+        return error('Error: Requires 2 or more arguments').step(() => pure(1));
     }
     const inputFileName = args[0];
     const outputFileName = args[1];
-    const result = transpile(fs)(inputFileName);
-    switch (result[0]) {
-        case 'ok': {
-            if (outputFileName.endsWith('.json')) {
-                const output = stringifyAsTree(sort)(result[1]);
-                fs.writeFileSync(outputFileName, encodeUtf8(output));
-                break;
-            }
-            const output = stringify(sort)(result[1]);
-            fs.writeFileSync(outputFileName, encodeUtf8(output));
-            break;
-        }
-        case 'error': {
+    return transpile(inputFileName).step((result) => {
+        if (result[0] === 'error') {
             const metadata = result[1].metadata;
-            error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`);
-            break;
+            return error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`).step(() => pure(0));
         }
-    }
-    return Promise.resolve(0);
+        const content = outputFileName.endsWith('.json')
+            ? stringifyAsTree(sort)(result[1])
+            : stringify(sort)(result[1]);
+        return writeFile(outputFileName, toVec(encodeUtf8(content))).step(() => pure(0));
+    });
 };

package/fs/djs/test.f.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    tooFewArgs: {
+        noArgs: () => void;
+        oneArg: () => void;
+    };
+    success: () => void;
+    jsonOutput: () => void;
+    fileNotFound: () => void;
+    parseError: () => void;
+};
+export default _default;

package/fs/djs/test.f.js

@@ -0,0 +1,75 @@
+import { compile } from "./module.f.js";
+import { virtual, emptyState } from "../types/effects/node/virtual/module.f.js";
+import { encodeUtf8, toVec, fromVec, decodeUtf8 } from "../types/uint8array/module.f.js";
+import { isVec } from "../types/bit_vec/module.f.js";
+const fileVec = (s) => toVec(encodeUtf8(s));
+const readOutput = (root, path) => {
+    const file = root[path];
+    if (!isVec(file)) {
+        throw `${path} is not a file`;
+    }
+    return decodeUtf8(fromVec(file));
+};
+export default {
+    tooFewArgs: {
+        noArgs: () => {
+            const [state, code] = virtual(emptyState)(compile([]));
+            if (code !== 1) {
+                throw code;
+            }
+            if (!state.stderr.includes('Requires 2 or more arguments')) {
+                throw state.stderr;
+            }
+        },
+        oneArg: () => {
+            const [state, code] = virtual(emptyState)(compile(['input.f.js']));
+            if (code !== 1) {
+                throw code;
+            }
+            if (!state.stderr.includes('Requires 2 or more arguments')) {
+                throw state.stderr;
+            }
+        },
+    },
+    success: () => {
+        const root = { 'input.f.js': fileVec('export default 42') };
+        const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.f.js']));
+        if (code !== 0) {
+            throw code;
+        }
+        const content = readOutput(state.root, 'output.f.js');
+        if (content !== 'export default 42') {
+            throw content;
+        }
+    },
+    jsonOutput: () => {
+        const root = { 'input.f.js': fileVec('export default 42') };
+        const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.json']));
+        if (code !== 0) {
+            throw code;
+        }
+        const content = readOutput(state.root, 'output.json');
+        if (content !== '42') {
+            throw content;
+        }
+    },
+    fileNotFound: () => {
+        const [state, code] = virtual(emptyState)(compile(['missing.f.js', 'output.f.js']));
+        if (code !== 0) {
+            throw code;
+        }
+        if (!state.stderr.includes('file not found')) {
+            throw state.stderr;
+        }
+    },
+    parseError: () => {
+        const root = { 'bad.f.js': fileVec('export default @') };
+        const [state, code] = virtual({ ...emptyState, root })(compile(['bad.f.js', 'output.f.js']));
+        if (code !== 0) {
+            throw code;
+        }
+        if (state.stderr === '') {
+            throw 'expected error output';
+        }
+    },
+};

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

@@ -7,10 +7,10 @@ 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';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-import type { Fs } from '../../io/module.f.ts';
 import { type ParseError } from '../parser/module.f.ts';
+import { type Effect } from '../../types/effects/module.f.ts';
+import { type ReadFile } from '../../types/effects/node/module.f.ts';
 export type ParseContext = {
-    readonly fs: Fs;
     readonly complete: OrderedMap<djsResult>;
     readonly stack: List<string>;
     readonly error: ParseError | null;
@@ -18,4 +18,4 @@ export type ParseContext = {
 export type djsResult = {
     djs: Unknown;
 };
-export declare const transpile: (fs: Fs) => (path: string) => Result<Unknown, ParseError>;
+export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;

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

@@ -5,15 +5,16 @@
  */
 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";
-import {} from "../../types/function/operator/module.f.js";
+import { drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
 import { tokenize } from "../tokenizer/module.f.js";
 import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
-import { decodeUtf8 } from "../../types/uint8array/module.f.js";
+import { decodeUtf8, fromVec } from "../../types/uint8array/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { readFile } from "../../types/effects/node/module.f.js";
 const mapDjs = context => path => {
     const res = at(path)(context.complete);
     if (res === null) {
@@ -21,46 +22,50 @@ const mapDjs = context => path => {
     }
     return res.djs;
 };
+const parseModule = path => readFile(path).step(result => {
+    if (result[0] === 'error') {
+        return pure(error({ message: 'file not found', metadata: null }));
+    }
+    const tokens = tokenize(stringToList(decodeUtf8(fromVec(result[1]))))(path);
+    return pure(parseFromTokens(tokens));
+});
 const transpileWithImports = path => parseModuleResult => context => {
     if (parseModuleResult[0] === 'ok') {
         const dir = pathConcat(path)('..');
         const pathsCombine = listMap(pathConcat(dir))(parseModuleResult[1][0]);
-        const contextWithImports = fold(foldNextModuleOp)({ ...context, stack: { first: path, tail: context.stack } })(pathsCombine);
-        if (contextWithImports.error !== null) {
-            return contextWithImports;
-        }
-        const args = toArray(listMap(mapDjs(contextWithImports))(pathsCombine));
-        const djs = { djs: run(parseModuleResult[1][1])(args) };
-        return { ...contextWithImports, stack: drop(1)(contextWithImports.stack), complete: setReplace(path)(djs)(contextWithImports.complete) };
-    }
-    return { ...context, error: parseModuleResult[1] };
-};
-const parseModule = path => context => {
-    const content = context.fs.readFileSync(path);
-    if (content === null) {
-        return error({ message: 'file not found', metadata: null });
+        const pathsArray = toArray(pathsCombine);
+        const contextWithStack = { ...context, stack: { first: path, tail: context.stack } };
+        return pathsArray.reduce((acc, p) => acc.step(ctx => foldNextModuleOp(p)(ctx)), pure(contextWithStack)).step(contextWithImports => {
+            if (contextWithImports.error !== null) {
+                return pure(contextWithImports);
+            }
+            const args = toArray(listMap(mapDjs(contextWithImports))(pathsCombine));
+            const djs = { djs: run(parseModuleResult[1][1])(args) };
+            return pure({
+                ...contextWithImports,
+                stack: drop(1)(contextWithImports.stack),
+                complete: setReplace(path)(djs)(contextWithImports.complete),
+            });
+        });
     }
-    const tokens = tokenize(stringToList(decodeUtf8(content)))(path);
-    return parseFromTokens(tokens);
+    return pure({ ...context, error: parseModuleResult[1] });
 };
 const foldNextModuleOp = path => context => {
     if (context.error !== null) {
-        return context;
+        return pure(context);
     }
     if (includes(path)(context.stack)) {
-        return { ...context, error: { message: 'circular dependency', metadata: null } };
+        return pure({ ...context, error: { message: 'circular dependency', metadata: null } });
     }
     if (at(path)(context.complete) !== null) {
-        return context;
+        return pure(context);
     }
-    const parseModuleResult = parseModule(path)(context);
-    return transpileWithImports(path)(parseModuleResult)(context);
+    return parseModule(path).step(parseModuleResult => transpileWithImports(path)(parseModuleResult)(context));
 };
-export const transpile = fs => path => {
-    const context = foldNextModuleOp(path)({ fs, stack: null, complete: null, error: null });
+export const transpile = path => foldNextModuleOp(path)({ stack: null, complete: null, error: null }).step((context) => {
     if (context.error !== null) {
-        return error(context.error);
+        return pure(error(context.error));
     }
     const result = at(path)(context.complete)?.djs;
-    return ok(result);
-};
+    return pure(ok(result));
+});