functionalscript 0.43.1 → 0.44.0

package/fjs/sul/id/proof.f.js

@@ -1,61 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { mask } from '../../types/bigint/module.f.js';
-import { vec } from '../../types/bit_vec/module.f.js';
-import { compress, hashId, isHash, isRaw, level3Id, rawId } from './module.f.js';
-import { asBase } from '../../types/nominal/module.f.js';
-// literal3ToVec bit patterns for symbols used below:
-//   0  → vec(8n)(0n)     4  → vec(8n)(3n)
-//   1  → vec(8n)(1n)     10 → vec(8n)(5n)
-//                        128 → vec(8n)(15n)
-// Two 127-bit raw payloads overflow the 253-bit inline limit, producing a hash value.
-const rawX7F = rawId(vec(0x7fn)(mask(0x7fn)));
-const overflowHash = compress(rawX7F, rawX7F);
-const hFF = hashId(mask(0xffn));
-const hFE = hashId(mask(0xffn) - 1n);
-assertEq(asBase(level3Id(0n)), 0n);
-assertEq(asBase(hashId(0n)), 1n << 0xffn);
-assertEq(asBase(hFF), mask(0x100n));
-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))),
-    inline_01_00: () => assertEq(compress(level3Id(0x01n), level3Id(0x00n)), rawId(vec(16n)(0x0100n))),
-    inline_01_01: () => assertEq(compress(level3Id(0x01n), level3Id(0x01n)), rawId(vec(16n)(0x0101n))),
-    inline_00_04: () => assertEq(compress(level3Id(0x00n), level3Id(0x04n)), rawId(vec(16n)(0x0003n))),
-    inline_04_00: () => assertEq(compress(level3Id(0x04n), level3Id(0x00n)), rawId(vec(16n)(0x0300n))),
-    inline_0A_80: () => assertEq(compress(level3Id(0x0an), level3Id(0x80n)), rawId(vec(16n)(0x050fn))),
-    // Inline outputs are raw-encoded (bit 254 set, bit 255 not set)
-    inline_is_raw: () => assert(isRaw(compress(level3Id(0x00n), level3Id(0x00n)))),
-    // Non-commutativity: argument order is preserved in concatenation
-    non_commutative: () => {
-        assert(compress(level3Id(0n), level3Id(1n)) !== compress(level3Id(1n), level3Id(0n)), compress(level3Id(0n), level3Id(1n)));
-    },
-    // Overflow: two 127-bit raw payloads sum to 254 bits, exceeding the 253-bit inline limit
-    overflow_is_hash: () => assert(isHash(overflowHash)),
-    // Hash input: either argument being a hash always triggers SHA2-based merge
-    hash_left_is_hash: () => assert(isHash(compress(overflowHash, level3Id(0n)))),
-    hash_right_is_hash: () => assert(isHash(compress(level3Id(0n), overflowHash))),
-    hash_non_commutative: () => {
-        assert(compress(overflowHash, level3Id(0n)) !== compress(level3Id(0n), overflowHash), compress(overflowHash, level3Id(0n)));
-    },
-    // High-bit sensitivity: prefix bit of `a` is included in the SHA2 upper half
-    hash_merge_a_high_bits: () => {
-        assert(compress(hashId(0n), hashId(0n)) !== compress(level3Id(0n), hashId(0n)), compress(hashId(0n), hashId(0n)));
-    },
-    // High-bit sensitivity: prefix bit of `b` is included in the SHA2 lower half
-    hash_merge_b_high_bits: () => {
-        assert(compress(hashId(0n), hashId(0n)) !== compress(hashId(0n), level3Id(0n)), compress(hashId(0n), hashId(0n)));
-    },
-    // Shift correctness: changing a bit in `a` (upper 256 bits of SHA2 input) changes result
-    hash_merge_a_sensitivity: () => {
-        assert(compress(hFF, hFF) !== compress(hFE, hFF), compress(hFF, hFF));
-    },
-    // Shift correctness: changing a bit in `b` (lower 256 bits of SHA2 input) changes result
-    hash_merge_b_sensitivity: () => {
-        assert(compress(hFF, hFF) !== compress(hFF, hFE), compress(hFF, hFF));
-    },
-    // Shift correctness: same bit-flip in `a` vs `b` lands at different SHA2 input positions
-    hash_merge_shift: () => {
-        assert(compress(hFE, hFF) !== compress(hFF, hFE), compress(hFE, hFF));
-    },
-};

package/fjs/sul/level/hash/module.f.d.ts

@@ -1,38 +0,0 @@
-/**
- * Streaming encoder for SUL hash-level symbols using a Patricia trie and 256-bit content-addressed hashes.
- *
- * @module
- */
-import { type State } from '../../../types/patricia_trie/module.f.ts';
-import { type Id } from '../../id/module.f.ts';
-/**
- * Called once per merge during encoding. `merged = compress(left, right)`.
- * `isSymbol` is `true` for the terminal `compress(root, t)` that produces the
- * word-level output symbol, and `false` for Patricia trie internal merges.
- * Implementations record the triple in a content-addressed store.
- */
-export type Add<S> = (left: Id, right: Id, merged: Id, isSymbol: boolean, storage: S) => S;
-/**
- * Streaming state for hash-level encoding.
- * Wraps the Patricia trie state that accumulates the strictly-decreasing
- * prefix of the word currently being encoded.
- */
-export type EncodeState<S> = State<S, Id>;
-/**
- * Returns a streaming encoder for hash-level symbols.
- *
- * The returned step function processes one level-3 symbol at a time.
- * It returns `undefined` while the strictly-decreasing prefix is still
- * being accumulated. When the terminating symbol `t` arrives (`t >= last`),
- * the word `[s0 > ... > sk, t]` is finalised:
- *
- * 1. The Patricia trie of `[s0, ..., sk]` is collapsed to a root hash.
- * 2. The root is merged with `t` via `compress`, producing the output symbol.
- * 3. State is reset to an empty stack (storage is preserved).
- *
- * `add` is called once for every `compress` call. `isSymbol` is `false` for
- * Patricia trie internal merges and `true` for the terminal `compress(root, t)`.
- */
-export declare const encode: <S>(add: Add<S>) => (symbol: Id, state: EncodeState<S>) => readonly [Id | undefined, EncodeState<S>];
-/** Returns the initial encoding state wrapping `storage`. */
-export declare const emptyEncodeState: <S>(storage: S) => EncodeState<S>;

package/fjs/sul/level/hash/module.f.js

@@ -1,43 +0,0 @@
-/**
- * Streaming encoder for SUL hash-level symbols using a Patricia trie and 256-bit content-addressed hashes.
- *
- * @module
- */
-import { emptyState, patriciaTrie } from '../../../types/patricia_trie/module.f.js';
-import { compress } from '../../id/module.f.js';
-import { asBase } from '../../../types/nominal/module.f.js';
-/**
- * Returns a streaming encoder for hash-level symbols.
- *
- * The returned step function processes one level-3 symbol at a time.
- * It returns `undefined` while the strictly-decreasing prefix is still
- * being accumulated. When the terminating symbol `t` arrives (`t >= last`),
- * the word `[s0 > ... > sk, t]` is finalised:
- *
- * 1. The Patricia trie of `[s0, ..., sk]` is collapsed to a root hash.
- * 2. The root is merged with `t` via `compress`, producing the output symbol.
- * 3. State is reset to an empty stack (storage is preserved).
- *
- * `add` is called once for every `compress` call. `isSymbol` is `false` for
- * Patricia trie internal merges and `true` for the terminal `compress(root, t)`.
- */
-export const encode = (add) => {
-    const create = (isSymbol) => (a, b, s) => {
-        const m = compress(a, b);
-        return [m, add(a, b, m, isSymbol, s)];
-    };
-    const { push, end } = patriciaTrie(create(false));
-    const rootCreate = create(true);
-    return (symbol, state) => {
-        const [, stack] = state;
-        const last = stack.at(-1);
-        if (last === undefined || last[0] > asBase(symbol)) {
-            return [undefined, push([asBase(symbol), symbol], state)];
-        }
-        const [root1, storage1] = end(state);
-        const [root2, storage2] = rootCreate(root1, symbol, storage1);
-        return [root2, [storage2, []]];
-    };
-};
-/** Returns the initial encoding state wrapping `storage`. */
-export const emptyEncodeState = emptyState;

package/fjs/sul/level/hash/proof.f.d.ts

@@ -1,13 +0,0 @@
-export declare const proof: {
-    min_equal: () => void;
-    min_greater: () => void;
-    intermediate_undefined: () => void;
-    three_symbol: () => void;
-    output_is_last_add: () => void;
-    state_reset: () => void;
-    storage_accumulates: () => void;
-    two_words: () => void;
-    non_commutative: () => void;
-    isSymbol_terminal_only: () => void;
-    isSymbol_min_word: () => void;
-};

package/fjs/sul/level/hash/proof.f.js

@@ -1,112 +0,0 @@
-import { assert, assertEq } from '../../../asserts/module.f.js';
-import { compress, level3Id } from '../../id/module.f.js';
-import { emptyEncodeState, encode } from './module.f.js';
-const add = (l, r, m, isSymbol, s) => [...s, [l, r, m, isSymbol]];
-const enc = encode(add);
-const initial = emptyEncodeState([]);
-// Run a complete valid word from a clean state; throws if no output is produced.
-const runWord = (symbols) => {
-    let state = initial;
-    for (const s of symbols) {
-        const [out, newState] = enc(s, state);
-        state = newState;
-        if (out !== undefined) {
-            return [out, state[0]];
-        }
-    }
-    throw symbols;
-};
-// Every stored triple must satisfy m === compress(l, r).
-const verifyStorage = (storage) => {
-    for (const [l, r, m] of storage) {
-        assertEq(m, compress(l, r));
-    }
-};
-const s0 = level3Id(0n);
-const s1 = level3Id(1n);
-export const proof = {
-    // Minimum word [s0, t] with t == s0
-    min_equal: () => {
-        const [out, storage] = runWord([s0, s0]);
-        assertEq(out, compress(s0, s0));
-        assertEq(storage.length, 1);
-        verifyStorage(storage);
-    },
-    // Minimum word [s0, t] with t > s0
-    min_greater: () => {
-        const [out, storage] = runWord([s0, s1]);
-        assertEq(out, compress(s0, s1));
-        assertEq(storage.length, 1);
-        verifyStorage(storage);
-    },
-    // All symbols before the terminator return undefined
-    intermediate_undefined: () => {
-        const [r0, st0] = enc(s1, initial);
-        assertEq(r0, undefined);
-        const [r1, st1] = enc(s0, st0);
-        assertEq(r1, undefined);
-        const [r2] = enc(s1, st1);
-        assert(r2 !== undefined);
-    },
-    // Three-symbol word [s0, s1, t]: end merges (s0,s1), then create merges (root, t)
-    three_symbol: () => {
-        const [out, storage] = runWord([s1, s0, s0]);
-        assertEq(out, compress(compress(s1, s0), s0));
-        assertEq(storage.length, 2);
-        verifyStorage(storage);
-        // first add: merge of the two decreasing-prefix symbols during end
-        assertEq(storage[0][0], s1);
-        assertEq(storage[0][1], s0);
-        // second add: merge of trie root with terminator
-        assertEq(storage[1][0], compress(s1, s0));
-        assertEq(storage[1][1], s0);
-    },
-    // Output equals the merged value in the last add call
-    output_is_last_add: () => {
-        const [out, storage] = runWord([s1, s0, s1]);
-        assertEq(out, storage.at(-1)[2]);
-    },
-    // Stack is empty after flush; storage is preserved
-    state_reset: () => {
-        const st1 = enc(s0, initial)[1];
-        const [, st2] = enc(s0, st1);
-        assertEq(st2[1].length, 0);
-        assertEq(st2[0].length, 1);
-    },
-    // Storage grows across consecutive words (not wiped on flush)
-    storage_accumulates: () => {
-        const st1 = enc(s0, initial)[1];
-        const st2 = enc(s1, st1)[1]; // flush [s0, s1]
-        const st3 = enc(s0, st2)[1];
-        const [, st4] = enc(s0, st3); // flush [s0, s0]
-        assertEq(st4[0].length, 2);
-        verifyStorage(st4[0]);
-    },
-    // Two consecutive words encode independently and correctly
-    two_words: () => {
-        const st1 = enc(s0, initial)[1];
-        const [r1, st2] = enc(s1, st1);
-        assertEq(r1, compress(s0, s1));
-        const st3 = enc(s0, st2)[1];
-        const [r2] = enc(s0, st3);
-        assertEq(r2, compress(s0, s0));
-    },
-    // Different words produce different hashes
-    non_commutative: () => {
-        const [out1] = runWord([s0, s1]);
-        const [out2] = runWord([s1, s0, s1]);
-        assert(out1 !== out2);
-    },
-    // Trie-internal merges have isSymbol=false; only the terminal merge has isSymbol=true
-    isSymbol_terminal_only: () => {
-        const [, storage] = runWord([s1, s0, s0]);
-        assertEq(storage[0][3], false); // Patricia trie merge
-        assertEq(storage[1][3], true); // terminal compress(root, t)
-    },
-    // Single-step word: no trie merges, exactly one isSymbol=true
-    isSymbol_min_word: () => {
-        const [, storage] = runWord([s0, s0]);
-        assertEq(storage.length, 1);
-        assertEq(storage[0][3], true);
-    },
-};

package/fjs/sul/level/literal/module.f.d.ts

@@ -1,64 +0,0 @@
-/**
- * Bijective encoding between words of level-k symbols and single symbols of level k+1,
- * for the first three literal SUL levels.
- *
- * @module
- */
-import { type Vec } from '../../../types/bit_vec/module.f.ts';
-import type { Func } from '../../../types/function/module.f.ts';
-import { type Equal, type StateScan } from '../../../types/function/operator/module.f.ts';
-import { type List } from '../../../types/list/module.f.ts';
-export declare const symbolToString: (s: bigint) => string;
-export type Word = readonly bigint[];
-export declare const wordToString: (word: List<bigint>) => string;
-export declare const wordEqual: Equal<List<bigint>>;
-/**
- * Streaming encoder state: `[last, part]`.
- * - `last` — the most recently consumed input symbol, or `undefined` before any symbol is seen.
- * - `part` — accumulated index offset from the decreasing prefix consumed so far.
- */
-export type EncodeState = readonly [bigint | undefined, bigint];
-/** Initial encoder state: no symbols seen, zero offset. */
-export declare const emptyEncodeState: EncodeState;
-/**
- * A literal SUL level with finite alphabet `[0, n)`.
- */
-export type Level = {
-    /** Number of valid words whose first symbol is ≤ `i`. */
-    readonly sum: (i: bigint) => bigint;
-    /** Inverse of {@link Level.encode}: restores the complete word from a symbol. */
-    readonly decode: (i: bigint) => List<bigint>;
-    /** Streaming encoder: processes one input symbol at a time, emitting an output symbol only
-     *  when the terminating symbol `t >= last` arrives. */
-    readonly encode: StateScan<bigint, EncodeState, bigint | undefined>;
-};
-/**
- * Creates a {@link Level} for alphabet size `n = 2^e + 1`.
- *
- * The first three levels for a tree starting from a binary alphabet:
- *
- * | `e`  | `n`    |
- * |------|--------|
- * | `0`  | `2`    |
- * | `2`  | `5`    |
- * | `7`  | `0x81` |
- *
- * @param e `log2(n - 1)`
- */
-export declare const level: (e: bigint) => Level;
-/** Combined encoder state for the three-level literal pipeline (L1 → L2 → L3). */
-export type PipelineState = readonly [EncodeState, EncodeState, EncodeState];
-/** Initial state for the three-level literal pipeline. */
-export declare const emptyPipelineState: PipelineState;
-/**
- * Advances the three-level literal pipeline by one bit.
- * Returns a level-3 symbol whenever the pipeline emits, otherwise `undefined`.
- */
-export declare const pipelineStep: StateScan<bigint, PipelineState, bigint | undefined>;
-export type LiteralToVec = Func<bigint, Vec>;
-/** Decodes a level-1 symbol to its canonical MSB bit vector. */
-export declare const literal1ToVec: LiteralToVec;
-/** Decodes a level-2 symbol to its canonical MSB bit vector (via level-1 decoding). */
-export declare const literal2ToVec: LiteralToVec;
-/** Decodes a level-3 symbol to its canonical MSB bit vector (via level-2 and level-1 decoding). */
-export declare const literal3ToVec: LiteralToVec;

package/fjs/sul/level/literal/module.f.js

@@ -1,88 +0,0 @@
-/**
- * Bijective encoding between words of level-k symbols and single symbols of level k+1,
- * for the first three literal SUL levels.
- *
- * @module
- */
-import { log2 } from '../../../types/bigint/module.f.js';
-import { msb, vec } from '../../../types/bit_vec/module.f.js';
-import { strictEqual } from '../../../types/function/operator/module.f.js';
-import { equal, map } from '../../../types/list/module.f.js';
-import { join } from '../../../types/string/module.f.js';
-export const symbolToString = (s) => s.toString(16);
-export const wordToString = (word) => join(',')(map(symbolToString)(word));
-export const wordEqual = equal(strictEqual);
-/** Initial encoder state: no symbols seen, zero offset. */
-export const emptyEncodeState = [undefined, 0n];
-/**
- * Creates a {@link Level} for alphabet size `n = 2^e + 1`.
- *
- * The first three levels for a tree starting from a binary alphabet:
- *
- * | `e`  | `n`    |
- * |------|--------|
- * | `0`  | `2`    |
- * | `2`  | `5`    |
- * | `7`  | `0x81` |
- *
- * @param e `log2(n - 1)`
- */
-export const level = (e) => {
-    // m = n - 1
-    const m = 1n << e;
-    const n = m + 1n;
-    // k = n - 2
-    const k = m - 1n;
-    // m2 = 2 * m
-    const m2 = m << 1n;
-    const e1 = e + 1n;
-    const sum = (i) => (m2 << i) + i - k;
-    const decode = (i) => () => {
-        const r = log2((i + k) >> e1);
-        const s0 = sum(r) > i ? r : r + 1n;
-        const s1 = i - sum(s0) + n;
-        return s1 >= s0 ? [s0, s1] : {
-            first: s0,
-            tail: decode(i - sum(s0 - 1n))
-        };
-    };
-    return {
-        sum,
-        decode,
-        encode: (i, [last, part]) => last === undefined ? [undefined, [i, 0n]] :
-            last > i ? [undefined, [i, part + sum(last - 1n)]] :
-                [part + sum(last) + i - n, emptyEncodeState]
-    };
-};
-const l1 = level(0n);
-const l2 = level(2n);
-const l3 = level(7n);
-/** Initial state for the three-level literal pipeline. */
-export const emptyPipelineState = [emptyEncodeState, emptyEncodeState, emptyEncodeState];
-/**
- * Advances the three-level literal pipeline by one bit.
- * Returns a level-3 symbol whenever the pipeline emits, otherwise `undefined`.
- */
-export const pipelineStep = (bit, [l1s, l2s, l3s]) => {
-    const [l1Out, newL1s] = l1.encode(bit, l1s);
-    if (l1Out === undefined)
-        return [undefined, [newL1s, l2s, l3s]];
-    const [l2Out, newL2s] = l2.encode(l1Out, l2s);
-    if (l2Out === undefined)
-        return [undefined, [newL1s, newL2s, l3s]];
-    const [l3Out, newL3s] = l3.encode(l2Out, l3s);
-    return [l3Out, [newL1s, newL2s, newL3s]];
-};
-const vec1 = vec(1n);
-const { listToVec } = msb;
-const literalToVec = (prior, e) => {
-    const m = map(prior);
-    const { decode } = level(e);
-    return literal => listToVec(m(decode(literal)));
-};
-/** Decodes a level-1 symbol to its canonical MSB bit vector. */
-export const literal1ToVec = literalToVec(vec1, 0n);
-/** Decodes a level-2 symbol to its canonical MSB bit vector (via level-1 decoding). */
-export const literal2ToVec = literalToVec(literal1ToVec, 2n);
-/** Decodes a level-3 symbol to its canonical MSB bit vector (via level-2 and level-1 decoding). */
-export const literal3ToVec = literalToVec(literal2ToVec, 7n);