functionalscript 0.19.0 → 0.20.0

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

@@ -0,0 +1,5 @@
+export declare const proof: {
+    normalizeTest: (() => void)[];
+    concatTest: (() => void)[];
+    relativizeTest: (() => void)[];
+};

package/fs/path/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { concat, normalize, relativize } from "./module.f.js";
-export const normalizeTest = [
+const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
         if (norm !== "dir/file.json") {
@@ -25,7 +25,7 @@ export const normalizeTest = [
         }
     },
 ];
-export const concatTest = [
+const concatTest = [
     () => {
         const c = concat("a")("b");
         if (c !== "a/b") {
@@ -45,7 +45,7 @@ export const concatTest = [
         }
     },
 ];
-export const relativizeTest = [
+const relativizeTest = [
     () => {
         const r = relativize('/repo', '/repo/fs/a.ts');
         if (r !== './fs/a.ts') {
@@ -65,3 +65,4 @@ export const relativizeTest = [
         }
     },
 ];
+export const proof = { normalizeTest, concatTest, relativizeTest };

package/fs/sul/id/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     inline_00_00: () => void;
     inline_00_01: () => void;
     inline_01_00: () => void;
@@ -18,4 +18,3 @@ declare const _default: {
     hash_merge_b_sensitivity: () => void;
     hash_merge_shift: () => void;
 };
-export default _default;

package/fs/sul/id/{test.f.js → proof.f.js}

@@ -15,7 +15,7 @@ const hFE = hashId(mask(0xffn) - 1n);
 assertEq(asBase(level3Id(0n)), 0n);
 assertEq(asBase(hashId(0n)), 1n << 0xffn);
 assertEq(asBase(hFF), mask(0x100n));
-export default {
+export const proof = {
     // Two level-3 literals whose combined bit vectors fit inline (≤ 253 bits)
     inline_00_00: () => assertEq(compress(level3Id(0x00n), level3Id(0x00n)), rawId(vec(16n)(0x0000n))),
     inline_00_01: () => assertEq(compress(level3Id(0x00n), level3Id(0x01n)), rawId(vec(16n)(0x0001n))),

package/fs/sul/level/hash/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     min_equal: () => void;
     min_greater: () => void;
     intermediate_undefined: () => void;
@@ -11,4 +11,3 @@ declare const _default: {
     isSymbol_terminal_only: () => void;
     isSymbol_min_word: () => void;
 };
-export default _default;

package/fs/sul/level/hash/{test.f.js → proof.f.js}

@@ -24,7 +24,7 @@ const verifyStorage = (storage) => {
 };
 const s0 = level3Id(0n);
 const s1 = level3Id(1n);
-export default {
+export const proof = {
     // Minimum word [s0, t] with t == s0
     min_equal: () => {
         const [out, storage] = runWord([s0, s0]);

package/fs/sul/level/literal/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     x2: () => void;
     x5: () => void;
     x81: () => void;
@@ -9,4 +9,3 @@ declare const _default: {
     };
     pipeline: () => void;
 };
-export default _default;

package/fs/sul/level/literal/{test.f.js → proof.f.js}

@@ -46,7 +46,7 @@ const w = (symbol, expected) => {
     if (out !== symbol)
         throw out;
 };
-export default {
+export const proof = {
     x2: () => {
         const { c, n } = tests(0n);
         c(-1n, 0n);

package/fs/sul/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     deterministic: () => void;
     distinct: () => void;
     order_matters: () => void;
@@ -7,4 +7,3 @@ declare const _default: {
     compress_correct: () => void;
     isSymbol_terminal_only: () => void;
 };
-export default _default;

package/fs/sul/{test.f.js → proof.f.js}

@@ -13,7 +13,7 @@ const run = (bits) => {
 };
 const id = (bits) => run(bits)[0];
 const zeros = (n) => new Array(n).fill(0n);
-export default {
+export const proof = {
     deterministic: () => {
         assertEq(id(zeros(16)), id(zeros(16)));
     },

package/fs/text/ascii/proof.f.d.ts

@@ -0,0 +1,3 @@
+export declare const proof: {
+    range: () => void;
+};

package/fs/text/ascii/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { range } from "./module.f.js";
 import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     range: () => {
         const r = stringify(range("A"));
         if (r !== '[65,65]') {

package/fs/text/code_point/module.f.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
+ * error-tag mask used to flag invalid sequences, and a streaming `decoder`
+ * factory that wraps a per-unit step and an end-of-input step into a single
+ * `List`-to-`List` conversion.
+ *
+ * @module
+ */
+import { type List } from '../../types/list/module.f.ts';
+import type { StateScan } from '../../types/function/operator/module.f.ts';
+/**
+ * Error mask used to tag invalid code points or encoding errors. A decoded
+ * value with this bit set represents a malformed unit rather than a valid
+ * code point.
+ */
+export declare const errorMask = 2147483648;
+/**
+ * Builds a streaming decoder from the two direction-specific steps.
+ *
+ * Decoding starts from the empty (`null`) state. The input is processed unit by
+ * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
+ * flush any leftover decoding state.
+ *
+ * @param byteOp - The per-unit decoding step.
+ * @param eofOp - The end-of-input step that flushes the remaining state.
+ * @returns A function converting a list of code units into a list of code points.
+ */
+export declare const decoder: <Unit, S, Cp>(byteOp: StateScan<Unit, S | null, List<Cp>>, eofOp: (state: S | null) => readonly [List<Cp>, S | null]) => (input: List<Unit>) => List<Cp>;

package/fs/text/code_point/module.f.js

@@ -0,0 +1,31 @@
+/**
+ * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
+ * error-tag mask used to flag invalid sequences, and a streaming `decoder`
+ * factory that wraps a per-unit step and an end-of-input step into a single
+ * `List`-to-`List` conversion.
+ *
+ * @module
+ */
+import { flat, stateScan } from "../../types/list/module.f.js";
+/**
+ * Error mask used to tag invalid code points or encoding errors. A decoded
+ * value with this bit set represents a malformed unit rather than a valid
+ * code point.
+ */
+export const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+/**
+ * Builds a streaming decoder from the two direction-specific steps.
+ *
+ * Decoding starts from the empty (`null`) state. The input is processed unit by
+ * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
+ * flush any leftover decoding state.
+ *
+ * @param byteOp - The per-unit decoding step.
+ * @param eofOp - The end-of-input step that flushes the remaining state.
+ * @returns A function converting a list of code units into a list of code points.
+ */
+export const decoder = (byteOp, eofOp) => {
+    const op = (input, state) => input === null ? eofOp(state) : byteOp(input, state);
+    const run = stateScan(op)(null);
+    return input => flat(run(flat([input, [null]])));
+};

package/fs/text/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,4 @@
-declare const _default: {
+export declare const proof: {
     block: () => void;
     encoding: () => void;
 };
-export default _default;

package/fs/text/{test.f.js → proof.f.js}

@@ -1,6 +1,6 @@
 import { flat, utf8, utf8ToString } from "./module.f.js";
 import { join } from "../types/string/module.f.js";
-export default {
+export const proof = {
     block: () => {
         const text = [
             'a',

package/fs/text/sgr/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: (() => void)[];

package/fs/text/sgr/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { fgRed, createConsoleText, backspace } from "./module.f.js";
-export default [
+export const proof = [
     () => {
         if (fgRed !== '\x1b[31m') {
             throw new Error('Test failed: sgr(0)');

package/fs/text/utf16/module.f.js

@@ -5,10 +5,11 @@
  *
  * @module
  */
-import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/module.f.js";
+import { map, reduce, flatMap, empty, } from "../../types/list/module.f.js";
 import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";
 import { fn } from "../../types/function/module.f.js";
+import { decoder, errorMask } from "../code_point/module.f.js";
 /**
  * Ranges of code points for the lower (Low) and higher (High) parts of the BMP (Basic Multilingual Plane) plane.
  */
@@ -29,10 +30,6 @@ const isHighSurrogate = contains([0xd800, 0xdbff]);
  * Range: 0xDC00 – 0xDFFF.
  */
 const isLowSurrogate = contains([0xdc00, 0xdfff]);
-/**
- * Mask of mistakes. Used to indicate invalid code points or coding errors
- */
-const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
 /**
  * Checks whether the code point belongs to the additional (Supplementary) plane of Unicode.
  * Additional planes include code points from 0x010000 to 0x10FFFF.
@@ -219,53 +216,6 @@ const utf16ByteToCodePointOp = (word, state) => {
  * ```
  */
 const utf16EofToCodePointOp = (state) => [state === null ? empty : [state | errorMask], null];
-/**
- * A stateful scan operation that processes UTF-16 input (word or EOF).
- * This function determines whether to handle a UTF-16 word or an end-of-file (EOF)
- * signal during decoding:
- * 1. If the input is `null` (EOF), it calls `utf16EofToCodePointOp` to process
- *    any remaining state.
- * 2. If the input is a valid UTF-16 word, it calls `utf16ByteToCodePointOp` to
- *    process the word and update the state accordingly.
- * @param state - The current state in the UTF-16 decoding process:
- *   - `null`: No pending surrogate.
- *   - A high surrogate waiting for a low surrogate.
- * @param input - The current UTF-16 word to process, or `null` to signal EOF.
- * @returns A tuple:
- *   - A list of decoded code points (if any).
- *   - The updated decoding state.
- *
- * @example
- *
- * ```ts
- * // Example 1: Process a valid UTF-16 word
- * const input1 = 0x0041 // 'A' (BMP code point)
- * const result1 = utf16ByteOrEofToCodePointOp(input1, null)
- * console.log(result1) // [[0x0041], null]
- * // Example 2: Process a high surrogate, followed by EOF
- * const input2 = 0xD83D // High surrogate
- * const result2 = utf16ByteOrEofToCodePointOp(input2, null)
- * console.log(result2) // [[], 0xD83D] (waiting for a low surrogate)
- * const eofResult = utf16ByteOrEofToCodePointOp(null, 0xD83D)
- * console.log(eofResult) // [[0xD83D | errorMask], null] (unpaired high surrogate)
- * // Example 3: Handle EOF with no pending state
- * const eofResult2 = utf16ByteOrEofToCodePointOp(null, null)
- * ```
- */
-const utf16ByteOrEofToCodePointOp = (input, state) => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(input, state);
-/**
- * Represents an end-of-file (EOF) indicator in a list of UTF-16 code units.
- *
- * This list contains a single element, `null`, which is used to signal the end
- * of input during UTF-16 decoding operations.
- * @example
- *
- * ```ts
- * const input = [...utf16Data, ...eofList]
- * // Ensures the EOF is handled during processing.
- * ```
- */
-const eofList = [null];
 /**
  * Converts a list of UTF-16 code units to a list of Unicode code points (CodePoint).
  * This function processes each UTF-16 code unit, decoding them into their corresponding Unicode code points.
@@ -281,7 +231,7 @@ const eofList = [null];
  * const codePoints = toCodePointList(utf16List)
  * ```
  */
-export const toCodePointList = (input) => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const toCodePointList = decoder(utf16ByteToCodePointOp, utf16EofToCodePointOp);
 /**
  * Converts a string to a list of UTF-16 code units (U16).
  *

package/fs/text/utf16/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     toCodePointList: (() => void)[];
     fromCodePointList: (() => void)[];
     string: (() => void)[];
@@ -7,4 +7,3 @@ declare const _default: {
     stringToCodePointList: (() => void)[];
     codePointListToString: (() => void)[];
 };
-export default _default;

package/fs/text/utf16/{test.f.js → proof.f.js}

@@ -3,7 +3,7 @@ import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
 const stringify = (a) => jsonStringify(sort)(a);
-export default {
+export const proof = {
     toCodePointList: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 65536])));

package/fs/text/utf8/module.f.js

@@ -3,11 +3,8 @@
  *
  * @module
  */
-import { flat, flatMap, stateScan } from "../../types/list/module.f.js";
-/**
- * Error mask constant used to represent invalid code points or encoding errors in UTF-8.
- */
-const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+import { flatMap } from "../../types/list/module.f.js";
+import { decoder, errorMask } from "../code_point/module.f.js";
 /**
  * Converts a Unicode code point to a sequence of UTF-8 bytes.
  * @param input The Unicode code point to be converted. Valid range:
@@ -175,29 +172,10 @@ const utf8EofToCodePointOp = (state) => [
     state === null ? null : [utf8StateToError(state)],
     null,
 ];
-/**
- * Combines UTF-8 byte and EOF handling into a single decoding operation.
- *
- * @param state - The current UTF-8 decoding state.
- * @param input - The next byte or EOF indicator.
- * @returns A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The updated UTF-8 state.
- */
-const utf8ByteOrEofToCodePointOp = (input, state) => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(input, state);
-/**
- * A constant representing the end-of-file (EOF) marker for UTF-8 decoding.
- *
- * @remarks
- * This is used as a sentinel value in decoding operations to signify the
- * termination of input. The list contains a single `null` value, which
- * represents the EOF condition.
- */
-const eofList = [null];
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.
  *
  * @param input - A list of UTF-8 bytes.
  * @returns A list of Unicode code points or error codes.
  */
-export const toCodePointList = (input) => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePointOp);

package/fs/text/utf8/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     toCodePoint: (() => void)[];
     fromCodePointList: (() => void)[];
     toFrom: (() => void)[];
 };
-export default _default;

package/fs/text/utf8/{test.f.js → proof.f.js}

@@ -3,7 +3,7 @@ import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     toCodePoint: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 256])));

package/fs/types/array/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     stringify: () => void;
     at: (() => void)[];
     first: (() => void)[];
@@ -9,4 +9,3 @@ declare const _default: {
     splitLast: (() => void)[];
     empty: () => void;
 };
-export default _default;

package/fs/types/array/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./mod
 import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     stringify: () => {
         const result = stringify([1, 20, 300]);
         if (result !== '[1,20,300]') {

package/fs/types/bigfloat/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     decToBin: (() => void)[];
     roundingPositive: (() => void)[];
     roundingNegative: (() => void)[];
 };
-export default _default;

package/fs/types/bigfloat/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { decToBin } from "./module.f.js";
-export default {
+export const proof = {
     decToBin: [
         () => {
             const result = decToBin([0n, 0]);

package/fs/types/bigint/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,5 @@
 export declare const clz32Log2: (v: bigint) => bigint;
-declare const _default: {
+export declare const proof: {
     example: () => void;
     benchmark: () => {
         big: {
@@ -30,4 +30,3 @@ declare const _default: {
     divUp: () => void;
     roundUp: () => void;
 };
-export default _default;

package/fs/types/bigint/{test.f.js → proof.f.js}

@@ -148,7 +148,7 @@ const benchmarkSmall = f => () => {
         --e;
     } while (c !== 0n);
 };
-export default {
+export const proof = {
     example: () => {
         const total = sum([1n, 2n, 3n]); // 6n
         if (total !== 6n) {

package/fs/types/bit_vec/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     examples: {
         vec: () => void;
         uint: () => void;
@@ -54,4 +54,3 @@ declare const _default: {
         msb_unaligned: () => void;
     };
 };
-export default _default;

package/fs/types/bit_vec/{test.f.js → proof.f.js}

@@ -80,7 +80,7 @@ const concat = (e) => (r) => () => {
         throw ab;
     }
 };
-export default {
+export const proof = {
     examples: {
         vec: () => {
             const vec4 = vec(4n);

package/fs/types/btree/find/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: () => void;

package/fs/types/btree/find/{test.f.js → proof.f.js}

@@ -148,4 +148,4 @@ const test = () => {
         }
     }
 };
-export default test;
+export const proof = test;

package/fs/types/btree/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     valueTest1: () => void;
     valuesTest2: () => void;
     findTrue: () => void;
     find: () => void;
     test: () => void;
 };
-export default _default;

package/fs/types/btree/{test.f.js → proof.f.js}

@@ -62,7 +62,7 @@ const test = () => {
         }
     }
 };
-export default {
+export const proof = {
     valueTest1,
     valuesTest2,
     findTrue,

package/fs/types/btree/remove/proof.f.d.ts

@@ -0,0 +1,4 @@
+export declare const proof: {
+    test: () => void;
+    test2: () => void;
+};

package/fs/types/btree/remove/{test.f.js → proof.f.js}

@@ -625,7 +625,7 @@ const test2 = () => {
         }
     }
 };
-export default {
+export const proof = {
     test,
     test2,
 };

package/fs/types/btree/set/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: (() => void)[];

package/fs/types/btree/set/{test.f.js → proof.f.js}

@@ -354,4 +354,4 @@ const test = [
         }
     }
 ];
-export default test;
+export const proof = test;

package/fs/types/btree/types/module.f.d.ts

@@ -12,4 +12,12 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
+/**
+ * Demotes a single-child branch root to its only child.
+ *
+ * After an insert or remove the root may temporarily hold exactly one child
+ * (a `Branch1`). In that case the tree is one level taller than necessary;
+ * returning the child directly restores the correct height. If the root has
+ * more than one child it is returned unchanged.
+ */
 export declare const collapseRoot: <T>(b: Branch1<T> | Branch3<T> | Branch5<T>) => TNode<T>;

package/fs/types/btree/types/module.f.js

@@ -1 +1,9 @@
+/**
+ * Demotes a single-child branch root to its only child.
+ *
+ * After an insert or remove the root may temporarily hold exactly one child
+ * (a `Branch1`). In that case the tree is one level taller than necessary;
+ * returning the child directly restores the correct height. If the root has
+ * more than one child it is returned unchanged.
+ */
 export const collapseRoot = b => b.length === 1 ? b[0] : b;

package/fs/types/byte_set/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     has: (() => void)[];
     setRange: () => void;
     unset: (() => void)[];
@@ -9,4 +9,3 @@ declare const _default: {
     };
     toRangeMap: (() => void)[];
 };
-export default _default;

package/fs/types/byte_set/{test.f.js → proof.f.js}

@@ -3,7 +3,7 @@ import { every, countdown, map, toArray } from "../list/module.f.js";
 import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     has: [
         () => {
             if (has(0)(empty)) {

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

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import { type List } from '../list/module.f.ts';
 export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;
@@ -20,6 +21,22 @@ export type Param<O extends Operation> = F<O>[0];
 export type Return<O extends Operation> = F<O>[1];
 export declare const do_: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
 export declare const begin: Effect<never, void>;
+/**
+ * Sequentially threads a state value through an effect for each item in `items`.
+ *
+ * Given `f: item => state => Effect<O, state>`, `init: S`, and `items: [x₀, x₁, …]`,
+ * builds `f(x₀)(init).step(f(x₁)).step(f(x₂)).…` and yields a single
+ * `Effect<O, S>` that produces the final state.
+ *
+ * Sequential — each step depends on the previous state. Compare to `all`,
+ * which fans out independent effects.
+ */
+export declare const foldStep: <O extends Operation, T, S>(f: (item: T) => (state: S) => Effect<O, S>) => (init: S) => (items: List<T>) => Effect<O, S>;
+/**
+ * Sequentially runs `f(item)` for each item in `items`, discarding intermediate
+ * results. The `void` accumulator sibling of `foldStep`.
+ */
+export declare const forEachStep: <O extends Operation, T>(f: (item: T) => Effect<O, void>) => (items: List<T>) => Effect<O, void>;
 export type ToAsyncOperationMap<O extends Operation> = {
     readonly [K in O[0]]: (...payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
 };

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

@@ -3,6 +3,7 @@
  *
  * @module
  */
+import { fold } from "../list/module.f.js";
 export const pure = (v) => ({
     value: [v],
     step: f => f(v)
@@ -13,3 +14,19 @@ export const doFull = (cmd, param, cont) => ({
 });
 export const do_ = (cmd) => (...param) => doFull(cmd, param, pure);
 export const begin = pure(undefined);
+/**
+ * Sequentially threads a state value through an effect for each item in `items`.
+ *
+ * Given `f: item => state => Effect<O, state>`, `init: S`, and `items: [x₀, x₁, …]`,
+ * builds `f(x₀)(init).step(f(x₁)).step(f(x₂)).…` and yields a single
+ * `Effect<O, S>` that produces the final state.
+ *
+ * Sequential — each step depends on the previous state. Compare to `all`,
+ * which fans out independent effects.
+ */
+export const foldStep = (f) => (init) => (items) => fold(item => acc => acc.step(f(item)))(pure(init))(items);
+/**
+ * Sequentially runs `f(item)` for each item in `items`, discarding intermediate
+ * results. The `void` accumulator sibling of `foldStep`.
+ */
+export const forEachStep = (f) => (items) => foldStep((item) => () => f(item))(undefined)(items);