functionalscript 0.10.3 → 0.11.1

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,40 @@
  */
 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> = {
+    /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    /** Writes a key/value pair to the underlying storage. */
     readonly write: (key: Vec, value: Vec) => Effect<O, void>;
+    /** Lists all keys available in the store. */
     readonly list: () => Effect<O, readonly Vec[]>;
 };
+/** A key/value tuple where index `0` is the key and index `1` is the value. */
 export type Kv = readonly [Vec, Vec];
+/**
+ * Creates a filesystem-backed key/value store under the provided root path.
+ */
 export declare const fileKvStore: (path: string) => KvStore<Fs>;
-export type Cas<O extends Operations> = {
+export type Cas<O extends Operation> = {
+    /** Reads content by hash; returns `undefined` when not found. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    /** Stores content and returns its computed hash. */
     readonly write: (value: Vec) => Effect<O, Vec>;
+    /** Lists all stored content hashes. */
     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>;
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ */
+export declare const cas: (sha2: Sha2) => <O extends Operation>(_: KvStore<O>) => Cas<O>;
+/**
+ * Runs the CAS CLI.
+ *
+ * Supported subcommands:
+ * - `add <path>`: stores file content and prints the hash.
+ * - `get <hash> <path>`: restores content by hash into a file.
+ * - `list`: prints all known hashes.
+ */
+export declare const main: (args: readonly string[]) => Effect<NodeOp, number>;

package/cas/module.f.js

@@ -6,62 +6,73 @@
 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";
 const o = { withFileTypes: true };
 const split = (s) => [s.substring(0, 2), s.substring(2)];
 const prefix = '.cas';
+/** Converts a content key to its sharded relative CAS file path. */
 const toPath = (key) => {
     const s = vecToCBase32(key);
     const [a, bc] = split(s);
     const [b, c] = split(bc);
     return `${prefix}/${a}/${b}/${c}`;
 };
+/**
+ * Creates a filesystem-backed key/value store under the provided root path.
+ */
 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)))),
 });
+/**
+ * Builds a content-addressable storage facade from a SHA-2 implementation.
+ */
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
     return ({ read, write, list }) => ({
         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
+/** Prints an error message and returns exit code `1`. */
+const e = (s) => begin
     .step(() => error(s))
-    .step(() => pure(1))
-    .effect;
+    .step(() => pure(1));
+/**
+ * Runs the CAS CLI.
+ *
+ * Supported subcommands:
+ * - `add <path>`: stores file content and prints the hash.
+ * - `get <hash> <path>`: restores content by hash into a file.
+ * - `list`: prints all known hashes.
+ */
 export const main = (args) => {
     const c = cas(sha256)(fileKvStore('.'));
     const [cmd, ...options] = args;
@@ -71,12 +82,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 +97,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/crypto/sha2/module.f.d.ts

@@ -7,7 +7,9 @@ import type { Array16, Array8 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { Fold } from '../../types/function/operator/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
+/** 8-word SHA-2 state vector. */
 export type V8 = Array8<bigint>;
+/** 16-word SHA-2 message schedule chunk. */
 export type V16 = Array16<bigint>;
 /**
  * Type definition for the state of the SHA-2 algorithm.
@@ -75,8 +77,16 @@ export type Sha2 = {
      */
     readonly end: (state: State) => Vec;
 };
+/**
+ * Computes a SHA-2 hash from a list of message chunks.
+ *
+ * @param sha2 A SHA-2 algorithm configuration.
+ * @returns A function that hashes the full list of chunks.
+ */
 export declare const computeSync: ({ append, init, end }: Sha2) => (list: List<Vec>) => Vec;
+/** 32-bit SHA-2 base configuration shared by SHA-224 and SHA-256. */
 export declare const base32: Base;
+/** 64-bit SHA-2 base configuration shared by SHA-384, SHA-512, SHA-512/224 and SHA-512/256. */
 export declare const base64: Base;
 /** SHA-256 */
 export declare const sha256: Sha2;

package/crypto/sha2/module.f.js

@@ -167,10 +167,17 @@ const sha2 = ({ append, end, chunkLength }, hash, hashLength) => ({
     append,
     end: end(hashLength),
 });
+/**
+ * Computes a SHA-2 hash from a list of message chunks.
+ *
+ * @param sha2 A SHA-2 algorithm configuration.
+ * @returns A function that hashes the full list of chunks.
+ */
 export const computeSync = ({ append, init, end }) => {
     const f = fold(append)(init);
     return (list) => end(f(list));
 };
+/** 32-bit SHA-2 base configuration shared by SHA-224 and SHA-256. */
 export const base32 = base({
     logBitLen: 5n,
     k: [
@@ -196,6 +203,7 @@ export const base32 = base({
     ss0: [7n, 18n, 3n],
     ss1: [17n, 19n, 10n],
 });
+/** 64-bit SHA-2 base configuration shared by SHA-384, SHA-512, SHA-512/224 and SHA-512/256. */
 export const base64 = base({
     logBitLen: 6n,
     k: [

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

@@ -14,10 +14,25 @@ export type All = {
     readonly int2octets: (x: bigint) => Vec;
     readonly bits2octets: (b: Vec) => Vec;
 };
+/**
+ * Builds RFC6979 helper conversions for a subgroup order.
+ *
+ * @param q - Subgroup order.
+ * @returns Conversion helpers used by deterministic nonce generation.
+ */
 export declare const all: (q: bigint) => All;
+/**
+ * Builds RFC6979 helper conversions from curve parameters.
+ */
 export declare const fromCurve: (c: Curve) => All;
 export declare const concat: (...x: readonly Vec[]) => Vec;
+/**
+ * Computes deterministic ECDSA nonce `k` as described by RFC6979.
+ */
 export declare const computeK: (_: All) => (_: Sha2) => (x: bigint) => (m: Vec) => bigint;
 type Signature = Array2<bigint>;
+/**
+ * Signs a message bit vector and returns an ECDSA `(r, s)` signature pair.
+ */
 export declare const sign: (c: Curve) => (hf: Sha2) => (x: bigint) => (m: Vec) => Signature;
 export {};

package/crypto/sign/module.f.js

@@ -5,6 +5,12 @@ import { computeSync } from "../sha2/module.f.js";
 // qlen to rlen
 const roundUp8 = roundUp(8n);
 const divUp8 = divUp(8n);
+/**
+ * Builds RFC6979 helper conversions for a subgroup order.
+ *
+ * @param q - Subgroup order.
+ * @returns Conversion helpers used by deterministic nonce generation.
+ */
 export const all = (q) => {
     const qlen = bitLength(q);
     const bits2int = (b) => {
@@ -22,11 +28,17 @@ export const all = (q) => {
         bits2octets: b => int2octets(bits2int(b) % q),
     };
 };
+/**
+ * Builds RFC6979 helper conversions from curve parameters.
+ */
 export const fromCurve = (c) => all(c.nf.p);
 const x01 = vec8(0x01n);
 const x00 = vec8(0x00n);
 const ltov = listToVec(msb);
 export const concat = (...x) => ltov(x);
+/**
+ * Computes deterministic ECDSA nonce `k` as described by RFC6979.
+ */
 export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => hf => {
     // TODO: Look at https://www.rfc-editor.org/rfc/rfc6979#section-3.3 to reformulate
     //       it using `HMAC_DRBG`.
@@ -96,6 +108,9 @@ export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => hf =
         }
     };
 };
+/**
+ * Signs a message bit vector and returns an ECDSA `(r, s)` signature pair.
+ */
 export const sign = (c) => (hf) => (x) => (m) => {
     // 2.4 Signature Generation
     const { nf: { p: q, div }, g } = c;

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

@@ -0,0 +1,2 @@
+import { index4 } from '../module.f.ts';
+export default index4;

package/dev/index/module.f.js

@@ -0,0 +1,2 @@
+import { index4 } from "../module.f.js";
+export default index4;

package/dev/module.f.d.ts

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

package/dev/module.f.js

@@ -5,11 +5,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, both, 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,31 +17,34 @@ export const env = ({ process: { env } }) => a => {
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles = (io) => (s) => {
-    const { fs: { promises: { readdir } } } = io;
-    const load = async (p) => {
+export const allFiles2 = (s) => {
+    const load = (p) => begin
+        .step(() => readdir(p, {}))
+        .step(d => {
         let result = [];
-        for (const i of await readdir(p, { withFileTypes: true })) {
+        for (const i of unwrap(d)) {
             const { name } = i;
             if (name.startsWith('.')) {
                 continue;
             }
             const file = `${p}/${name}`;
-            if (i.isDirectory()) {
+            if (!i.isFile) {
                 if (name === 'node_modules') {
                     continue;
                 }
-                result = [...result, ...await load(file)];
+                result = [...result, load(file)];
                 continue;
             }
             if (name.endsWith('.js') || name.endsWith('.ts')) {
-                result = [...result, file];
+                result = [...result, pure([file])];
             }
         }
-        return result;
-    };
+        return all(...result);
+    })
+        .step(v => pure(v.flat()));
     return load(s);
 };
+const allFiles = (io) => (s) => fromIo(io)(allFiles2(s));
 export const loadModuleMap = async (io) => {
     const { fs: { existsSync }, asyncImport } = io;
     let map = [];
@@ -58,22 +60,21 @@ 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 allFiles2aa = begin
+    .step(() => allFiles2('.'))
+    .step(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)
+    return pure(Object.fromEntries(exportsA));
+});
+const index3 = both(index2)(allFiles2aa)
+    .step(([jsr_json, 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 index4 = () => index3;

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>;