functionalscript 0.10.3 → 0.11.0

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

@@ -1,12 +1,34 @@
+/**
+ * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
+ * for FunctionalScript BNF rules.
+ *
+ * @module
+ */
 import { type CodePoint } from '../../text/utf16/module.f.ts';
 import { type RangeMapArray } from '../../types/range_map/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
+/**
+ * Encoded terminal range value used by BNF data rules.
+ *
+ * The same as the functional TerminalRange.
+ */
 export type TerminalRange = number;
+/**
+ * Ordered list of grammar rule names.
+ */
 export type Sequence = readonly string[];
 /** A variant of rule names. */
 export type Variant = {
     readonly [k in string]: string;
 };
+/**
+ * Grammar rule definition.
+ *
+ * It can be one of:
+ * - a tagged variant map,
+ * - a sequence of referenced rule names,
+ * - an encoded terminal range.
+ */
 export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
@@ -29,11 +51,29 @@ type DispatchMap = {
 type EmptyTagMap = {
     readonly [id in string]: EmptyTagEntry;
 };
+/**
+ * Recursive descent matcher for a single named rule.
+ */
 export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], idx: number) => DescentMatchResult<T>;
+/**
+ * Result tuple of a descent match operation: AST node, success flag, and next index.
+ */
 export type DescentMatchResult<T> = readonly [AstRuleMeta<T>, boolean, number];
+/**
+ * Entry-point recursive descent matcher.
+ */
 export type DescentMatch<T> = (name: string, s: readonly CodePointMeta<T>[]) => DescentMatchResult<T>;
+/**
+ * Code point value paired with metadata.
+ */
 export type CodePointMeta<T> = readonly [CodePoint, T];
+/**
+ * AST sequence for the metadata-aware parser.
+ */
 export type AstSequenceMeta<T> = readonly (AstRuleMeta<T> | CodePointMeta<T>)[];
+/**
+ * Metadata-aware AST node.
+ */
 export type AstRuleMeta<T> = {
     readonly tag: AstTag;
     readonly sequence: AstSequenceMeta<T>;
@@ -55,18 +95,44 @@ type AstRule = {
  */
 export type Remainder = readonly CodePoint[] | null;
 /**
+ * Parsing result of {@link parser} and {@link parserRuleSet}.
+ *
  * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
  */
 export type MatchResult = readonly [AstRule, boolean, Remainder];
 /**
- * Represents an LL(1) parser function for matching input against grammar rules.
+ * LL(1) parser function for matching by rule name.
  */
 export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
+/**
+ * Internal match function signature used by compiled dispatch rules.
+ */
 export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
+/**
+ * Converts a functional grammar rule into serializable BNF data and returns
+ * the generated rule set with the entry rule identifier.
+ */
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ */
 export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
+/**
+ * Creates a map that describes whether each rule can consume empty input and,
+ * for tagged variants, which tag represents the empty match.
+ */
 export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
+/**
+ * Creates a recursive descent parser that preserves metadata for each consumed
+ * code point.
+ */
 export declare const descentParser: <T>(fr: FRule) => DescentMatch<T>;
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ */
 export declare const parser: (fr: FRule) => Match;
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ */
 export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
 export {};

package/bnf/data/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
+ * for FunctionalScript BNF rules.
+ *
+ * @module
+ */
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
@@ -74,6 +80,10 @@ const toDataAdd = (map) => (fr) => {
     const [map2, set, rule] = newRule(map1);
     return [map2, { ...set, [id]: rule }, id];
 };
+/**
+ * Converts a functional grammar rule into serializable BNF data and returns
+ * the generated rule set with the entry rule identifier.
+ */
 export const toData = (fr) => {
     const [, ruleSet, id] = toDataAdd({})(fr);
     return [ruleSet, id];
@@ -91,6 +101,9 @@ const dispatchOp = rangeMap({
     equal: strictEqual,
     def: null,
 });
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ */
 export const dispatchMap = (ruleSet) => {
     const addRuleToDispatch = (dr, name) => {
         if (dr === null)
@@ -196,9 +209,17 @@ const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
         return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
     }
 };
+/**
+ * Creates a map that describes whether each rule can consume empty input and,
+ * for tagged variants, which tag represents the empty match.
+ */
 export const createEmptyTagMap = (data) => {
     return emptyTagMapAdd(data[0])({})(data[1])[1];
 };
+/**
+ * Creates a recursive descent parser that preserves metadata for each consumed
+ * code point.
+ */
 export const descentParser = (fr) => {
     const data = toData(fr);
     const emptyTagMap = createEmptyTagMap(data);
@@ -256,10 +277,16 @@ export const descentParser = (fr) => {
     };
     return match;
 };
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ */
 export const parser = (fr) => {
     const data = toData(fr);
     return parserRuleSet(data[0]);
 };
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ */
 export const parserRuleSet = (ruleSet) => {
     const map = dispatchMap(ruleSet);
     const f = (rule, cp) => {

package/bnf/module.f.js

@@ -1,3 +1,11 @@
+/**
+ * Core BNF grammar primitives and helpers for describing parser rules.
+ *
+ * The module provides terminal-range encoding utilities, rule composition
+ * types, and set/range helpers used by FunctionalScript grammar definitions.
+ *
+ * @module
+ */
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";

package/cas/module.f.d.ts

@@ -5,19 +5,19 @@
  */
 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/effects/module.f.ts";
-import { type Fs, type NodeOperations } from "../types/effects/node/module.f.ts";
-export type KvStore<O extends Operations> = {
+import { type Effect, type Operation } from "../types/effects/module.f.ts";
+import { type Fs, type NodeOp } from "../types/effects/node/module.f.ts";
+export type KvStore<O extends Operation> = {
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
     readonly write: (key: Vec, value: Vec) => Effect<O, void>;
     readonly list: () => Effect<O, readonly Vec[]>;
 };
 export type Kv = readonly [Vec, Vec];
 export declare const fileKvStore: (path: string) => KvStore<Fs>;
-export type Cas<O extends Operations> = {
+export type Cas<O extends Operation> = {
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
     readonly write: (value: Vec) => Effect<O, Vec>;
     readonly list: () => Effect<O, readonly Vec[]>;
 };
-export declare const cas: (sha2: Sha2) => <O extends Operations>(_: KvStore<O>) => Cas<O>;
-export declare const main: (args: readonly string[]) => Effect<NodeOperations, number>;
+export declare const cas: (sha2: Sha2) => <O extends Operation>(_: KvStore<O>) => Cas<O>;
+export declare const main: (args: readonly string[]) => Effect<NodeOp, number>;

package/cas/module.f.js

@@ -6,7 +6,7 @@
 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";
-import { fluent, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../types/effects/module.f.js";
 import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
@@ -20,29 +20,26 @@ const toPath = (key) => {
     return `${prefix}/${a}/${b}/${c}`;
 };
 export const fileKvStore = (path) => ({
-    read: (key) => fluent
+    read: (key) => begin
         .step(() => readFile(toPath(key)))
-        .step(([status, data]) => pure(status === 'error' ? undefined : data))
-        .effect,
+        .step(([status, data]) => pure(status === 'error' ? undefined : data)),
     write: (key, value) => {
         const p = toPath(key);
         const parts = parse(p);
         const dir = `${path}/${parts.slice(0, -1).join('/')}`;
         // TODO: error handling
-        return fluent
+        return begin
             .step(() => mkdir(dir, { recursive: true }))
             .step(() => writeFile(`${path}/${p}`, value))
-            .step(() => pure(undefined))
-            .effect;
+            .step(() => pure(undefined));
     },
     list: () => 
     // TODO: remove unwrap
-    fluent
+    begin
         .step(() => readdir('.cas', { recursive: true }))
         .step(r => pure(unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile
         ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name)
-        : null))))
-        .effect,
+        : null)))),
 });
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
@@ -50,18 +47,16 @@ export const cas = (sha2) => {
         read,
         write: (value) => {
             const hash = compute([value]);
-            return fluent
+            return begin
                 .step(() => write(hash, value))
-                .step(() => pure(hash))
-                .effect;
+                .step(() => pure(hash));
         },
         list,
     });
 };
-const e = (s) => fluent
+const e = (s) => begin
     .step(() => error(s))
-    .step(() => pure(1))
-    .effect;
+    .step(() => pure(1));
 export const main = (args) => {
     const c = cas(sha256)(fileKvStore('.'));
     const [cmd, ...options] = args;
@@ -71,12 +66,11 @@ export const main = (args) => {
                 return e("'cas add' expects one parameter");
             }
             const [path] = options;
-            return fluent
+            return begin
                 .step(() => readFile(path))
                 .step(v => c.write(unwrap(v)))
                 .step(hash => log(vecToCBase32(hash)))
-                .step(() => pure(0))
-                .effect;
+                .step(() => pure(0));
         }
         case 'get': {
             if (options.length !== 2) {
@@ -87,36 +81,32 @@ export const main = (args) => {
             if (hash === null) {
                 return e(`invalid hash format: ${hashCBase32}`);
             }
-            return fluent
+            return begin
                 .step(() => c.read(hash))
                 .step(v => {
                 const result = v === undefined
                     ? e(`no such hash: ${hashCBase32}`)
-                    : fluent
+                    : begin
                         .step(() => writeFile(path, v))
-                        .step(() => pure(0))
-                        .effect;
+                        .step(() => pure(0));
                 return result;
-            })
-                .effect;
+            });
         }
         case 'list': {
-            return fluent
+            return begin
                 .step(() => c.list())
                 .step(v => {
                 // TODO: make it lazy.
-                let i = fluent.effect;
+                let i = begin;
                 for (const j of v) {
                     const prev = i;
-                    i = fluent
+                    i = begin
                         .step(() => prev)
-                        .step(() => log(vecToCBase32(j)))
-                        .effect;
+                        .step(() => log(vecToCBase32(j)));
                 }
                 return i;
             })
-                .step(() => pure(0))
-                .effect;
+                .step(() => pure(0));
         }
         case undefined: {
             return e('Error: CAS command requires subcommand');

package/ci/module.f.d.ts

@@ -1,4 +1,5 @@
-import { type NodeEffect } from '../types/effects/node/module.f.ts';
-export declare const effect: NodeEffect<number>;
-declare const _default: () => import("../types/effects/module.f.ts").Pure<number>;
+import { type Effect } from '../types/effects/module.f.ts';
+import { type NodeOp } from '../types/effects/node/module.f.ts';
+export declare const effect: Effect<NodeOp, number>;
+declare const _default: () => Effect<NodeOp, number>;
 export default _default;

package/ci/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { fluent, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../types/effects/module.f.js";
 import { writeFile } from "../types/effects/node/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
 const architecture = ['intel', 'arm'];
@@ -177,8 +177,7 @@ const gha = {
     on: { pull_request: {} },
     jobs,
 };
-export const effect = fluent
+export const effect = begin
     .step(() => writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  '))))
-    .step(() => pure(0))
-    .effect;
+    .step(() => pure(0));
 export default () => effect;

package/dev/module.f.d.ts

@@ -4,6 +4,8 @@
  * @module
  */
 import { type Io } from '../io/module.f.ts';
+import { type All, type Readdir } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../types/effects/module.f.ts';
 export declare const todo: () => never;
 export type Module = {
     readonly default?: unknown;
@@ -12,6 +14,7 @@ export type ModuleMap = {
     readonly [k in string]: Module;
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
+export declare const allFiles2: (s: string) => Effect<Readdir | All, readonly string[]>;
 export declare const allFiles: (io: Io) => (s: string) => Promise<readonly string[]>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
 export declare const index: (io: Io) => Promise<number>;

package/dev/module.f.js

@@ -6,10 +6,10 @@
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
 import { encodeUtf8 } from "../types/uint8array/module.f.js";
-import { readFile } from "../types/effects/node/module.f.js";
-import { utf8ToString } from "../text/module.f.js";
+import { all, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-import { fluent, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../types/effects/module.f.js";
 export const todo = () => { throw 'not implemented'; };
 const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
@@ -18,6 +18,33 @@ export const env = ({ process: { env } }) => a => {
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
+export const allFiles2 = (s) => {
+    const load = (p) => begin
+        .step(() => readdir(p, {}))
+        .step(d => {
+        let result = [];
+        for (const i of unwrap(d)) {
+            const { name } = i;
+            if (name.startsWith('.')) {
+                continue;
+            }
+            const file = `${p}/${name}`;
+            if (!i.isFile) {
+                if (name === 'node_modules') {
+                    continue;
+                }
+                result = [...result, load(file)];
+                continue;
+            }
+            if (name.endsWith('.js') || name.endsWith('.ts')) {
+                result = [...result, pure([file])];
+            }
+        }
+        return all(...result);
+    })
+        .step(v => pure(v.flat()));
+    return load(s);
+};
 export const allFiles = (io) => (s) => {
     const { fs: { promises: { readdir } } } = io;
     const load = async (p) => {
@@ -58,22 +85,23 @@ export const loadModuleMap = async (io) => {
     return Object.fromEntries(map.toSorted(cmp));
 };
 const denoJson = './deno.json';
-const index2 = fluent
+const index2 = begin
     .step(() => updateVersion)
     .step(() => readFile(denoJson))
-    .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))))
-    .effect;
-export const index = async (io) => {
-    const runner = fromIo(io);
-    const jsr_json = await runner(index2);
-    const list = (await allFiles(io)('.')).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
-    // console.log(list)
+    .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))));
+const allFiles2a = (jsr_json) => begin
+    .step(() => allFiles2('.'))
+    .step(files => {
+    // console.log(files)
+    const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
-    // console.log(exportsA)
     const exports = Object.fromEntries(exportsA);
-    // console.log(exports)
     const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
-    // console.log(json)
-    await io.fs.promises.writeFile(denoJson, encodeUtf8(json));
-    return 0;
+    return writeFile(denoJson, utf8(json));
+})
+    .step(() => pure(0));
+export const index = async (io) => {
+    const runner = fromIo(io);
+    const jsr_json = await runner(index2);
+    return await runner(allFiles2a(jsr_json));
 };

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

@@ -1,2 +1,3 @@
-import { type NodeEffect } from "../../types/effects/node/module.f.ts";
-export declare const updateVersion: NodeEffect<number>;
+import { type Effect } from "../../types/effects/module.f.ts";
+import { type All, type ReadFile, type WriteFile } from "../../types/effects/node/module.f.ts";
+export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;

package/dev/version/module.f.js

@@ -4,24 +4,24 @@
  * @module
  */
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { all, fluent, pure, step } from "../../types/effects/module.f.js";
-import { readFile, writeFile } from "../../types/effects/node/module.f.js";
+import { begin, pure } from "../../types/effects/module.f.js";
+import { all, readFile, writeFile } from "../../types/effects/node/module.f.js";
 import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = (name) => fluent
+const readJson = (name) => begin
     .step(() => readFile(jsonFile(name)))
-    .step(v => pure(parse(utf8ToString(unwrap(v)))))
-    .effect;
-const writeVersion = (version) => (name) => step(readJson(name))(json => writeFile(jsonFile(name), utf8(stringify({
+    .step(v => pure(parse(utf8ToString(unwrap(v)))));
+const writeVersion = (version) => (name) => begin
+    .step(() => readJson(name))
+    .step(json => writeFile(jsonFile(name), utf8(stringify({
     ...json,
     version,
 }, null, 2))));
-export const updateVersion = fluent
+export const updateVersion = begin
     .step(() => readJson('package'))
     .step(p => {
     const w = writeVersion(p.version);
-    return all([w('package'), w('deno')]);
+    return all(w('package'), w('deno'));
 })
-    .step(() => pure(0))
-    .effect;
+    .step(() => pure(0));

package/dev/version/test.f.js

@@ -1,8 +1,6 @@
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { isVec } from "../../types/bit_vec/module.f.js";
-import { run } from "../../types/effects/mock/module.f.js";
-import { all } from "../../types/effects/module.f.js";
-import { writeFile } from "../../types/effects/node/module.f.js";
+import { all, writeFile } from "../../types/effects/node/module.f.js";
 import { emptyState, virtual } from "../../types/effects/node/virtual/module.f.js";
 import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
@@ -81,13 +79,12 @@ const e = '{\n' +
     '}';
 export default {
     new: () => {
-        const rv = run(virtual);
         const w = (name) => {
             const fn = `${name}.json`;
             return writeFile(fn, utf8(JSON.stringify(x[fn])));
         };
-        const [state] = rv(emptyState)(all([w('package'), w('deno')]));
-        const [newState, result] = rv(state)(updateVersion);
+        const [state] = virtual(emptyState)(all(w('package'), w('deno')));
+        const [newState, result] = virtual(state)(updateVersion);
         if (result !== 0) {
             throw result;
         }

package/io/module.f.d.ts

@@ -1,4 +1,5 @@
-import type { NodeEffect } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../types/effects/module.f.ts';
+import type { NodeOp } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -104,4 +105,5 @@ 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 } }, fetch, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;
+export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -1,4 +1,6 @@
+import { todo } from "../dev/module.f.js";
 import { normalize } from "../path/module.f.js";
+import { pure } from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, toVec } from "../types/uint8array/module.f.js";
@@ -7,7 +9,7 @@ import { fromVec, toVec } from "../types/uint8array/module.f.js";
  * Handles errors by exiting with code 1
  */
 export const run = (io) => {
-    const code = ([x, b]) => {
+    const exitCode = ([x, b]) => {
         if (x === 'error') {
             io.console.error(b);
             return 1;
@@ -16,7 +18,7 @@ export const run = (io) => {
             return b;
         }
     };
-    return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
+    return async (f) => io.process.exit(exitCode(await io.asyncTryCatch(() => f(io))));
 };
 const tc = async (f) => {
     try {
@@ -26,19 +28,23 @@ const tc = async (f) => {
         return error(e);
     }
 };
-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 }))
-        .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
-    writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
-});
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => {
+    const result = asyncRun({
+        all: async (effects) => await Promise.all(effects.map(v => result(v))),
+        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 }))
+            .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
+        writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+    });
+    return result;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.10.3",
+  "version": "0.11.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -14,9 +14,9 @@
     "index": "node ./dev/index/module.ts",
     "fst": "node ./fjs/module.ts t",
     "fjs": "node ./fjs/module.ts",
-    "ci-update": "node ./ci/module.ts",
+    "ci-update": "node ./fjs/module.ts r ./ci/module.f.ts",
     "update": "git clean -fdx && npm install && npm run index && npm run ci-update",
-    "website": "node --experimental-strip-types ./website/module.ts"
+    "website": "node --experimental-strip-types ./fjs/module.ts r ./website/module.f.ts"
   },
   "engines": {
     "node": ">=20"

package/types/effects/mock/module.f.d.ts

@@ -3,8 +3,9 @@
  *
  * @module
  */
-import type { Effect, Operations } from "../module.f.ts";
-export type MemOperationMap<O extends Operations, S> = {
-    readonly [K in keyof O]: (state: S, payload: O[K][0]) => readonly [S, O[K][1]];
+import type { Effect, Operation, Pr } from "../module.f.ts";
+export type MemOperationMap<O extends Operation, S> = {
+    readonly [K in O[0]]: (state: S, payload: Pr<O, K>[0]) => readonly [S, Pr<O, K>[1]];
 };
-export declare const run: <O extends Operations, S>(o: MemOperationMap<O, S>) => (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];
+export type RunInstance<O extends Operation, S> = (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];
+export declare const run: <O extends Operation, S>(o: MemOperationMap<O, S>) => RunInstance<O, S>;

package/types/effects/mock/module.f.js

@@ -1,11 +1,13 @@
-export const run = (o) => (state) => (effect) => {
+export const run = (o) => state => effect => {
     let s = state;
     let e = effect;
     while (true) {
-        if (e.length === 1) {
-            return [s, e[0]];
+        const { value } = e;
+        if (value.length === 1) {
+            const [v] = value;
+            return [s, v];
         }
-        const [cmd, payload, cont] = e;
+        const [cmd, payload, cont] = value;
         const operation = o[cmd];
         const [ns, m] = operation(s, payload);
         s = ns;

package/types/effects/module.d.ts

@@ -1,2 +1,2 @@
-import type { Effect, Operations, ToAsyncOperationMap } from "./module.f.ts";
-export declare const asyncRun: <O extends Operations>(map: ToAsyncOperationMap<O>) => <T, E extends Effect<O, T>>(effect: Effect<O, T>) => Promise<T>;
+import type { Effect, Operation, ToAsyncOperationMap } from "./module.f.ts";
+export declare const asyncRun: <O extends Operation>(map: ToAsyncOperationMap<O>) => <T, E extends Effect<O, T>>(effect: Effect<O, T>) => Promise<T>;

package/types/effects/module.f.d.ts

@@ -3,25 +3,23 @@
  *
  * @module
  */
-export type Operations = {
-    readonly [command in string]: readonly [input: unknown, output: unknown];
+export type Operation = readonly [string, (_: never) => unknown];
+export type Effect<O extends Operation, T> = {
+    value: Value<O, T>;
+    step: <Q extends Operation, R>(f: (p: T) => Effect<Q, R>) => Effect<O | Q, R>;
 };
-export type Effect<O extends Operations, T> = Pure<T> | Do<O, T>;
+export type Value<O extends Operation, T> = Pure<T> | Do<O, T>;
 export type Pure<T> = readonly [T];
-export type One<O extends Operations, T, K extends keyof O & string> = readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>];
-export type Do<O extends Operations, T> = {
-    readonly [K in keyof O & string]: One<O, T, K>;
-}[keyof O & string];
-export declare const pure: <T>(value: T) => Pure<T>;
-export declare const do_: <O extends Operations, K extends keyof O & string>(cmd: K, payload: O[K][0]) => Do<O, O[K][1]>;
-export type ToAsyncOperationMap<O extends Operations> = {
-    readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>;
+export type DoKPR<O extends Operation, T, K extends string, PR extends readonly [unknown, unknown]> = readonly [K, PR[0], (_: PR[1]) => Effect<O, T>];
+export type Pr<O extends Operation, K extends O[0]> = O extends readonly [K, (_: infer P) => infer R] ? readonly [P, R] : never;
+export type DoK<O extends Operation, T, K extends O[0]> = DoKPR<O, T, K, Pr<O, K>>;
+export type Do<O extends Operation, T> = DoK<O, T, O[0]>;
+export declare const pure: <T>(v: T) => Effect<never, T>;
+export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, param: Pr<O, K>[0], cont: (input: Pr<O, K>[1]) => Effect<O, T>) => Effect<O, T>;
+export declare const do_: <O extends Operation>(cmd: O[0]) => (param: Pr<O, O[0]>[0]) => Effect<O, Pr<O, O[0]>[1]>;
+export declare const begin: Effect<never, void>;
+export type ToAsyncOperationMap<O extends Operation> = {
+    readonly [K in O[0]]: (payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
 };
-export declare const step: <O extends Operations, T>(e: Effect<O, T>) => <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Effect<O | O1, R>;
-export declare const map: <O extends Operations, T>(e: Effect<O, T>) => <R>(f: (_: T) => R) => Effect<O, R>;
-export type Fluent<O extends Operations, T> = {
-    readonly effect: Effect<O, T>;
-    readonly step: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Fluent<O | O1, R>;
-};
-export declare const fluent: Fluent<{}, void>;
-export declare const all: <O extends Operations, T>(set: readonly Effect<O, T>[]) => Effect<O, readonly T[]>;
+export type F<O extends Operation> = Pr<O, O[0]>;
+export type Func<O extends Operation> = (_: F<O>[0]) => Effect<O, F<O>[1]>;

package/types/effects/module.f.js

@@ -1,20 +1,80 @@
-export const pure = (value) => [value];
-const doFull = (cmd, payload, cont) => [cmd, payload, cont];
-export const do_ = (cmd, payload) => doFull(cmd, payload, pure);
-export const step = (e) => (f) => {
+/**
+ * Core effect type constructors and combinators.
+ *
+ * @module
+ */
+export const pure = (v) => ({
+    value: [v],
+    step: f => f(v)
+});
+export const doFull = (cmd, param, cont) => ({
+    value: [cmd, param, cont],
+    step: (f) => doFull(cmd, param, x => cont(x).step(f)),
+});
+export const do_ = (cmd) => (param) => doFull(cmd, param, pure);
+export const begin = pure(undefined);
+//----------------------------------------------------------------------
+/*
+export type Operations = {
+    readonly [command in string]: readonly [input: unknown, output: unknown]
+}
+
+export type Effect<O extends Operations, T> = Pure<O, T> | Do<O, T>
+
+export type Pure<O, T> = readonly [T]
+
+export type One<O extends Operations, T, K extends keyof O & string> =
+    readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>]
+
+export type Do<O extends Operations, T> = { readonly [K in keyof O & string]: One<O, T, K> }[keyof O & string]
+
+export const pure = <O extends Operations, T>(value: T): Pure<O, T> => [value]
+
+const doFull = <O extends Operations, K extends keyof O & string, T>(
+    cmd: K,
+    payload: O[K][0],
+    cont: (input: O[K][1]) => Effect<O, T>
+): Do<O, T> =>
+    [cmd, payload, cont]
+
+export const do_ = <O extends Operations, K extends keyof O & string>(
+    cmd: K,
+    payload: O[K][0]
+): Do<O, O[K][1]> =>
+    doFull(cmd, payload, pure)
+
+export type ToAsyncOperationMap<O extends Operations> = {
+    readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>
+}
+
+export const step =
+    <O extends Operations, T>(e: Effect<O, T>) =>
+    <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>): Effect<O | O1, R> =>
+{
     if (e.length === 1) {
-        const [value] = e;
-        return f(value);
+        const [value] = e
+        return f(value)
     }
-    const [cmd, payload, cont] = e;
-    return doFull(cmd, payload, x => step(cont(x))(f));
-};
-export const map = (e) => (f) => step(e)(x => pure(f(x)));
-const wrap = (effect) => ({
+    const [cmd, payload, cont] = e
+    return doFull(cmd, payload, x => step(cont(x))(f))
+}
+
+export const map =
+    <O extends Operations, T>(e: Effect<O, T>) =>
+    <R>(f: (_: T) => R): Effect<O, R> =>
+    step(e)(x => pure(f(x)))
+
+export type Fluent<O extends Operations, T> = {
+    readonly effect: Effect<O, T>
+    readonly step: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Fluent<O | O1, R>
+}
+
+const wrap = <O extends Operations, T>(effect: Effect<O, T>): Fluent<O, T> => ({
     effect,
     step: x => wrap(step(effect)(x)),
-});
-export const fluent = wrap(pure(undefined));
-const empty = pure([]);
-// TODO: replace with either a `Do` operation or as an addition to `Pure` and `Do`.
-export const all = (set) => set.reduce((previous, current) => step(previous)(previousResult => map(current)(currentResult => [...previousResult, currentResult])), empty);
+})
+
+export const fluent: Fluent<{}, void> = wrap(pure(undefined))
+
+const empty: Effect<{}, readonly never[]> = pure([])
+*/

package/types/effects/module.js

@@ -1,9 +1,10 @@
 export const asyncRun = (map) => async (effect) => {
     while (true) {
-        if (effect.length === 1) {
-            return effect[0];
+        const { value } = effect;
+        if (value.length === 1) {
+            return value[0];
         }
-        const [command, payload, continuation] = effect;
+        const [command, payload, continuation] = value;
         const operation = map[command];
         const result = await operation(payload);
         effect = continuation(result);

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

@@ -1,23 +1,26 @@
 import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
-import { type Do, type Effect, type ToAsyncOperationMap } from '../module.f.ts';
+import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
-export type Fetch = {
-    readonly fetch: readonly [string, IoResult<Vec>];
-};
-export declare const fetch: (url: string) => Do<Fetch, IoResult<Vec>>;
+export type All = ['all', <T>(_: readonly Effect<never, T>[]) => readonly T[]];
+/**
+ * To run the operation `O` should be known by the runner/engine.
+ * This is the reason why we merge `O` with `All` in the resulted `Effect`.
+ *
+ * @param a
+ * @returns
+ */
+export declare const all: <O extends Operation, T>(...a: readonly Effect<O, T>[]) => Effect<O | All, readonly T[]>;
+export type Fetch = ['fetch', (_: string) => IoResult<Vec>];
+export declare const fetch: Func<Fetch>;
 export type MakeDirectoryOptions = {
     readonly recursive: true;
 };
 export type MkdirParam = readonly [string, MakeDirectoryOptions?];
-export type Mkdir = {
-    readonly mkdir: readonly [MkdirParam, IoResult<void>];
-};
-export declare const mkdir: (...p: MkdirParam) => Do<Mkdir, IoResult<void>>;
-export type ReadFile = {
-    readonly readFile: readonly [string, IoResult<Vec>];
-};
-export declare const readFile: (path: string) => Do<ReadFile, IoResult<Vec>>;
+export type Mkdir = readonly ['mkdir', (_: MkdirParam) => IoResult<void>];
+export declare const mkdir: (...p: MkdirParam) => Effect<Mkdir, IoResult<void>>;
+export type ReadFile = readonly ['readFile', (_: string) => IoResult<Vec>];
+export declare const readFile: Func<ReadFile>;
 /**
  * Represents a directory entry (file or directory) in the filesystem
  * @see https://nodejs.org/api/fs.html#class-fsdirent
@@ -31,26 +34,18 @@ export type ReaddirOptions = {
     readonly recursive?: true;
 };
 export type ReaddirParam = readonly [string, ReaddirOptions];
-export type Readdir = {
-    readonly readdir: readonly [ReaddirParam, IoResult<readonly Dirent[]>];
-};
-export declare const readdir: (...p: ReaddirParam) => Do<Readdir, IoResult<readonly Dirent[]>>;
+export type Readdir = readonly ['readdir', (_: ReaddirParam) => IoResult<readonly Dirent[]>];
+export declare const readdir: (...p: ReaddirParam) => Effect<Readdir, IoResult<readonly Dirent[]>>;
 export type WriteFileParam = readonly [string, Vec];
-export type WriteFile = {
-    readonly writeFile: readonly [WriteFileParam, IoResult<void>];
-};
-export declare const writeFile: (...p: WriteFileParam) => Do<WriteFile, IoResult<void>>;
-export type Fs = Mkdir & ReadFile & Readdir & WriteFile;
-export type Error = {
-    readonly error: readonly [string, void];
-};
-export declare const error: (msg: string) => Do<Error, void>;
-export type Log = {
-    readonly log: readonly [string, void];
-};
-export declare const log: (msg: string) => Do<Log, void>;
-export type Console = Log & Error;
-export type NodeOperations = Fetch & Console & Fs;
-export type NodeEffect<T> = Effect<NodeOperations, T>;
-export type NodeOperationMap = ToAsyncOperationMap<NodeOperations>;
-export type NodeProgram = (argv: readonly string[]) => NodeEffect<number>;
+export type WriteFile = readonly ['writeFile', (_: WriteFileParam) => IoResult<void>];
+export declare const writeFile: (...p: WriteFileParam) => Effect<WriteFile, IoResult<void>>;
+export type Fs = Mkdir | ReadFile | Readdir | WriteFile;
+export type Error = ['error', (_: string) => void];
+export declare const error: Func<Error>;
+export type Log = ['log', (_: string) => void];
+export declare const log: Func<Log>;
+export type Console = Log | Error;
+export type NodeOp = All | Fetch | Console | Fs;
+export type NodeEffect<T> = Effect<NodeOp, T>;
+export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
+export type NodeProgram = (argv: readonly string[]) => Effect<NodeOp, number>;

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

@@ -1,8 +1,19 @@
 import { do_ } from "../module.f.js";
-export const fetch = (url) => do_('fetch', url);
-export const mkdir = (...p) => do_('mkdir', p);
-export const readFile = (path) => do_('readFile', path);
-export const readdir = (...p) => do_('readdir', p);
-export const writeFile = (...p) => do_('writeFile', p);
-export const error = (msg) => do_('error', msg);
-export const log = (msg) => do_('log', msg);
+/**
+ * To run the operation `O` should be known by the runner/engine.
+ * This is the reason why we merge `O` with `All` in the resulted `Effect`.
+ *
+ * @param a
+ * @returns
+ */
+export const all = (...a) => {
+    const result = do_('all')(a);
+    return result;
+};
+export const fetch = do_('fetch');
+export const mkdir = (...p) => do_('mkdir')(p);
+export const readFile = do_('readFile');
+export const readdir = (...p) => do_('readdir')(p);
+export const writeFile = (...p) => do_('writeFile')(p);
+export const error = do_('error');
+export const log = do_('log');

package/types/effects/node/test.f.js

@@ -1,26 +1,27 @@
 import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
-import { map } from "../module.f.js";
 import { run } from "../mock/module.f.js";
+import { pure } from "../module.f.js";
 import { fetch, mkdir, readdir, readFile, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export default {
     map: () => {
-        let e = map(readFile('hello'))(([k, v]) => {
+        let e = readFile('hello').step(([k, v]) => {
             if (k === 'error') {
                 throw v;
             }
-            return uint(v) * 2n;
+            return pure(uint(v) * 2n);
         });
         //
         while (true) {
-            if (e.length === 1) {
-                const result = e[0];
+            const { value } = e;
+            if (value.length === 1) {
+                const [result] = value;
                 if (result !== 0x2an) {
                     throw result;
                 }
                 return;
             }
-            const [cmd, p, cont] = e;
+            const [cmd, p, cont] = value;
             if (cmd !== 'readFile') {
                 throw cmd;
             }
@@ -31,8 +32,7 @@ export default {
         }
     },
     fetch: () => {
-        const v = run(virtual);
-        const [_, [t, result]] = v({
+        const [_, [t, result]] = virtual({
             ...emptyState,
             internet: {
                 'https://example.com/data': vec8(0x2an),
@@ -50,8 +50,7 @@ export default {
     },
     mkdir: {
         one: () => {
-            const v = run(virtual);
-            const [state, [t, result]] = v(emptyState)(mkdir('a'));
+            const [state, [t, result]] = virtual(emptyState)(mkdir('a'));
             if (t === 'error') {
                 throw result;
             }
@@ -61,7 +60,7 @@ export default {
             }
         },
         rec: () => {
-            const [state, [t, result]] = run(virtual)(emptyState)(mkdir('tmp/cache', { recursive: true }));
+            const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache', { recursive: true }));
             if (t !== 'ok') {
                 throw result;
             }
@@ -75,7 +74,7 @@ export default {
             }
         },
         nonRec: () => {
-            const [state, [t, result]] = run(virtual)(emptyState)(mkdir('tmp/cache'));
+            const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache'));
             if (t !== 'error') {
                 throw result;
             }
@@ -86,14 +85,13 @@ export default {
     },
     readFile: {
         one: () => {
-            const v = run(virtual);
             const initial = {
                 ...emptyState,
                 root: {
                     hello: vec8(0x2an),
                 },
             };
-            const [state, [t, result]] = v(initial)(readFile('hello'));
+            const [state, [t, result]] = virtual(initial)(readFile('hello'));
             if (t === 'error') {
                 throw result;
             }
@@ -108,7 +106,7 @@ export default {
             }
         },
         nested: () => {
-            const [_, [tag, result]] = run(virtual)({
+            const [_, [tag, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { cache: vec8(0x15n) } }
             })(readFile('tmp/cache'));
@@ -120,13 +118,13 @@ export default {
             }
         },
         noSuchFile: () => {
-            const [_, [t, result]] = run(virtual)(emptyState)(readFile('hello'));
+            const [_, [t, result]] = virtual(emptyState)(readFile('hello'));
             if (t !== 'error') {
                 throw result;
             }
         },
         nestedPath: () => {
-            const [_, [t, result]] = run(virtual)(emptyState)(readFile('tmp/cache'));
+            const [_, [t, result]] = virtual(emptyState)(readFile('tmp/cache'));
             if (t !== 'error') {
                 throw result;
             }
@@ -137,7 +135,7 @@ export default {
     },
     readdir: {
         one: () => {
-            const [_, [t, result]] = run(virtual)({
+            const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
                     file: vec8(0x2an),
@@ -159,7 +157,7 @@ export default {
             }
         },
         nonRecursive: () => {
-            const [_, [t, result]] = run(virtual)({
+            const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
                     file: vec8(0x2an),
@@ -184,7 +182,7 @@ export default {
             }
         },
         nested: () => {
-            const [_, [t, result]] = run(virtual)({
+            const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { cache: vec8(0x15n) } }
             })(readdir('tmp', { recursive: true }));
@@ -203,7 +201,7 @@ export default {
             }
         },
         noSuchDir: () => {
-            const [_, [t, result]] = run(virtual)(emptyState)(readdir('tmp', { recursive: true }));
+            const [_, [t, result]] = virtual(emptyState)(readdir('tmp', { recursive: true }));
             if (t !== 'error') {
                 throw result;
             }
@@ -214,7 +212,7 @@ export default {
     },
     writeFile: {
         one: () => {
-            const [state, [t, result]] = run(virtual)(emptyState)(writeFile('hello', vec8(0x2an)));
+            const [state, [t, result]] = virtual(emptyState)(writeFile('hello', vec8(0x2an)));
             if (t !== 'ok') {
                 throw result;
             }
@@ -227,7 +225,7 @@ export default {
             }
         },
         overwrite: () => {
-            const [state, [t, result]] = run(virtual)({
+            const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: {
                     hello: vec8(0x15n),
@@ -245,7 +243,7 @@ export default {
             }
         },
         nestedPath: () => {
-            const [state, [t, result]] = run(virtual)(emptyState)(writeFile('tmp/cache', vec8(0x2an)));
+            const [state, [t, result]] = virtual(emptyState)(writeFile('tmp/cache', vec8(0x2an)));
             if (t !== 'error') {
                 throw result;
             }
@@ -257,7 +255,7 @@ export default {
             }
         },
         directory: () => {
-            const [state, [t, result]] = run(virtual)({
+            const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: {
                     tmp: {},

package/types/effects/node/virtual/module.f.d.ts

@@ -1,16 +1,16 @@
 import { type Vec } from "../../../bit_vec/module.f.ts";
-import type { MemOperationMap } from "../../mock/module.f.ts";
-import type { NodeOperations } from "../module.f.ts";
-export type VirtualDir = {
-    readonly [name in string]?: VirtualDir | Vec;
+import { type RunInstance } from "../../mock/module.f.ts";
+import type { NodeOp } from "../module.f.ts";
+export type Dir = {
+    readonly [name in string]?: Dir | Vec;
 };
-export type VirtualState = {
+export type State = {
     stdout: string;
     stderr: string;
-    root: VirtualDir;
+    root: Dir;
     internet: {
         readonly [url: string]: Vec;
     };
 };
-export declare const emptyState: VirtualState;
-export declare const virtual: MemOperationMap<NodeOperations, VirtualState>;
+export declare const emptyState: State;
+export declare const virtual: RunInstance<NodeOp, State>;

package/types/effects/node/virtual/module.f.js

@@ -6,6 +6,8 @@
 import { parse } from "../../../../path/module.f.js";
 import { isVec } from "../../../bit_vec/module.f.js";
 import { error, ok } from "../../../result/module.f.js";
+import { run } from "../../mock/module.f.js";
+import { pure } from "../../module.f.js";
 export const emptyState = {
     stdout: '',
     stderr: '',
@@ -30,7 +32,6 @@ const operation = (op) => {
         return [{ ...state, root }, result];
     };
 };
-// TODO: we can have a better implementation with some code shared with `operation`.
 const readOperation = (op) => operation((dir, path) => [dir, op(dir, path)]);
 const okVoid = ok(undefined);
 const mkdir = (recursive) => operation((dir, path) => {
@@ -94,7 +95,16 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
     return ok(f(base, dir));
 });
 const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name]}${payload}\n` }, undefined];
-export const virtual = {
+const map = {
+    all: (state, a) => {
+        let e = [];
+        for (const i of a) {
+            const [ns, ei] = virtual(state)(i);
+            state = ns;
+            e = [...e, ei];
+        }
+        return [state, e];
+    },
     error: console('stderr'),
     log: console('stdout'),
     fetch: (state, url) => {
@@ -106,3 +116,4 @@ export const virtual = {
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
     writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
 };
+export const virtual = run(map);

package/website/module.f.d.ts

@@ -1,2 +1,4 @@
-declare const _default: () => import("../types/effects/module.f.ts").Pure<number>;
+import { type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../types/effects/module.f.ts';
+declare const _default: () => Effect<NodeOp, number>;
 export default _default;

package/website/module.f.js

@@ -6,12 +6,11 @@
 import { htmlToString } from "../html/module.f.js";
 import { writeFile } from "../types/effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
-import { fluent, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../types/effects/module.f.js";
 const html = ['body',
     ['a', { href: 'https://github.com/functionalscript/functionalscript' }, 'GitHub Repository']
 ];
-const program = fluent
+const program = begin
     .step(() => writeFile('index.html', utf8(htmlToString(html))))
-    .step(() => pure(0))
-    .effect;
+    .step(() => pure(0));
 export default () => program;

package/ci/module.d.ts

@@ -1 +0,0 @@
-export {};

package/ci/module.js

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

package/website/module.d.ts

@@ -1 +0,0 @@
-export {};

package/website/module.js

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