functionalscript 0.22.0 → 0.24.0

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

@@ -4,9 +4,10 @@
  *
  * @module
  */
-import { bitLength, max } from "../types/bigint/module.f.js";
+import { bitLength } from "../types/bigint/module.f.js";
 import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { identity } from "../types/function/module.f.js";
+import { max } from "../types/function/compare/module.f.js";
 import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
 const { popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);

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

@@ -5,8 +5,8 @@
  */
 import { type Sha2 } from '../crypto/sha2/module.f.ts';
 import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
-import { type Fs, type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
+import { type Fs, type NodeOp } from '../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>;

package/fs/cas/module.f.js

@@ -6,8 +6,8 @@
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { begin, forEachStep, pure } from "../types/effects/module.f.js";
-import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { begin, forEachStep, pure } from "../effects/module.f.js";
+import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../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 };

package/fs/cas/proof.f.d.ts

@@ -1,4 +1,13 @@
 export declare const proof: {
+    mainAdd: () => void;
+    mainAddWrongArgs: () => void;
+    mainGetFound: () => void;
+    mainGetNotFound: () => void;
+    mainGetWrongArgs: () => void;
+    mainGetInvalidHash: () => void;
+    mainList: () => void;
+    mainNoCmd: () => void;
+    mainUnknownCmd: () => void;
     casWrite: () => void;
     casReadPassthrough: () => void;
 };

package/fs/cas/proof.f.js

@@ -1,9 +1,103 @@
-import { cas } from "./module.f.js";
+import { cas, main } from "./module.f.js";
 import { sha256 } from "../crypto/sha2/module.f.js";
-import { empty, length } from "../types/bit_vec/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { run } from "../types/effects/mock/module.f.js";
+import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { run } from "../effects/mock/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 export const proof = {
+    mainAdd: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [finalState, exitCode] = virtual(state)(main(['add', 'myfile']));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+        if (finalState.stdout.length === 0) {
+            throw 'expected hash in stdout';
+        }
+    },
+    mainAddWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['add']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetFound: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1, exitCode1] = virtual(state)(main(['add', 'myfile']));
+        if (exitCode1 !== 0) {
+            throw ['expected add exit 0', exitCode1];
+        }
+        const hashStr = state1.stdout.trim();
+        const [, exitCode2] = virtual(state1)(main(['get', hashStr, 'output']));
+        if (exitCode2 !== 0) {
+            throw ['expected get exit 0', exitCode2];
+        }
+    },
+    mainGetNotFound: () => {
+        // valid cBase32 hash that has not been stored
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1] = virtual(state)(main(['add', 'myfile']));
+        const hashStr = state1.stdout.trim();
+        // use an empty store so the hash is not found
+        const [finalState, exitCode] = virtual(emptyState)(main(['get', hashStr, 'output']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['get']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainGetInvalidHash: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['get', 'not-a-valid-hash', 'output']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainList: () => {
+        const content = vec8(0x2an);
+        const state = { ...emptyState, root: { myfile: content } };
+        const [state1] = virtual(state)(main(['add', 'myfile']));
+        const [, exitCode] = virtual(state1)(main(['list']));
+        if (exitCode !== 0) {
+            throw ['expected exit 0', exitCode];
+        }
+    },
+    mainNoCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main([]));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
+    mainUnknownCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(['bogus']));
+        if (exitCode !== 1) {
+            throw ['expected exit 1', exitCode];
+        }
+        if (finalState.stderr.length === 0) {
+            throw 'expected error in stderr';
+        }
+    },
     casWrite: () => {
         const store = {
             read: (_key) => pure(undefined),

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

@@ -20,7 +20,7 @@ export declare const images: {
     };
 };
 export declare const bun = "1.3.14";
-export declare const deno = "2.8.1";
+export declare const deno = "2.8.2";
 export declare const playwright = "1.60.0";
 export declare const node: {
     readonly default: "26.3.0";
@@ -28,7 +28,7 @@ export declare const node: {
 };
 export declare const wasmtime = "45.0.0";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260601.1";
+export declare const tsgo = "7.0.0-dev.20260604.1";
 export declare const actions: {
     readonly 'actions/checkout': "v6";
     readonly 'actions/setup-node': "v6";

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

@@ -23,7 +23,7 @@ export const images = {
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.8.1';
+export const deno = '2.8.2';
 // https://www.npmjs.com/package/playwright
 export const playwright = '1.60.0';
 // https://nodejs.org/en/download
@@ -36,7 +36,7 @@ export const wasmtime = '45.0.0';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260601.1';
+export const tsgo = '7.0.0-dev.20260604.1';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.

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

@@ -1,5 +1,5 @@
-import { type Effect } from '../types/effects/module.f.ts';
-import { type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';
 export type Setup = {
     readonly rust: boolean;

package/fs/ci/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
+import { begin, pure } from "../effects/module.f.js";
+import { writeFile } from "../effects/node/module.f.js";
 import { images } from "./config/module.f.js";
 import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";

package/fs/ci/proof.f.js

@@ -3,7 +3,7 @@ import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
-import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));

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

@@ -0,0 +1,37 @@
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nullable } from '../../types/nullable/module.f.ts';
+import { type Sha2 } from '../sha2/module.f.ts';
+/** Genesis-block compact target (`0x1d00ffff`). */
+export declare const genesisNBits = 486604799n;
+/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
+export declare const genesisTarget = 26959535291011309493156476344723991336010898738574164086137773096960n;
+/**
+ * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
+ *
+ * - `exponent = nBits >> 24`
+ * - `mantissa = nBits & 0xffffff`
+ * - `target = mantissa × 2^(8 × (exponent − 3))`
+ *
+ * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
+ * sign bit, overflow, target wider than 256 bits).
+ *
+ * @param nBits - Compact target encoding.
+ * @returns Decoded target, or `null` when **nBits** is invalid.
+ */
+export declare const targetFromNBits: (nBits: bigint) => Nullable<bigint>;
+export type Pow = {
+    /** Hash `data` with the configured `Sha2`; digest as big-endian uint256. */
+    readonly hashInt: (data: Vec) => bigint;
+    /** Whether `hashInt(data) <= targetFromNBits(nBits)`; `false` when **nBits** is invalid. */
+    readonly meets: (nBits: bigint) => (data: Vec) => boolean;
+};
+/**
+ * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
+ *
+ * @param hash - SHA-2 configuration whose digest is compared as uint256.
+ */
+export declare const pow: (hash: Sha2) => Pow;
+/** SHA-256 proof-of-work (`pow(sha256)`). */
+export declare const sha256Pow: Pow;
+/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
+export declare const bitcoinPow: Pow;

package/fs/crypto/pow/module.f.js

@@ -0,0 +1,72 @@
+/**
+ * Bitcoin-style proof-of-work: compact **nBits** target decoding and
+ * hash-vs-target verification using an injected SHA-2 hash.
+ *
+ * @module
+ */
+import { mask } from "../../types/bigint/module.f.js";
+import { uint } from "../../types/bit_vec/module.f.js";
+import { computeSync, sha256 } from "../sha2/module.f.js";
+const nBitsMantissa = mask(24n);
+const mantissaSign = 0x00800000n;
+const mantissaBody = 0x007fffffn;
+const exponentShift = 24n;
+const uint256Mask = mask(256n);
+/** Genesis-block compact target (`0x1d00ffff`). */
+export const genesisNBits = 0x1d00ffffn;
+/** Genesis-block uint256 target decoded from {@link genesisNBits}. */
+export const genesisTarget = 0x00000000ffff0000000000000000000000000000000000000000000000000000n;
+const decodeShift = (exponent) => 8n * (exponent - 3n);
+const compactTarget = (exponent) => (mantissa) => {
+    const shift = decodeShift(exponent);
+    return shift >= 0n ? mantissa << shift : mantissa >> -shift;
+};
+const negativeNBits = (mantissa) => mantissa !== 0n && (mantissa & mantissaSign) !== 0n;
+const overflowNBits = (exponent) => (mantissa) => (target) => target !== 0n &&
+    (exponent > 34n || (mantissa !== 0n && (mantissa & mantissaBody) === 0n));
+/**
+ * Decodes compact **nBits** (32-bit block-header "bits") to a uint256 target:
+ *
+ * - `exponent = nBits >> 24`
+ * - `mantissa = nBits & 0xffffff`
+ * - `target = mantissa × 2^(8 × (exponent − 3))`
+ *
+ * Returns `null` for malformed encodings per Bitcoin `SetCompact` rules (negative
+ * sign bit, overflow, target wider than 256 bits).
+ *
+ * @param nBits - Compact target encoding.
+ * @returns Decoded target, or `null` when **nBits** is invalid.
+ */
+export const targetFromNBits = (nBits) => {
+    const exponent = nBits >> exponentShift;
+    const mantissa = nBits & nBitsMantissa;
+    if (negativeNBits(mantissa)) {
+        return null;
+    }
+    const target = compactTarget(exponent)(mantissa);
+    if (overflowNBits(exponent)(mantissa)(target)) {
+        return null;
+    }
+    if (target > uint256Mask) {
+        return null;
+    }
+    return target;
+};
+/**
+ * Builds PoW helpers for a hash function (typical consumer: {@link sha256}).
+ *
+ * @param hash - SHA-2 configuration whose digest is compared as uint256.
+ */
+export const pow = (hash) => {
+    const c = computeSync(hash);
+    const hashInt = (data) => uint(c([data]));
+    const meets = (nBits) => (data) => {
+        const target = targetFromNBits(nBits);
+        return target !== null && hashInt(data) <= target;
+    };
+    return { hashInt, meets };
+};
+/** SHA-256 proof-of-work (`pow(sha256)`). */
+export const sha256Pow = pow(sha256);
+/** Bitcoin block-header PoW; same as {@link sha256Pow}. */
+export const bitcoinPow = sha256Pow;

package/fs/crypto/pow/proof.f.d.ts

@@ -0,0 +1,33 @@
+export declare const proof: {
+    targetFromNBits: {
+        genesis: () => void;
+        block0HashWithinGenesisTarget: () => void;
+        exponent3: () => void;
+        exponent2: () => void;
+        hardTargetOne: () => void;
+        zero: () => void;
+        negative: () => void;
+        negativeHighMantissa: () => void;
+        overflowExponent: () => void;
+        exceeds256: () => void;
+    };
+    meets: {
+        easy: () => void;
+        hard: () => void;
+        genesisFailsSample: () => void;
+        zeroTargetRejectsSample: () => void;
+        invalidNBits: () => void;
+        hashLeqTarget: () => void;
+    };
+    hashInt: {
+        sha256Sample: () => void;
+        sha256Empty: () => void;
+        sha224: () => void;
+        stable: () => void;
+    };
+    pow: {
+        sha256Pow: () => void;
+        bitcoinPow: () => void;
+        independentInstances: () => void;
+    };
+};

package/fs/crypto/pow/proof.f.js

@@ -0,0 +1,161 @@
+import { utf8 } from "../../text/module.f.js";
+import { empty, uint } from "../../types/bit_vec/module.f.js";
+import { computeSync, sha224, sha256 } from "../sha2/module.f.js";
+import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from "./module.f.js";
+const p256 = sha256Pow;
+const p224 = pow(sha224);
+const sample = utf8('functionalscript pow proof');
+const emptyData = empty;
+/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
+const easyNBits = 0x207fffffn;
+/** Compact encoding for target `1` (`0x03000001`). */
+const hardNBits = 0x03000001n;
+/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
+const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
+/** Bitcoin block #0 header hash as big-endian uint256. */
+const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
+const expectNull = (nBits) => {
+    if (targetFromNBits(nBits) !== null) {
+        throw nBits;
+    }
+};
+export const proof = {
+    targetFromNBits: {
+        genesis: () => {
+            if (targetFromNBits(genesisNBits) !== genesisTarget) {
+                throw 'genesis target';
+            }
+        },
+        block0HashWithinGenesisTarget: () => {
+            if (block0Hash > genesisTarget) {
+                throw 'block0 hash exceeds genesis target';
+            }
+        },
+        exponent3: () => {
+            if (targetFromNBits(0x030000ffn) !== 0xffn) {
+                throw 'exponent 3';
+            }
+        },
+        exponent2: () => {
+            if (targetFromNBits(0x02008000n) !== 0x80n) {
+                throw 'exponent 2';
+            }
+        },
+        hardTargetOne: () => {
+            if (targetFromNBits(hardNBits) !== 1n) {
+                throw 'hard target';
+            }
+        },
+        zero: () => {
+            if (targetFromNBits(0n) !== 0n) {
+                throw 'zero nBits';
+            }
+        },
+        negative: () => {
+            expectNull(0x01800001n);
+        },
+        negativeHighMantissa: () => {
+            expectNull(0x22ffffffn);
+        },
+        overflowExponent: () => {
+            expectNull(0x23000001n);
+        },
+        exceeds256: () => {
+            expectNull(0x227fffffn);
+        },
+    },
+    meets: {
+        easy: () => {
+            if (!p256.meets(easyNBits)(sample)) {
+                throw 'easy nBits should pass';
+            }
+        },
+        hard: () => {
+            if (p256.meets(hardNBits)(sample)) {
+                throw 'target 1 should fail';
+            }
+        },
+        genesisFailsSample: () => {
+            if (p256.meets(genesisNBits)(sample)) {
+                throw 'genesis target too hard for sample';
+            }
+        },
+        zeroTargetRejectsSample: () => {
+            if (p256.meets(0n)(sample)) {
+                throw 'non-zero hash vs zero target';
+            }
+        },
+        invalidNBits: () => {
+            if (p256.meets(0x01800001n)(sample)) {
+                throw 'invalid nBits should not pass';
+            }
+        },
+        hashLeqTarget: () => {
+            const h = p256.hashInt(sample);
+            const target = targetFromNBits(easyNBits);
+            if (target === null) {
+                throw 'easy nBits decode';
+            }
+            if (h > target) {
+                throw 'hash above easy target';
+            }
+            if (!(h <= target)) {
+                throw 'hash <= target';
+            }
+        },
+    },
+    hashInt: {
+        sha256Sample: () => {
+            const digest = computeSync(sha256)([sample]);
+            if (p256.hashInt(sample) !== uint(digest)) {
+                throw 'sha256 sample';
+            }
+        },
+        sha256Empty: () => {
+            if (p256.hashInt(emptyData) !== sha256EmptyHash) {
+                throw 'sha256 empty constant';
+            }
+            const digest = computeSync(sha256)([emptyData]);
+            if (p256.hashInt(emptyData) !== uint(digest)) {
+                throw 'sha256 empty';
+            }
+        },
+        sha224: () => {
+            const digest = computeSync(sha224)([sample]);
+            if (p224.hashInt(sample) !== uint(digest)) {
+                throw 'sha224';
+            }
+        },
+        stable: () => {
+            if (p256.hashInt(sample) !== p256.hashInt(sample)) {
+                throw 'stable';
+            }
+        },
+    },
+    pow: {
+        sha256Pow: () => {
+            const built = pow(sha256);
+            if (sha256Pow.hashInt(sample) !== built.hashInt(sample)) {
+                throw 'hashInt';
+            }
+            if (sha256Pow.meets(easyNBits)(sample) !== built.meets(easyNBits)(sample)) {
+                throw 'meets';
+            }
+        },
+        bitcoinPow: () => {
+            if (bitcoinPow.hashInt(sample) !== sha256Pow.hashInt(sample)) {
+                throw 'bitcoinPow';
+            }
+        },
+        independentInstances: () => {
+            const a = pow(sha256);
+            const b = pow(sha256);
+            if (a.hashInt(sample) !== b.hashInt(sample)) {
+                throw 'hashInt';
+            }
+            if (a.meets(easyNBits)(sample) !== b.meets(easyNBits)(sample)) {
+                throw 'meets';
+            }
+        },
+    },
+};

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

@@ -1,11 +1,5 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-import type { Io } from '../io/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';
+import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
@@ -13,7 +7,6 @@ export type Module = {
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
-export declare const env: (io: Io) => (v: string) => string | undefined;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/fs/dev/module.f.js

@@ -1,19 +1,18 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
 import { updateVersion } from "./version/module.f.js";
-import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { all, both, import_, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../effects/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
-import { relativize } from "../path/module.f.js";
-export const env = ({ process: { env } }) => a => {
-    const r = Object.getOwnPropertyDescriptor(env, a);
-    return r === undefined ? undefined :
-        typeof r.get === 'function' ? r.get() :
-            r.value;
-};
+import { relativize, toPosix } from "../path/module.f.js";
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -74,7 +73,7 @@ const { fromEntries } = Object;
  */
 export const loadModuleMap = (env) => {
     const initCwd = env['INIT_CWD'];
-    const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
+    const s = initCwd === undefined ? '.' : toPosix(initCwd);
     const prefix = s === '.' ? '' : s;
     // TODO: there are multiple `all` effects here,
     //       we should consider optimize them by ALIQ technique or something similar.
@@ -92,7 +91,9 @@ const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = updateVersion
     .step(() => readFile(denoJson))
     .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'))
+const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') ||
+    v.endsWith('/module.ts') ||
+    v.endsWith('/all.test.ts'))
     .step(files => {
     const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
     return pure(Object.fromEntries(exportsA));

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

@@ -9,5 +9,4 @@ export declare const proof: {
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
     throw: () => void;
-    env: () => void;
 };

package/fs/dev/proof.f.js

@@ -1,5 +1,4 @@
 import { todo } from "../asserts/module.f.js";
-import { env } from "./module.f.js";
 export const proof = {
     shouldPass: () => ({
         then: () => undefined
@@ -57,24 +56,4 @@ export const proof = {
     throw: () => {
         todo();
     },
-    env: () => {
-        const mockIo = { process: { env: { MY_VAR: 'hello' } } };
-        // missing key → undefined
-        const r1 = env(mockIo)('MISSING');
-        if (r1 !== undefined) {
-            throw r1;
-        }
-        // regular value property → returns value
-        const r2 = env(mockIo)('MY_VAR');
-        if (r2 !== 'hello') {
-            throw r2;
-        }
-        // getter property → calls get()
-        const envWithGetter = Object.defineProperty({}, 'GETTER_VAR', { get: () => 'from-getter', enumerable: true, configurable: true });
-        const mockIo2 = { process: { env: envWithGetter } };
-        const r3 = env(mockIo2)('GETTER_VAR');
-        if (r3 !== 'from-getter') {
-            throw r3;
-        }
-    }
 };

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

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

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

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { begin, pure } from "../../types/effects/module.f.js";
-import { all, readFile, writeFile } from "../../types/effects/node/module.f.js";
+import { begin, pure } from "../../effects/module.f.js";
+import { all, readFile, writeFile } from "../../effects/node/module.f.js";
 import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;