functionalscript 0.44.0 → 0.45.0

package/fjs/types/bit_vec/module.f.mjs

@@ -20,34 +20,23 @@
  * ```
  *
  * @module
+ *
+ * @import { Reduce as BigintReduce } from '../bigint/types.ts'
+ * @import { Fold } from '../function/operator/types.ts'
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { Absorbing } from '../../common/monoid/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { BitOrder, PopFront, Reduce, Unpacked, Vec, _NormOp, _UnpackConcat, } from './types.ts'
  */
 
 import { bitLength, divUp, mask, maxLength, xor } from '../bigint/module.f.mjs'
-/** @import { Reduce as BigintReduce } from '../bigint/types.ts' */
-
-import { flip, identity } from '../function/module.f.mjs'
-
-/** @import { Fold } from '../function/operator/types.ts' */
-
-import { map, tryFold } from '../list/module.f.mjs'
-/** @import { Accumulator, List, Thunk } from '../list/types.ts' */
-
+import { compose, flip, identity } from '../function/module.f.mjs'
+import { map } from '../list/module.f.mjs'
 import { asBase, asNominal } from '../nominal/module.f.mjs'
-
-import { repeat as mRepeat } from '../../common/monoid/module.f.mjs'
-
+import { foldAbsorbing, repeat as mRepeat } from '../../common/monoid/module.f.mjs'
 import { cmp, max, min } from '../function/compare/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
-
-import { mapUnwrap } from '../nullable/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
-
-/**
- * @import {
- *  BitOrder, PopFront, Reduce, Unpacked, Vec,
- *  _NormOp, _UnpackConcat,
- * } from './types.ts'
- */
+import { map as nullableMap, mapUnwrap } from '../nullable/module.f.mjs'
 
 /**
  * Maximum length of a bit vector in bits (1_048_576 = 0x10_0000).
@@ -195,55 +184,53 @@ const op = norm => op => ap => bp => {
 const unpackEmpty = /** @type {const} */{ length: 0n, uint: 0n }
 
 /**
- * @typedef {{
- *  readonly len: bigint
- *  readonly stack: readonly Unpacked[]
- * }} _ListToVecState
+ * Concatenation as a monoid over `Nullable<Unpacked>`, where `null` means "the
+ * concatenation is longer than `maxLength`" and is an **absorbing** element:
+ * combining it with anything is `null` again. The identity is the empty vector.
+ *
+ * This is a lawful monoid, so `monoid.fold` may re-associate it freely. Length
+ * is additive and non-negative, so any partial combine is at most the total: a
+ * partial can only overflow when the total does, and the top-level combine
+ * always sees the full total. The result is therefore `null` **iff** the total
+ * length exceeds `maxLength`, whatever the grouping.
+ *
+ * The cap is checked on the operands' lengths rather than on the concatenated
+ * result because the result is what must not be built: `maxLength` is the
+ * smallest `bigint` size supported across FunctionalScript's runtimes. The two
+ * lengths are exact and additive — this is the length, not an estimate of it
+ * (AGENTS.md §5.6).
+ *
+ * Being absorbing is also what keeps the fold's walk bounded: `foldAbsorbing`
+ * stops at the first merge that overflows instead of reading the rest of a list
+ * whose answer is already `null`. `List<T>` includes `Thunk<T>`, so that is the
+ * difference between answering and never returning on an unbounded lazy list —
+ * and at `maxLength` = 128 KiB, overflow is an ordinary outcome for a stream,
+ * not an exotic one. Since a single vector is never `null`, only a merge can
+ * reach the absorbing element, so the stop lags the element that crossed the cap
+ * by at most one doubling of the run size (measured: 65 536 elements read for a
+ * cap crossed at 32 769, and 4 for a cap crossed at 3).
+ *
+ * @type {(unpackConcat: _UnpackConcat) => Absorbing<Nullable<Unpacked>>}
  */
-
-/** @typedef {Accumulator<Unpacked, _ListToVecState, Vec>} _ListToVecOp */
-
-/** @type {(unpackConcat: _UnpackConcat) => _ListToVecOp} */
-const listToVecOp = unpackConcat => ({
-    init: { len: 0n, stack: [] },
-    update: (v, {len, stack}) => {
-        len += v.length
-        if (len > maxLength) { return null }
-        let i = 0
-        while (true) {
-            if (stack.length <= i) {
-                stack = [...stack, v]
-                break
-            }
-            const old = stack[i]
-            if (old.length === 0n) {
-                stack = stack.toSpliced(i, 1, v)
-                break
-            }
-            stack = stack.toSpliced(i, 1, unpackEmpty)
-            v = unpackConcat(old)(v)
-            i++
-        }
-        return { len, stack }
+const tryUnpackConcat = unpackConcat => ({
+    monoid: {
+        identity: unpackEmpty,
+        operation: a => b =>
+            a === null || b === null || a.length + b.length > maxLength
+                ? null
+                : unpackConcat(a)(b)
     },
-    end: ({stack}) => pack(stack.reduce((p, c) => unpackConcat(c)(p), unpackEmpty))
+    absorbing: null,
 })
 
 /**
- * Concatenates a list of unpacked vectors using a binary-counter accumulator,
- * giving O(n log n) total `bigint` shifting work instead of the O(n²) of a
- * naive left fold.
+ * Concatenates a list of unpacked vectors, or `null` if the result would be
+ * longer than `maxLength`.
  *
- * Slot `i` of `result` holds an already-combined run of the most recent
- * `2 ** i` elements. Each arriving element "carries" upward, merging only with
- * runs of comparable size — exactly like incrementing a binary number — so
- * every merge joins two runs of similar length. Left-to-right element order is
- * preserved: `unpackConcat(old)(cur)` keeps the earlier run on the left, and
- * the final reduce prepends higher (earlier) slots in front of accumulated
- * later runs. An empty list yields `unpackEmpty`.
- *
- * Returns `null` as soon as the accumulated length exceeds `maxLength`, which
- * `tryFold` propagates by abandoning the rest of the list.
+ * `monoid.foldAbsorbing` reduces as a balanced binary tree, so each merge joins
+ * two runs of comparable size — O(n log n) total `bigint` shifting work instead
+ * of the O(n²) a left fold would spend growing one accumulator against small
+ * operands — and stops reading at the first overflow.
  *
  * This is the bit-vector analogue of a builder that accumulates appended pieces
  * and materializes the combined result on demand, such as `StringBuilder`
@@ -251,7 +238,8 @@ const listToVecOp = unpackConcat => ({
  *
  * @param {_UnpackConcat} unpackConcat
  */
-const unpackListToVec = unpackConcat => tryFold(listToVecOp(unpackConcat))
+const unpackListToVec = unpackConcat =>
+    compose(foldAbsorbing(tryUnpackConcat(unpackConcat)))(nullableMap(pack))
 
 /** @type {(base: _Base) => BitOrder} */
 const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
@@ -284,9 +272,9 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
         const bu = unpack(b)
         return pack(unpackConcat(au)(bu))
     }
+    const unpackedListToVec = unpackListToVec(unpackConcat)
     /** @param {List<Vec>} list */
-    const tryListToVec = list =>
-        unpackListToVec(unpackConcat)(map(unpack)(list))
+    const tryListToVec = list => unpackedListToVec(map(unpack)(list))
     return {
         front,
         removeFront,
@@ -378,9 +366,11 @@ export const msb = bo({
  *
  * @type {(_: BitOrder) => (list: List<number>) => Nullable<Vec>}
  */
-export const tryU8ListToVec = ({ unpackConcat }) => list =>
-    unpackListToVec(unpackConcat)(
+export const tryU8ListToVec = ({ unpackConcat }) => {
+    const unpackedListToVec = unpackListToVec(unpackConcat)
+    return list => unpackedListToVec(
         map(/** @type {(_: number) => Unpacked} */b => ({ length: 8n, uint: BigInt(b) }))(list))
+}
 
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.

package/fjs/types/bit_vec/proof.f.d.mts

@@ -1,3 +1,8 @@
+/**
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Vec, BitOrder } from './types.ts'
+ * @import { List } from '../list/types.ts'
+ */
 export declare const proof: {
     fromSentinel: () => void;
     examples: {
@@ -47,6 +52,7 @@ export declare const proof: {
     };
     u8ListToVec: () => () => void;
     tryListToVecOverflow: () => void;
+    tryListToVecUnbounded: () => void;
     listToVecOverflow: {
         throw: () => void;
     };

package/fjs/types/bit_vec/proof.f.mjs

@@ -1,10 +1,13 @@
+/**
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Vec, BitOrder } from './types.ts'
+ * @import { List } from '../list/types.ts'
+ */
+
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { mask } from '../bigint/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { asBase, asNominal } from '../nominal/module.f.mjs'
-/** @import { Vec, BitOrder } from './types.ts' */
 import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from './module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { repeat as listRepeat, toArray } from '../list/module.f.mjs'
 
 /** @type {(a: bigint) => Vec} */
@@ -421,6 +424,29 @@ export const proof = {
         const list = [vec(maxLength)(1n), vec(1n)(1n)]
         assertEq(lsb.tryListToVec(list), null)
         assertEq(msb.tryListToVec(list), null)
+        // Overflow is an absorbing element, so it survives every later
+        // combination: here the failed pair ends up on the left of the last
+        // one, and on the right in the two-element case above.
+        /** @type {List<Vec>} */
+        const longer = [vec(maxLength)(1n), vec(1n)(1n), vec(1n)(1n)]
+        assertEq(lsb.tryListToVec(longer), null)
+        assertEq(msb.tryListToVec(longer), null)
+    },
+    tryListToVecUnbounded: () => {
+        // `List` includes `Thunk`, so an unbounded lazy list is a legal input —
+        // and at 128 KiB, `maxLength` is an ordinary amount for a stream to
+        // exceed. Overflow being absorbing is what lets the fold answer instead
+        // of reading forever: each element here is half of `maxLength`, so the
+        // total crosses the cap at the third and the merge that sees it happens
+        // at the fourth. The rest of the list asserts it is never read.
+        const half = vec(maxLength / 2n)(1n)
+        /** @type {(n: number) => List<Vec>} */
+        const from = n => () => {
+            assert(n <= 8)
+            return { first: half, tail: from(n + 1) }
+        }
+        assertEq(lsb.tryListToVec(from(1)), null)
+        assertEq(msb.tryListToVec(from(1)), null)
     },
     listToVecOverflow: {
         // Same oversized input, but through the throwing `listToVec` wrapper.

package/fjs/types/btree/find/module.f.d.mts

@@ -2,8 +2,12 @@
  * Lookup operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { TNode } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { KeyOf } from '../../array/types.ts'
+ * @import { First, Path, PathItem, Result } from './types.ts'
  */
-/** @import { TNode } from '../types/types.ts' */
 import type { TNode } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 import type { First, Result } from './types.ts';

package/fjs/types/btree/find/module.f.mjs

@@ -2,14 +2,14 @@
  * Lookup operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { TNode } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { KeyOf } from '../../array/types.ts'
+ * @import { First, Path, PathItem, Result } from './types.ts'
  */
-/** @import { TNode } from '../types/types.ts' */
 
 import { index3, index5 } from '../../function/compare/module.f.mjs'
-/** @import { Compare } from '../../function/compare/types.ts' */
-
-/** @import { KeyOf } from '../../array/types.ts' */
-/** @import { First, Path, PathItem, Result } from './types.ts' */
 
 /** @type {<T>(item: PathItem<T>) => TNode<T>} */
 const child = item => {

package/fjs/types/btree/find/proof.f.d.mts

@@ -1,4 +1,8 @@
-/** @import { Unknown } from '../../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../../media/json/types.ts'
+ * @import { Result } from './types.ts'
+ * @import { TNode } from '../types/types.ts'
+ */
 declare const test: () => void;
 export declare const proof: typeof test;
 export {};

package/fjs/types/btree/find/proof.f.mjs

@@ -1,11 +1,13 @@
-/** @import { Unknown } from '../../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../../media/json/types.ts'
+ * @import { Result } from './types.ts'
+ * @import { TNode } from '../types/types.ts'
+ */
 
-/** @import { Result } from './types.ts' */
 import { find as btreeFind } from './module.f.mjs'
 import { map, toArray } from '../../list/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'
 import { sort } from '../../object/module.f.mjs'
-/** @import { TNode } from '../types/types.ts' */
 import { cmp } from '../../string/module.f.mjs'
 import { set as setSet } from '../set/module.f.mjs'
 import { assertEq } from '../../../asserts/module.f.mjs'

package/fjs/types/btree/module.f.d.mts

@@ -2,6 +2,9 @@
  * Core persistent B-tree construction and traversal helpers.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { TNode, Tree } from './types/types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Tree } from './types/types.ts';

package/fjs/types/btree/module.f.mjs

@@ -2,12 +2,13 @@
  * Core persistent B-tree construction and traversal helpers.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { TNode, Tree } from './types/types.ts'
  */
 
 import { flat } from '../list/module.f.mjs'
-/** @import { List, Thunk } from '../list/types.ts' */
 import { map } from '../nullable/module.f.mjs'
-/** @import { TNode, Tree } from './types/types.ts' */
 
 /** @type {<T>(node: TNode<T>) => Thunk<T>} */
 const nodeValues

package/fjs/types/btree/proof.f.d.mts

@@ -1,4 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { TNode } from './types/types.ts'
+ * @import { List, Result } from '../list/types.ts'
+ */
 declare const valueTest1: () => void;
 declare const valuesTest2: () => void;
 declare const findTrue: () => void;

package/fjs/types/btree/proof.f.mjs

@@ -1,11 +1,13 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { TNode } from './types/types.ts'
+ * @import { List, Result } from '../list/types.ts'
+ */
 
-/** @import { TNode } from './types/types.ts' */
 import { values } from './module.f.mjs'
 import { stringify as jsonStringify } from '../../media/json/module.f.mjs'
 import { sort } from '../object/module.f.mjs'
 import { cmp } from '../string/module.f.mjs'
-/** @import { List, Result } from '../list/types.ts' */
 import { next, toArray } from '../list/module.f.mjs'
 import { set as setSet } from './set/module.f.mjs'
 import { value, find as findFind } from './find/module.f.mjs'

package/fjs/types/btree/remove/module.f.d.mts

@@ -1,3 +1,13 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ *
+ * @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { Path, PathItem } from '../find/types.ts'
+ * @import { Tuple } from '../../array/types.ts'
+ */
 import type { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 import type { Path } from '../find/types.ts';
@@ -16,6 +26,7 @@ export declare const proof: {
     throw: {
         reduceValue0DefaultBranch: () => void;
         reduceValue2DefaultBranch: () => void;
+        initValue0DefaultBranch: () => void;
         initValue1DefaultBranch: () => void;
     };
 };

package/fjs/types/btree/remove/module.f.mjs

@@ -2,19 +2,16 @@
  * Removal operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { Path, PathItem } from '../find/types.ts'
+ * @import { Tuple } from '../../array/types.ts'
  */
-import { collapseRoot } from '../types/module.f.mjs'
-/** @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts' */
-
-/** @import { Compare } from '../../function/compare/types.ts' */
 
+import { collapseRoot } from '../types/module.f.mjs'
 import { find } from '../find/module.f.mjs'
-/** @import { Path, PathItem } from '../find/types.ts' */
-
 import { fold, concat, next } from '../../list/module.f.mjs'
-
-/** @import { Tuple } from '../../array/types.ts' */
-
 import { map } from '../../nullable/module.f.mjs'
 
 /**
@@ -180,6 +177,9 @@ export const proof = {
         reduceValue2DefaultBranch: () => {
             reduceValue2([['leaf']])([['x'], 's', ['y']])
         },
+        initValue0DefaultBranch: () => {
+            initValue0(null)([['x'], 's', [['a'], 'b', ['c']]])
+        },
         initValue1DefaultBranch: () => {
             initValue1(null)([[['a'], 'b', ['c']], 'd', ['e']])
         },

package/fjs/types/btree/remove/proof.f.d.mts

@@ -1,3 +1,6 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
 declare const test: () => void;
 declare const test2: () => void;
 declare const test3: () => void;

package/fjs/types/btree/remove/proof.f.mjs

@@ -1,5 +1,8 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
+
 import { nodeRemove } from './module.f.mjs'
-/** @import { TNode } from '../types/types.ts' */
 import { set as setSet } from '../set/module.f.mjs'
 import { cmp } from '../../string/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'

package/fjs/types/btree/set/module.f.d.mts

@@ -1,3 +1,12 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ *
+ * @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts'
+ * @import { First, PathItem, Result } from '../find/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ */
 import type { Branch1, Branch3, TNode, Tree } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 export type _Branch1To3<T> = Branch1<T> | Branch3<T>;

package/fjs/types/btree/set/module.f.mjs

@@ -2,15 +2,14 @@
  * Insertion and update operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts'
+ * @import { First, PathItem, Result } from '../find/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
  */
-import { collapseRoot } from '../types/module.f.mjs'
-/** @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts' */
 
+import { collapseRoot } from '../types/module.f.mjs'
 import { find } from '../find/module.f.mjs'
-/** @import { First, PathItem, Result } from '../find/types.ts' */
-
-/** @import { Compare } from '../../function/compare/types.ts' */
-
 import { fold } from '../../list/module.f.mjs'
 
 /**

package/fjs/types/btree/set/proof.f.d.mts

@@ -1 +1,4 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
 export declare const proof: (() => void)[];

package/fjs/types/btree/set/proof.f.mjs

@@ -1,5 +1,8 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
+
 import { set as setSet } from './module.f.mjs'
-/** @import { TNode } from '../types/types.ts' */
 import { cmp } from '../../string/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'
 import { sort } from '../../object/module.f.mjs'

package/fjs/types/btree/types/module.f.d.mts

@@ -3,8 +3,9 @@
  * themselves live in `./types.ts`.
  *
  * @module
+ *
+ * @import { Branch1, Branch3, Branch5, TNode } from './types.ts'
  */
-/** @import { Branch1, Branch3, Branch5, TNode } from './types.ts' */
 import type { Branch1, Branch3, Branch5, TNode } from './types.ts';
 /**
  * Demotes a single-child branch root to its only child.

package/fjs/types/btree/types/module.f.mjs

@@ -3,8 +3,9 @@
  * themselves live in `./types.ts`.
  *
  * @module
+ *
+ * @import { Branch1, Branch3, Branch5, TNode } from './types.ts'
  */
-/** @import { Branch1, Branch3, Branch5, TNode } from './types.ts' */
 
 /**
  * Demotes a single-child branch root to its only child.

package/fjs/types/byte_set/module.f.d.mts

@@ -1,8 +1,17 @@
+/**
+ * Compact byte-set operations and predicates. See `./types.ts` for the
+ * `ByteSet` type.
+ *
+ * @module
+ *
+ * @import { RangeMap } from '../range_map/types.ts'
+ * @import { SortedSet } from '../sorted_set/types.ts'
+ * @import { ByteSet } from './types.ts'
+ */
 import type { RangeMap } from '../range_map/types.ts';
 import type { SortedSet } from '../sorted_set/types.ts';
 import type { ByteSet } from './types.ts';
 export type _Byte = number;
-/** @import { ByteSet } from './types.ts' */
 /** @typedef {number} _Byte */
 /** @type {(n: _Byte) => (s: ByteSet) => boolean} */
 export declare const has: (n: _Byte) => (s: ByteSet) => boolean;

package/fjs/types/byte_set/module.f.mjs

@@ -3,12 +3,14 @@
  * `ByteSet` type.
  *
  * @module
+ *
+ * @import { RangeMap } from '../range_map/types.ts'
+ * @import { SortedSet } from '../sorted_set/types.ts'
+ * @import { ByteSet } from './types.ts'
  */
+
 import { compose } from '../function/module.f.mjs'
-/** @import { RangeMap } from '../range_map/types.ts' */
-/** @import { SortedSet } from '../sorted_set/types.ts' */
 import { reverse, countdown, flat, map } from '../list/module.f.mjs'
-/** @import { ByteSet } from './types.ts' */
 
 /** @typedef {number} _Byte */
 

package/fjs/types/byte_set/proof.f.d.mts

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 export declare const proof: {
     has: (() => void)[];
     setRange: () => void;

package/fjs/types/byte_set/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 
 import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from './module.f.mjs'
 import { every, countdown, map, toArray } from '../list/module.f.mjs'

package/fjs/types/function/compare/module.f.d.mts

@@ -2,9 +2,10 @@
  * Comparison function types and helpers.
  *
  * @module
+ *
+ * @import { Index, Tuple } from '../../array/types.ts'
+ * @import { Cmp1, Cmp2, Compare, Sign } from './types.ts'
  */
-/** @import { Index, Tuple } from '../../array/types.ts' */
-/** @import { Cmp1, Cmp2, Compare, Sign } from './types.ts' */
 import type { Index, Tuple } from '../../array/types.ts';
 import type { Cmp1, Cmp2, Compare, Sign } from './types.ts';
 /** @type {<T>(cmp: Compare<T>) => (value: T) => Index<3>} */

package/fjs/types/function/compare/module.f.mjs

@@ -2,9 +2,10 @@
  * Comparison function types and helpers.
  *
  * @module
+ *
+ * @import { Index, Tuple } from '../../array/types.ts'
+ * @import { Cmp1, Cmp2, Compare, Sign } from './types.ts'
  */
-/** @import { Index, Tuple } from '../../array/types.ts' */
-/** @import { Cmp1, Cmp2, Compare, Sign } from './types.ts' */
 
 /** @type {<T>(cmp: Compare<T>) => (value: T) => Index<3>} */
 export const index3

package/fjs/types/function/module.f.d.mts

@@ -1,4 +1,11 @@
-/** @import { Func, Fn } from './types.ts' */
+/**
+ * Function combinators: composition, identity, argument flipping, and the
+ * chainable `Fn` wrapper.
+ *
+ * @module
+ *
+ * @import { Func, Fn } from './types.ts'
+ */
 import type { Func, Fn } from './types.ts';
 /**
  * A postfix compose function.

package/fjs/types/function/module.f.mjs

@@ -1,4 +1,11 @@
-/** @import { Func, Fn } from './types.ts' */
+/**
+ * Function combinators: composition, identity, argument flipping, and the
+ * chainable `Fn` wrapper.
+ *
+ * @module
+ *
+ * @import { Func, Fn } from './types.ts'
+ */
 
 /**
  * A postfix compose function.

package/fjs/types/function/operator/module.f.d.mts

@@ -2,9 +2,10 @@
  * Common higher-order operator type aliases.
  *
  * @module
+ *
+ * @import { Fold, Reduce, Scan, StateScan, Unary } from './types.ts'
  */
 import type { Fold, Reduce, Scan, StateScan, Unary } from './types.ts';
-/** @import { Fold, Reduce, Scan, StateScan, Unary } from './types.ts' */
 /** @type {(separator: string) => Reduce<string>} */
 export declare const join: (separator: string) => Reduce<string>;
 /** @type {Reduce<string>} */