functionalscript 0.30.0 → 0.31.0

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

@@ -3,8 +3,39 @@
  *
  * @module
  */
-import { flatMap } from "../../types/list/module.f.js";
+import { flatMap, toArray } from "../../types/list/module.f.js";
 import { decoder, errorMask } from "../code_point/module.f.js";
+import { msb, u8List, length } from "../../types/bit_vec/module.f.js";
+import { codePointListToString } from "../utf16/module.f.js";
+/**
+ * UTF-8 byte-format constants. Each byte kind is defined by a tag — the fixed
+ * high bits identifying the kind — and a payload mask selecting the code-point
+ * bits the byte carries. The encoder and the decoder are exact inverses, so
+ * both read their bit patterns from this single set of definitions:
+ *
+ * | byte kind   | pattern      | tag       | payload mask |
+ * |-------------|--------------|-----------|--------------|
+ * | continuation| `10xx_xxxx`  | `contTag` | `contMask`   |
+ * | 2-byte lead | `110x_xxxx`  | `lead2Tag`| `lead2Mask`  |
+ * | 3-byte lead | `1110_xxxx`  | `lead3Tag`| `lead3Mask`  |
+ * | 4-byte lead | `1111_0xxx`  | `lead4Tag`| `lead4Mask`  |
+ */
+const contTag = 0b1000_0000;
+const contMask = 0b0011_1111;
+const lead2Tag = 0b1100_0000;
+const lead2Mask = 0b0001_1111;
+const lead3Tag = 0b1110_0000;
+const lead3Mask = 0b0000_1111;
+const lead4Tag = 0b1111_0000;
+const lead4Mask = 0b0000_0111;
+/**
+ * Encodes the low six bits of `x` as a UTF-8 continuation byte.
+ */
+const contByte = (x) => x & contMask | contTag;
+/**
+ * Reads the six payload bits of a continuation byte.
+ */
+const contPayload = (b) => b & contMask;
 /**
  * Converts a Unicode code point to a sequence of UTF-8 bytes.
  * @param input The Unicode code point to be converted. Valid range:
@@ -20,41 +51,41 @@ const codePointToUtf8 = (input) => {
         return [input & 0b01111_1111];
     }
     if (input >= 0x0080 && input <= 0x07ff) {
-        return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000];
+        return [input >> 6 | lead2Tag, contByte(input)];
     }
     if (input >= 0x0800 && input <= 0xffff) {
         return [
-            input >> 12 | 0b1110_0000,
-            input >> 6 & 0b0011_1111 | 0b1000_0000,
-            input & 0b0011_1111 | 0b1000_0000,
+            input >> 12 | lead3Tag,
+            contByte(input >> 6),
+            contByte(input),
         ];
     }
     if (input >= 0x10000 && input <= 0x10ffff) {
         return [
-            input >> 18 | 0b1111_0000,
-            input >> 12 & 0b0011_1111 | 0b1000_0000,
-            input >> 6 & 0b0011_1111 | 0b1000_0000,
-            input & 0b0011_1111 | 0b1000_0000,
+            input >> 18 | lead4Tag,
+            contByte(input >> 12),
+            contByte(input >> 6),
+            contByte(input),
         ];
     }
     if ((input & errorMask) !== 0) {
         if ((input & 0b1000_0000_0000_0000) !== 0) {
             return [
-                input >> 12 & 0b0000_0111 | 0b1111_0000,
-                input >> 6 & 0b0011_1111 | 0b1000_0000,
-                input & 0b0011_1111 | 0b1000_0000,
+                input >> 12 & lead4Mask | lead4Tag,
+                contByte(input >> 6),
+                contByte(input),
             ];
         }
         if ((input & 0b0000_0100_0000_0000) !== 0) {
             return [
-                input >> 6 & 0b0000_1111 | 0b1110_0000,
-                input & 0b0011_1111 | 0b1000_0000,
+                input >> 6 & lead3Mask | lead3Tag,
+                contByte(input),
             ];
         }
         if ((input & 0b0000_0010_0000_0000) !== 0) {
             return [
-                input >> 6 & 0b0000_0111 | 0b1111_0000,
-                input & 0b0011_1111 | 0b1000_0000,
+                input >> 6 & lead4Mask | lead4Tag,
+                contByte(input),
             ];
         }
         if ((input & 0b0000_0000_1000_0000) !== 0)
@@ -84,16 +115,16 @@ const utf8StateToError = (state) => {
         }
         case 2: {
             const [s0, s1] = state;
-            x = s0 < 0b1111_0000
-                ? ((s0 & 0b0000_1111) << 6) + (s1 & 0b0011_1111) + 0b0000_0100_0000_0000
-                : ((s0 & 0b0000_0111) << 6) + (s1 & 0b0011_1111) +
+            x = s0 < lead4Tag
+                ? ((s0 & lead3Mask) << 6) + contPayload(s1) + 0b0000_0100_0000_0000
+                : ((s0 & lead4Mask) << 6) + contPayload(s1) +
                     0b0000_0010_0000_0000;
             break;
         }
         case 3: {
             const [s0, s1, s2] = state;
-            x = ((s0 & 0b0000_0111) << 12) + ((s1 & 0b0011_1111) << 6) +
-                (s2 & 0b0011_1111) + 0b1000_0000_0000_0000;
+            x = ((s0 & lead4Mask) << 12) + (contPayload(s1) << 6) +
+                contPayload(s2) + 0b1000_0000_0000_0000;
             break;
         }
         default:
@@ -115,18 +146,18 @@ const utf8ByteToCodePointOp = (byte, state) => {
         return [[errorMask], state];
     }
     if (state === null) {
-        if (byte < 0b1000_0000)
+        if (byte < contTag)
             return [[byte], null];
         if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
             return [[], [byte]];
         return [[byte | errorMask], null];
     }
-    if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
+    if (byte >= contTag && byte < lead2Tag) {
         switch (state.length) {
             case 1: {
                 const [s0] = state;
-                if (s0 < 0b1110_0000) {
-                    return [[((s0 & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null];
+                if (s0 < lead3Tag) {
+                    return [[((s0 & lead2Mask) << 6) + contPayload(byte)], null];
                 }
                 if (s0 < 0b1111_1000)
                     return [[], [s0, byte]];
@@ -134,10 +165,10 @@ const utf8ByteToCodePointOp = (byte, state) => {
             }
             case 2: {
                 const [s0, s1] = state;
-                if (s0 < 0b1111_0000) {
+                if (s0 < lead4Tag) {
                     return [[
-                            ((s0 & 0b0000_1111) << 12) + ((s1 & 0b0011_1111) << 6) +
-                                (byte & 0b0011_1111),
+                            ((s0 & lead3Mask) << 12) + (contPayload(s1) << 6) +
+                                contPayload(byte),
                         ], null];
                 }
                 if (s0 < 0b1111_1000)
@@ -147,14 +178,14 @@ const utf8ByteToCodePointOp = (byte, state) => {
             case 3: {
                 const [s0, s1, s2] = state;
                 return [[
-                        ((s0 & 0b0000_0111) << 18) + ((s1 & 0b0011_1111) << 12) +
-                            ((s2 & 0b0011_1111) << 6) + (byte & 0b0011_1111),
+                        ((s0 & lead4Mask) << 18) + (contPayload(s1) << 12) +
+                            (contPayload(s2) << 6) + contPayload(byte),
                     ], null];
             }
         }
     }
     const error = utf8StateToError(state);
-    if (byte < 0b1000_0000)
+    if (byte < contTag)
         return [[error, byte], null];
     if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
         return [[error], [byte]];
@@ -179,3 +210,26 @@ const utf8EofToCodePointOp = (state) => [
  * @returns A list of Unicode code points or error codes.
  */
 export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePointOp);
+/**
+ * Returns the decoded string if `v` is valid UTF-8, or `null` otherwise.
+ * Rejects non-octet Vecs, invalid byte sequences, surrogates, and out-of-range
+ * code points.
+ */
+export const fromVec = (v) => {
+    if (length(v) % 8n !== 0n) {
+        return null;
+    }
+    const arr = toArray(toCodePointList(u8List(msb)(v)));
+    for (const cp of arr) {
+        if (cp < 0) {
+            return null;
+        }
+        if (cp > 0x10FFFF) {
+            return null;
+        }
+        if (cp >= 0xD800 && cp <= 0xDFFF) {
+            return null;
+        }
+    }
+    return codePointListToString(arr);
+};

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

@@ -2,4 +2,5 @@ export declare const proof: {
     toCodePoint: (() => void)[];
     fromCodePointList: (() => void)[];
     toFrom: (() => void)[];
+    fromVec: (() => void)[];
 };

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

@@ -1,7 +1,8 @@
-import { toCodePointList, fromCodePointList } from "./module.f.js";
+import { toCodePointList, fromCodePointList, fromVec } from "./module.f.js";
 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";
+import { msb, u8ListToVec } from "../../types/bit_vec/module.f.js";
 const stringify = jsonStringify(sort);
 export const proof = {
     toCodePoint: [
@@ -170,5 +171,63 @@ export const proof = {
                 throw result;
             }
         }
+    ],
+    fromVec: [
+        // Valid ASCII → decoded string
+        () => {
+            const v = u8ListToVec(msb)([0x68, 0x65, 0x6c, 0x6c, 0x6f]); // "hello"
+            if (fromVec(v) !== 'hello') {
+                throw 'expected "hello"';
+            }
+        },
+        // Valid multi-byte UTF-8 → decoded string (U+00A9 COPYRIGHT SIGN, 2-byte)
+        () => {
+            const v = u8ListToVec(msb)([0xc2, 0xa9]); // "©"
+            if (fromVec(v) !== '©') {
+                throw 'expected copyright sign';
+            }
+        },
+        // Valid 3-byte UTF-8 (U+4E2D CJK)
+        () => {
+            const v = u8ListToVec(msb)([0xe4, 0xb8, 0xad]); // "中"
+            if (fromVec(v) !== '中') {
+                throw 'expected CJK character';
+            }
+        },
+        // Valid 4-byte UTF-8 (U+1F600 GRINNING FACE)
+        () => {
+            const v = u8ListToVec(msb)([0xf0, 0x9f, 0x98, 0x80]);
+            if (fromVec(v) !== '\u{1f600}') {
+                throw 'expected emoji';
+            }
+        },
+        // Invalid byte sequence → null
+        () => {
+            const v = u8ListToVec(msb)([0xff, 0xfe]); // not valid UTF-8
+            if (fromVec(v) !== null) {
+                throw 'expected null for invalid UTF-8';
+            }
+        },
+        // Lone continuation byte → null
+        () => {
+            const v = u8ListToVec(msb)([0x80]);
+            if (fromVec(v) !== null) {
+                throw 'expected null for lone continuation byte';
+            }
+        },
+        // Surrogate half (U+D800, encoded as CESU-8 0xED 0xA0 0x80) → null
+        () => {
+            const v = u8ListToVec(msb)([0xed, 0xa0, 0x80]);
+            if (fromVec(v) !== null) {
+                throw 'expected null for surrogate';
+            }
+        },
+        // Empty Vec → empty string
+        () => {
+            const v = u8ListToVec(msb)([]);
+            if (fromVec(v) !== '') {
+                throw 'expected empty string';
+            }
+        },
     ]
 };

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

@@ -1,3 +1,6 @@
 export type BigFloat = readonly [bigint, number];
 export declare const multiply: ([m, e]: BigFloat) => (mul: bigint) => BigFloat;
 export declare const decToBin: (dec: BigFloat) => BigFloat;
+export declare const proof: {
+    normalizeMantissaZero: () => void;
+};

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

@@ -6,51 +6,48 @@
 import { abs, sign } from "../bigint/module.f.js";
 const twoPow53 = 9007199254740992n;
 const twoPow54 = 18014398509481984n;
-const increaseMantissa = ([m, e]) => (min) => {
-    if (m === 0n) {
-        return [m, e];
-    }
-    const s = sign(m);
-    m = abs(m);
-    while (true) {
-        if (m >= min) {
-            return [BigInt(s) * m, e];
-        }
-        m = m << 1n;
-        e--;
-    }
-};
-const decreaseMantissa = ([m, e]) => (max) => {
+/**
+ * Shifts the mantissa magnitude one bit at a time, compensating the exponent,
+ * until `done(magnitude, bound)` holds; the sign is restored on return.
+ * A zero mantissa is returned unchanged: it can never satisfy a lower bound,
+ * so shifting it would not terminate.
+ */
+const normalizeMantissa = (shift, de, done) => ([m, e]) => (bound) => {
     if (m === 0n) {
         return [m, e];
     }
     const s = sign(m);
     m = abs(m);
     while (true) {
-        if (m < max) {
+        if (done(m, bound)) {
             return [BigInt(s) * m, e];
         }
-        m = m >> 1n;
-        e++;
+        m = shift(m);
+        e += de;
     }
 };
+const increaseMantissa = normalizeMantissa(m => m << 1n, -1, (m, min) => m >= min);
+const decreaseMantissa = normalizeMantissa(m => m >> 1n, +1, (m, max) => m < max);
 const pow = (base) => (exp) => base ** BigInt(exp);
 const pow5 = pow(5n);
 export const multiply = ([m, e]) => (mul) => [m * mul, e];
 const divide = ([m, e]) => (div) => [[m / div, e], m % div];
-const round53 = ([[m, e], r]) => {
-    const mabs = abs(m);
-    const s = BigInt(sign(m));
-    const [m54, e54] = decreaseMantissa([mabs, e])(twoPow54);
+/**
+ * Runs `f` on the magnitude `[abs(m), e]` and restores the sign of `m` on the
+ * result: operations on signed mantissas factor through the magnitude.
+ */
+const withSign = (m, e) => (f) => multiply(f([abs(m), e]))(BigInt(sign(m)));
+const round53 = ([[m, e], r]) => withSign(m, e)(([mAbs]) => {
+    const [m54, e54] = decreaseMantissa([mAbs, e])(twoPow54);
     const o54 = m54 & 1n;
     const m53 = m54 >> 1n;
     const e53 = e54 + 1;
-    if (o54 === 1n && r === 0n && mabs === m54 >> BigInt(e - e54)) {
+    if (o54 === 1n && r === 0n && mAbs === m54 >> BigInt(e - e54)) {
         const odd = m53 & 1n;
-        return multiply([m53 + odd, e53])(s);
+        return [m53 + odd, e53];
     }
-    return multiply([m53 + o54, e53])(s);
-};
+    return [m53 + o54, e53];
+});
 export const decToBin = (dec) => {
     if (dec[0] === 0n) {
         return [0n, 0];
@@ -62,9 +59,11 @@ export const decToBin = (dec) => {
     }
     const p = pow5(-dec[1]);
     const [m, e] = increaseMantissa(dec)(p * twoPow53);
-    const mAbs = abs(m);
-    const s = BigInt(sign(m));
-    const qr = divide([mAbs, e])(p);
-    const r53 = round53(qr);
-    return multiply(r53)(s);
+    return withSign(m, e)(magnitude => round53(divide(magnitude)(p)));
+};
+export const proof = {
+    // normalizeMantissa guards against zero mantissa to prevent an infinite loop;
+    // this path is unreachable through decToBin (which returns early for 0n),
+    // so we exercise it here where the private helper is in scope.
+    normalizeMantissaZero: () => { increaseMantissa([0n, 5])(1n); }
 };

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

@@ -151,5 +151,27 @@ export declare const factorial: (b: bigint) => bigint;
  */
 export declare const combination: (...k: readonly bigint[]) => bigint;
 export declare const xor: Reduce;
-export declare const divUp: Reduce;
-export declare const roundUp: Reduce;
+export declare const divUp: (b: bigint) => Unary;
+export declare const roundUp: (b: bigint) => Unary;
+/**
+ * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ *
+ * @param e - The exponent (divisor = 2^e).
+ * @returns A function that rounds a value up by the given power of two.
+ */
+export declare const divUpE2: (e: bigint) => Unary;
+/**
+ * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ *
+ * @param e - The exponent (multiple = 2^e).
+ * @returns A function that rounds a value up to the nearest multiple of the given power of two.
+ */
+export declare const roundUpE2: (e: bigint) => Unary;
+/**
+ * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
+ */
+export declare const divUp8: Unary;
+/**
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ */
+export declare const roundUp8: Unary;

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

@@ -216,11 +216,39 @@ export const combination = (...k) => {
     return partialFactorial(m)(s) / p;
 };
 export const xor = a => b => a ^ b;
-export const divUp = b => {
+export const divUp = (b) => {
     const m = b - 1n;
     return v => (v + m) / b;
 };
-export const roundUp = b => {
+export const roundUp = (b) => {
     const d = divUp(b);
     return v => d(v) * b;
 };
+/**
+ * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ *
+ * @param e - The exponent (divisor = 2^e).
+ * @returns A function that rounds a value up by the given power of two.
+ */
+export const divUpE2 = (e) => {
+    const m = mask(e);
+    return v => (v + m) >> e;
+};
+/**
+ * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ *
+ * @param e - The exponent (multiple = 2^e).
+ * @returns A function that rounds a value up to the nearest multiple of the given power of two.
+ */
+export const roundUpE2 = (e) => {
+    const d = divUpE2(e);
+    return v => d(v) << e;
+};
+/**
+ * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
+ */
+export const divUp8 = divUpE2(3n);
+/**
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ */
+export const roundUp8 = roundUpE2(3n);

package/fs/types/bigint/proof.f.d.ts

@@ -29,4 +29,11 @@ export declare const proof: {
     combination3: () => void;
     divUp: () => void;
     roundUp: () => void;
+    divUpE2: () => void;
+    roundUpE2: () => void;
+    divUp8: () => void;
+    roundUp8: () => void;
+    xor: () => void;
+    multiple: () => void;
+    product: () => void;
 };

package/fs/types/bigint/proof.f.js

@@ -1,4 +1,5 @@
-import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, divUp, roundUp } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUpE2, roundUpE2, divUp8, roundUp8 } from "./module.f.js";
+import { assertEq } from "../../asserts/module.f.js";
 import { min } from "../function/compare/module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
@@ -454,22 +455,52 @@ export const proof = {
         }
     },
     divUp: () => {
-        if (divUp(8n)(8n) !== 1n) {
-            throw new Error("fail");
-        }
-        if (divUp(8n)(15n) !== 2n) {
-            throw new Error("fail");
-        }
+        assertEq(divUp(8n)(8n), 1n);
+        assertEq(divUp(8n)(15n), 2n);
     },
     roundUp: () => {
-        if (roundUp(8n)(8n) !== 8n) {
-            throw new Error("fail");
-        }
-        if (roundUp(8n)(15n) !== 16n) {
-            throw new Error("fail");
-        }
-        if (roundUp(8n)(3n) !== 8n) {
-            throw new Error("fail");
-        }
+        assertEq(roundUp(8n)(8n), 8n);
+        assertEq(roundUp(8n)(15n), 16n);
+        assertEq(roundUp(8n)(3n), 8n);
+    },
+    divUpE2: () => {
+        assertEq(divUpE2(3n)(8n), 1n);
+        assertEq(divUpE2(3n)(15n), 2n);
+        assertEq(divUpE2(3n)(0n), 0n);
+        assertEq(divUpE2(3n)(8n), 1n);
+        assertEq(divUpE2(3n)(9n), 2n);
+    },
+    roundUpE2: () => {
+        assertEq(roundUpE2(3n)(8n), 8n);
+        assertEq(roundUpE2(3n)(15n), 16n);
+        assertEq(roundUpE2(3n)(3n), 8n);
+        assertEq(roundUpE2(3n)(0n), 0n);
+        assertEq(roundUpE2(3n)(8n), 8n);
+        assertEq(roundUpE2(3n)(9n), 16n);
+    },
+    divUp8: () => {
+        assertEq(divUp8(0n), 0n);
+        assertEq(divUp8(1n), 1n);
+        assertEq(divUp8(8n), 1n);
+        assertEq(divUp8(9n), 2n);
+    },
+    roundUp8: () => {
+        assertEq(roundUp8(0n), 0n);
+        assertEq(roundUp8(1n), 8n);
+        assertEq(roundUp8(8n), 8n);
+        assertEq(roundUp8(9n), 16n);
+    },
+    xor: () => {
+        assertEq(xor(5n)(3n), 6n);
+        assertEq(xor(0n)(15n), 15n);
+        assertEq(xor(0xffn)(0xf0n), 0x0fn);
+    },
+    multiple: () => {
+        assertEq(multiple(3n)(4n), 12n);
+        assertEq(multiple(0n)(100n), 0n);
+    },
+    product: () => {
+        assertEq(product([1n, 2n, 3n, 4n]), 24n);
+        assertEq(product([5n, 6n]), 30n);
     },
 };

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

@@ -30,6 +30,24 @@ export declare const vec: (len: bigint) => (ui: bigint) => Vec;
  * Creates an 8-bit vector from an unsigned integer.
  */
 export declare const vec8: (ui: bigint) => Vec;
+/**
+ * Builds a vector from a bigint whose most-significant set bit is a sentinel
+ * marking the start of the data.
+ *
+ * The sentinel does double duty: it fixes the length (`bitLength - 1`) and is
+ * stripped from the result. This lets a plain hex literal carry leading zero
+ * bits that would otherwise be lost — write `0x1` ahead of the data and the
+ * `1` both delimits and disappears.
+ *
+ * @example
+ *
+ * ```js
+ * uint(fromSentinel(0x1_89_50n))   // 0x8950n
+ * length(fromSentinel(0x1_89_50n)) // 16n — the two data bytes, sentinel gone
+ * fromSentinel(0x1_00_05n)         // a 16-bit vector holding 0x0005
+ * ```
+ */
+export declare const fromSentinel: (raw: bigint) => Vec;
 /**
  * Returns the unsigned integer representation of the vector by clearing the stop bit.
  *

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

@@ -67,6 +67,24 @@ export const vec = (len) => {
  * Creates an 8-bit vector from an unsigned integer.
  */
 export const vec8 = vec(8n);
+/**
+ * Builds a vector from a bigint whose most-significant set bit is a sentinel
+ * marking the start of the data.
+ *
+ * The sentinel does double duty: it fixes the length (`bitLength - 1`) and is
+ * stripped from the result. This lets a plain hex literal carry leading zero
+ * bits that would otherwise be lost — write `0x1` ahead of the data and the
+ * `1` both delimits and disappears.
+ *
+ * @example
+ *
+ * ```js
+ * uint(fromSentinel(0x1_89_50n))   // 0x8950n
+ * length(fromSentinel(0x1_89_50n)) // 16n — the two data bytes, sentinel gone
+ * fromSentinel(0x1_00_05n)         // a 16-bit vector holding 0x0005
+ * ```
+ */
+export const fromSentinel = (raw) => vec(bitLength(raw) - 1n)(raw);
 /**
  * Returns the unsigned integer representation of the vector by clearing the stop bit.
  *

package/fs/types/bit_vec/proof.f.d.ts

@@ -1,4 +1,5 @@
 export declare const proof: {
+    fromSentinel: () => void;
     examples: {
         vec: () => void;
         uint: () => void;

package/fs/types/bit_vec/proof.f.js

@@ -1,6 +1,6 @@
 import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List, chunkList } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List, chunkList, fromSentinel } from "./module.f.js";
 import { repeat as listRepeat, toArray } from "../list/module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
@@ -81,6 +81,18 @@ const concat = (e) => (r) => () => {
     }
 };
 export const proof = {
+    fromSentinel: () => {
+        // Two data bytes; the leading 0x1 nibble is the sentinel, stripped out.
+        const v = fromSentinel(0x18950n);
+        assertEq(length(v), 16n);
+        assertEq(uint(v), 0x8950n);
+        // Leading zero bytes survive because the sentinel pins the length.
+        const z = fromSentinel(0x10005n);
+        assertEq(length(z), 16n);
+        assertEq(uint(z), 0x0005n);
+        // A bare sentinel yields the empty vector.
+        assertEq(fromSentinel(0x1n), empty);
+    },
     examples: {
         vec: () => {
             const vec4 = vec(4n);

package/fs/types/function/operator/proof.f.d.ts

@@ -5,6 +5,8 @@ export declare const proof: {
     strictEqualTest: () => void;
     additionTest: () => void;
     incrementTest: () => void;
+    counterTest: () => void;
+    stateScanToScanTest: () => void;
     foldToScanTest: () => void;
     reduceToScanTest: () => void;
 };

package/fs/types/function/operator/proof.f.js

@@ -1,4 +1,4 @@
-import { join, concat, logicalNot, strictEqual, addition, increment, foldToScan, reduceToScan, } from "./module.f.js";
+import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from "./module.f.js";
 const joinTest = () => {
     const result = join(', ')('world')('hello');
     if (result !== 'hello, world') {
@@ -63,4 +63,22 @@ const reduceToScanTest = () => {
         throw v1;
     }
 };
-export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, foldToScanTest, reduceToScanTest };
+const counterTest = () => {
+    const fn = counter();
+    if (fn(4) !== 5) {
+        throw 'counter() returned wrong function';
+    }
+};
+const stateScanToScanTest = () => {
+    const op = (input, state) => [input + state, input + state];
+    const scan = stateScanToScan(op)(0);
+    const [v1, scan2] = scan(3);
+    if (v1 !== 3) {
+        throw v1;
+    }
+    const [v2] = scan2(4);
+    if (v2 !== 7) {
+        throw v2;
+    }
+};
+export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, counterTest, stateScanToScanTest, foldToScanTest, reduceToScanTest };