functionalscript 0.37.0 → 0.39.0

package/README.md

@@ -60,7 +60,7 @@ The CAS is also exposed as an [MCP](https://modelcontextprotocol.io/) server so
 claude mcp add cas -- npx functionalscript m
 ```
 
-See [`fs/cas/mcp/README.md`](fs/cas/mcp/README.md) for details on the `cas_add`, `cas_get`, and `cas_list` tools.
+See [`fjs/cas/mcp/README.md`](fjs/cas/mcp/README.md) for details on the `cas_add`, `cas_get`, and `cas_list` tools.
 
 ## Vision
 

package/{fs → fjs}/asn.1/proof.f.js

@@ -1,7 +1,7 @@
 import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { asBase } from "../types/nominal/module.f.js";
 import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet, encodeObjectIdentifier, decodeObjectIdentifier, } from "./module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { assert, assertEq } from '../asserts/module.f.js';
 const { concat, popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const check = (tag, v, rest) => {
@@ -23,9 +23,7 @@ const integerValueCheck = (i, v) => {
         throw `encode: ${asBase(v)}, ${asBase(v0)}`;
     }
     const i0 = decodeInteger(v);
-    if (i !== i0) {
-        throw [i, i0];
-    }
+    assertEq(i, i0, [i, i0]);
 };
 const ch0 = (r, v, rest) => {
     const [r0, rest0] = decode(concat(v)(rest));
@@ -51,24 +49,14 @@ export const proof = {
         const v = vec8(0x13n);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 24n) {
-            throw lx;
-        }
+        assertEq(lx, 24n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [len, x2] = pop8(x1);
-        if (len !== 1n) {
-            throw len;
-        }
+        assertEq(len, 1n);
         const { length: intLen, uint } = unpack(x2);
-        if (intLen !== 8n) {
-            throw intLen;
-        }
-        if (uint !== 0x13n) {
-            throw uint;
-        }
+        assertEq(intLen, 8n);
+        assertEq(uint, 0x13n);
     },
     encode7F: () => {
         const valueLen = 0x7fn << 3n;
@@ -76,24 +64,14 @@ export const proof = {
         const v = vec(valueLen)(value);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 0x81n << 3n) {
-            throw lx;
-        }
+        assertEq(lx, 0x81n << 3n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [len, x2] = pop8(x1);
-        if (len !== 0x7fn) {
-            throw len;
-        }
+        assertEq(len, 0x7fn);
         const { length: intLen, uint } = unpack(x2);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encode80: () => {
         const valueLen = 0x80n << 3n;
@@ -101,28 +79,16 @@ export const proof = {
         const v = vec(valueLen)(value);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 0x83n << 3n) {
-            throw lx;
-        }
+        assertEq(lx, 0x83n << 3n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x81n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x81n);
         const [len, x3] = pop8(x2);
-        if (len !== 0x80n) {
-            throw len;
-        }
+        assertEq(len, 0x80n);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encodeFF: () => {
         const valueLen = 0xffn << 3n;
@@ -134,24 +100,14 @@ export const proof = {
             throw `lx: ${lx}`;
         }
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x81n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x81n);
         const [len, x3] = pop8(x2);
-        if (len !== 0xffn) {
-            throw len;
-        }
+        assertEq(len, 0xffn);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encode103: () => {
         const valueLen = 0x103n << 3n;
@@ -163,32 +119,20 @@ export const proof = {
             throw `lx: ${lx}`;
         }
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x82n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x82n);
         const [len, x3] = pop(16n)(x2);
-        if (len !== 0x103n) {
-            throw len;
-        }
+        assertEq(len, 0x103n);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     ed: [
         () => {
             const tag = integer;
             const v = vec(0x10n)(0x8234n);
-            if (asBase(v) !== 0x8234n) {
-                throw asBase(v).toString(16);
-            }
+            assertEq(asBase(v), 0x8234n, asBase(v).toString(16));
             check(integer, v, empty);
         },
         {
@@ -297,16 +241,10 @@ export const proof = {
         // bitString (0x03) is not in SupportedRecord, exercises the default case in rawToRecord
         const raw = encodeRaw([0x03n, vec8(0x42n)]);
         const [decoded, rest] = decode(raw);
-        if (!isVec(decoded)) {
-            throw 'expected UnsupportedRecord (Vec)';
-        }
-        if (rest !== empty) {
-            throw 'expected empty rest';
-        }
+        assert(isVec(decoded), 'expected UnsupportedRecord (Vec)');
+        assertEq(rest, empty, 'expected empty rest');
         // Re-encoding an UnsupportedRecord returns it unchanged (it is already the TLV bytes)
-        if (encode(decoded) !== raw) {
-            throw 'encode should round-trip UnsupportedRecord';
-        }
+        assertEq(encode(decoded), raw, 'encode should round-trip UnsupportedRecord');
     },
     raw: [
         () => {

package/fjs/asserts/module.f.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Assertion helpers for runtime checks and compile-time type-level tests.
+ *
+ * @module
+ */
+/**
+ * Marks a code path as unimplemented. Always throws.
+ */
+export declare const todo: () => never;
+/**
+ * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
+ *
+ * Narrows `v` to `true` via `asserts v`, so callers can rely on the
+ * condition holding for the rest of the enclosing scope.
+ */
+export declare const assert: (v: boolean, msg?: unknown) => asserts v;
+/**
+ * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ */
+export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
+/**
+ * Compile-time-only check: a type resolves only if it is exactly `true`.
+ * Used to assert type-level properties without any runtime cost, e.g.
+ * `type _ = Assert<Equal<A, B>>`.
+ */
+export type Assert<T extends true> = T;
+/**
+ * Asserts that `a` is neither `null` nor `undefined` and returns it,
+ * narrowed to `T`.
+ *
+ * Use this to chain directly off a call that may return a nullish value,
+ * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
+ * exists, prefer `assert(a !== null && a !== undefined)` instead.
+ */
+export declare const assertNotNullish: <T>(a: T | null | undefined, msg?: unknown) => T;

package/fjs/asserts/module.f.js

@@ -0,0 +1,39 @@
+/**
+ * Assertion helpers for runtime checks and compile-time type-level tests.
+ *
+ * @module
+ */
+/**
+ * Marks a code path as unimplemented. Always throws.
+ */
+export const todo = () => { throw 'not implemented'; };
+/**
+ * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
+ *
+ * Narrows `v` to `true` via `asserts v`, so callers can rely on the
+ * condition holding for the rest of the enclosing scope.
+ */
+export const assert = (v, msg = 'assertion failed') => {
+    if (!v)
+        throw msg;
+};
+/**
+ * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ */
+export const assertEq = (...x) => {
+    const [a, b] = x;
+    assert(a === b, x);
+};
+/**
+ * Asserts that `a` is neither `null` nor `undefined` and returns it,
+ * narrowed to `T`.
+ *
+ * Use this to chain directly off a call that may return a nullish value,
+ * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
+ * exists, prefer `assert(a !== null && a !== undefined)` instead.
+ */
+export const assertNotNullish = (a, msg) => {
+    assert(a !== null && a !== undefined, msg);
+    return a;
+};

package/fjs/asserts/proof.f.d.ts

@@ -0,0 +1,11 @@
+export declare const proof: {
+    assertPassesOnTrue: () => void;
+    assertEqPassesOnEqual: () => void;
+    throw: {
+        assertEqThrowsOnUnequal: () => void;
+        assertEqThrowsOnUnequal3: () => void;
+        assertThrowsDefaultMsg: () => void;
+        assertThrowsCustomMsg: () => void;
+        todoThrows: () => never;
+    };
+};

package/fjs/asserts/proof.f.js

@@ -0,0 +1,18 @@
+import { assert, assertEq, todo } from './module.f.js';
+export const proof = {
+    assertPassesOnTrue: () => {
+        assert(true);
+        assert(true, 'with message');
+    },
+    assertEqPassesOnEqual: () => {
+        assertEq(1, 1);
+        assertEq('x', 'x');
+    },
+    throw: {
+        assertEqThrowsOnUnequal: () => assertEq(1, 2),
+        assertEqThrowsOnUnequal3: () => assertEq(1, 2, "message"),
+        assertThrowsDefaultMsg: () => assert(false),
+        assertThrowsCustomMsg: () => assert(false, 'oops'),
+        todoThrows: () => todo(),
+    },
+};

package/{fs → fjs}/base_n/proof.f.js

@@ -25,67 +25,43 @@ const bigSampleHex = `f`.repeat(Number(maxLength >> 2n));
 export const proof = {
     encodeEmpty: () => {
         const s = hex.vecToString(empty);
-        if (s !== '') {
-            throw [s];
-        }
+        assertEq(s, '', [s]);
     },
     encodeAligned: () => {
         // Two 4-bit chunks → two hex digits
         const s = hex.vecToString(vec(8n)(0xa5n));
-        if (s !== 'a5') {
-            throw [s];
-        }
+        assertEq(s, 'a5', [s]);
     },
     encodeUnaligned: () => {
         // 6 bits → first 4-bit chunk + a 2-bit tail that popFront pads with
         // trailing zeros (the standard `popFront` behaviour the codec inherits).
         const s = hex.vecToString(vec(6n)(41n));
-        if (s !== 'a4') {
-            throw [s];
-        }
+        assertEq(s, 'a4', [s]);
     },
     decodeEmpty: () => {
         const v = hex.stringToVec('');
-        if (v !== empty) {
-            throw [v];
-        }
+        assertEq(v, empty, [v]);
     },
     decodeRoundTrip: () => {
         const v = hex.stringToVec('ab');
-        if (v !== vec(8n)(0xabn)) {
-            throw [v];
-        }
+        assertEq(v, vec(8n)(0xabn), [v]);
     },
     decodeInvalid: () => {
-        if (hex.stringToVec('z') !== null) {
-            throw 'invalid char should return null';
-        }
-        if (hex.stringToVec('aZ') !== null) {
-            throw 'mixed invalid char should return null';
-        }
+        assertEq(hex.stringToVec('z'), null, 'invalid char should return null');
+        assertEq(hex.stringToVec('aZ'), null, 'mixed invalid char should return null');
     },
     normalizeHit: () => {
         // 'A' lowercases to 'a' — same vector as the lowercase input.
         const a = cb32.stringToVec('A');
         const b = cb32.stringToVec('a');
-        if (a !== b) {
-            throw [a, b];
-        }
+        assertEq(a, b, [a, b]);
         // Crockford folds: i,l → 1 and o → 0.
-        if (cb32.stringToVec('I') !== cb32.stringToVec('1')) {
-            throw 'I→1';
-        }
-        if (cb32.stringToVec('l') !== cb32.stringToVec('1')) {
-            throw 'l→1';
-        }
-        if (cb32.stringToVec('o') !== cb32.stringToVec('0')) {
-            throw 'o→0';
-        }
+        assertEq(cb32.stringToVec('I'), cb32.stringToVec('1'), 'I→1');
+        assertEq(cb32.stringToVec('l'), cb32.stringToVec('1'), 'l→1');
+        assertEq(cb32.stringToVec('o'), cb32.stringToVec('0'), 'o→0');
     },
     normalizeMiss: () => {
-        if (cb32.stringToVec('u') !== null) {
-            throw 'unknown char should return null';
-        }
+        assertEq(cb32.stringToVec('u'), null, 'unknown char should return null');
     },
     // Decodes a 1 Mibit hex string. With the O(n log n) `listToVec` builder this
     // runs in well under a second (was ~13 s node / ~43 s bun under the old

package/{fs → fjs}/basen/base64/proof.f.d.ts

@@ -9,6 +9,7 @@ export declare const proof: {
     validPadding: () => void;
     knownVectors: () => void;
     decodeOverflow: () => void;
+    decodePaddedTailRejections: () => void;
     encodeAtMaxLengthSucceeds: () => void;
     decodeAtMaxLengthSucceeds: () => void;
     encodeLargeVecIsSlow: () => void;

package/{fs → fjs}/basen/base64/proof.f.js

@@ -83,6 +83,20 @@ export const proof = {
         const oversized = 'A'.repeat(174_764);
         assertEq(decode(oversized), null);
     },
+    decodePaddedTailRejections: () => {
+        // These all take the padded branch of `decode` (`padChars > 0`,
+        // i.e. the `head`/`lastChunk` split), unlike `decodeOverflow` above
+        // which takes the unpadded fast path. An invalid character before
+        // the final char must be rejected via the `head` decode...
+        assertEq(decode('!A=='), null);
+        // ...and an invalid final character (the one holding the padding
+        // bits) must be rejected via the last-character decode.
+        assertEq(decode('A!=='), null);
+        // Same as `decodeOverflow`, but with a padded tail so it's the
+        // padded branch that measures the result against `maxLength` and
+        // rejects it.
+        assertEq(decode('A'.repeat(174_764) + '='), null);
+    },
     encodeAtMaxLengthSucceeds: () => {
         // A `maxLength`-sized vector's trailing partial 6-bit chunk is
         // left-padded by `vecToString` itself (see `baseN`), so `encode`
@@ -99,7 +113,7 @@ export const proof = {
         check('A'.repeat(174_763) + '=', vec(maxLength)(0n));
     },
     // Regression guard: `encode` used to be quadratic in the input size, not
-    // linear. `baseN`'s `vecToString` (`fs/base_n/module.f.ts`) popped one
+    // linear. `baseN`'s `vecToString` (`fjs/base_n/module.f.ts`) popped one
     // 6-bit chunk off the front at a time via `popFront`, and each `popFront`
     // re-masked the entire remaining bigint through `vec()`'s `m & ui` —
     // O(remaining length) — so encoding a vector of `n` bits cost O(n²). A

package/{fs → fjs}/basen/cbase32/proof.f.js

@@ -1,26 +1,19 @@
 import { empty, vec } from "../../types/bit_vec/module.f.js";
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
 const check5x = (s, v) => {
     const sr = vec5xToCBase32(v);
-    if (sr !== s) {
-        throw [sr, s];
-    }
+    assertEq(sr, s, [sr, s]);
     const vr = cBase32ToVec5x(s);
-    if (vr !== v) {
-        throw [vr, v];
-    }
+    assertEq(vr, v, [vr, v]);
     //
     check(`${s}g`, v);
 };
 const check = (s, v) => {
     const sr = vecToCBase32(v);
-    if (sr !== s) {
-        throw [sr, s];
-    }
+    assertEq(sr, s, [sr, s]);
     const vr = cBase32ToVec(s);
-    if (vr !== v) {
-        throw [vr, v];
-    }
+    assertEq(vr, v, [vr, v]);
 };
 export const proof = {
     roundtrip5x: () => {
@@ -50,40 +43,20 @@ export const proof = {
     unalignedBits: () => {
         const v = vec(1n)(1n);
         const cr = vec5xToCBase32(v);
-        if (cr !== "g") {
-            throw ['g', cr];
-        }
+        assertEq(cr, "g", ['g', cr]);
     },
     caseInsensitive: () => {
-        if (cBase32ToVec5x("A") !== cBase32ToVec5x("a")) {
-            throw 'case-insensitive expected';
-        }
-        if (cBase32ToVec5x("I") !== cBase32ToVec5x("1")) {
-            throw 'i maps to 1';
-        }
-        if (cBase32ToVec5x("l") !== cBase32ToVec5x("1")) {
-            throw 'l maps to 1';
-        }
-        if (cBase32ToVec5x("o") !== cBase32ToVec5x("0")) {
-            throw 'o maps to 0';
-        }
-        if (cBase32ToVec5x("u") !== null) {
-            throw 'should error on invalid character';
-        }
+        assertEq(cBase32ToVec5x("A"), cBase32ToVec5x("a"), 'case-insensitive expected');
+        assertEq(cBase32ToVec5x("I"), cBase32ToVec5x("1"), 'i maps to 1');
+        assertEq(cBase32ToVec5x("l"), cBase32ToVec5x("1"), 'l maps to 1');
+        assertEq(cBase32ToVec5x("o"), cBase32ToVec5x("0"), 'o maps to 0');
+        assertEq(cBase32ToVec5x("u"), null, 'should error on invalid character');
     },
     unterminated: () => {
         // No sentinel `1` bit → invalid; must return null, not loop forever.
-        if (cBase32ToVec("") !== null) {
-            throw 'empty must be null';
-        }
-        if (cBase32ToVec("0") !== null) {
-            throw 'single zero symbol must be null';
-        }
-        if (cBase32ToVec("00") !== null) {
-            throw 'all-zero symbols must be null';
-        }
-        if (cBase32ToVec("o") !== null) {
-            throw 'o (maps to 0) must be null';
-        }
+        assertEq(cBase32ToVec(""), null, 'empty must be null');
+        assertEq(cBase32ToVec("0"), null, 'single zero symbol must be null');
+        assertEq(cBase32ToVec("00"), null, 'all-zero symbols must be null');
+        assertEq(cBase32ToVec("o"), null, 'o (maps to 0) must be null');
     }
 };

package/fjs/bnf/data/module.f.d.ts

@@ -0,0 +1,52 @@
+import { type Rule as FRule } from '../module.f.ts';
+import { type StringMap } from '../../types/object/module.f.ts';
+/**
+ * Encoded terminal range value used by BNF data rules.
+ *
+ * The same as the functional TerminalRange.
+ */
+export type TerminalRange = number;
+/**
+ * Ordered list of grammar rule names.
+ */
+export type Sequence = readonly string[];
+/** A variant of rule names. */
+export type Variant = StringMap<string, string>;
+/**
+ * Grammar rule definition.
+ *
+ * It can be one of:
+ * - a tagged variant map,
+ * - a sequence of referenced rule names,
+ * - an encoded terminal range.
+ */
+export type Rule = Variant | Sequence | TerminalRange;
+/** The full grammar */
+export type RuleSet = Readonly<Record<string, Rule>>;
+/**
+ * Whether a rule can match empty input: `undefined` if it never can, `true`
+ * if it can with no tag (a nullable sequence), or the tag of the nullable
+ * variant branch.
+ */
+export type EmptyTag = string | true | undefined;
+type EmptyTagMap = StringMap<string, EmptyTag>;
+/**
+ * Computes, for every rule in the set, whether it can match empty input, by
+ * the standard nullable-set fixpoint: a sequence is nullable iff all of its
+ * items are (AND semantics), a variant iff at least one branch is (its tag is
+ * that branch's). Rules may reference each other cyclically (e.g. a `repeat`
+ * rule referring to itself), so this starts every rule as non-nullable and
+ * relaxes every rule, one round at a time, until a full round changes
+ * nothing. A round only ever grows the nullable set or moves a variant's
+ * chosen tag to a later (still-nullable) branch, both bounded, so this always
+ * terminates — but a rule's tag can still change for rounds *after* its own
+ * nullable/non-nullable status has already settled, while a cyclic
+ * dependency's tag catches up, so a fixed round count isn't enough.
+ */
+export declare const emptyTagMap: (ruleSet: RuleSet) => EmptyTagMap;
+/**
+ * Converts a functional grammar rule into serializable BNF data and returns
+ * the generated rule set with the entry rule identifier.
+ */
+export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+export {};

package/{fs → fjs}/bnf/data/module.f.js

@@ -5,15 +5,65 @@
  * This module is the pure, parser-agnostic substrate: it defines the
  * {@link RuleSet} data form (`Rule = Variant | Sequence | TerminalRange`) and
  * converts a functional grammar into it. The automaton builders that consume a
- * {@link RuleSet} live in their own sibling modules (`fs/bnf/ll1`,
- * `fs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
+ * {@link RuleSet} live in their own sibling modules (`fjs/bnf/ll1`,
+ * `fjs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
  *
  * @module
  */
 import { stringToCodePointList } from '../../text/utf16/module.f.js';
 import { map, toArray } from '../../types/list/module.f.js';
 import { oneEncode, } from '../module.f.js';
-import {} from '../../types/object/module.f.js';
+import { definedEntries } from '../../types/object/module.f.js';
+const emptyTagOf = (map) => (rule) => {
+    if (typeof rule === 'number') {
+        return undefined;
+    }
+    else if (rule instanceof Array) {
+        return rule.every(item => map[item] !== undefined) ? true : undefined;
+    }
+    else {
+        let tag = undefined;
+        for (const [k, item] of definedEntries(rule)) {
+            if (map[item] !== undefined) {
+                tag = k;
+            }
+        }
+        return tag;
+    }
+};
+const emptyTagStep = (ruleSet) => (map) => {
+    let next = map;
+    let changed = false;
+    for (const name in ruleSet) {
+        const tag = emptyTagOf(map)(ruleSet[name]);
+        if (tag !== next[name]) {
+            changed = true;
+        }
+        next = { ...next, [name]: tag };
+    }
+    return [next, changed];
+};
+/**
+ * Computes, for every rule in the set, whether it can match empty input, by
+ * the standard nullable-set fixpoint: a sequence is nullable iff all of its
+ * items are (AND semantics), a variant iff at least one branch is (its tag is
+ * that branch's). Rules may reference each other cyclically (e.g. a `repeat`
+ * rule referring to itself), so this starts every rule as non-nullable and
+ * relaxes every rule, one round at a time, until a full round changes
+ * nothing. A round only ever grows the nullable set or moves a variant's
+ * chosen tag to a later (still-nullable) branch, both bounded, so this always
+ * terminates — but a rule's tag can still change for rounds *after* its own
+ * nullable/non-nullable status has already settled, while a cyclic
+ * dependency's tag catches up, so a fixed round count isn't enough.
+ */
+export const emptyTagMap = (ruleSet) => {
+    const step = emptyTagStep(ruleSet);
+    const relax = (map) => {
+        const [next, changed] = step(map);
+        return changed ? relax(next) : next;
+    };
+    return relax({});
+};
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {

package/{fs → fjs}/bnf/data/proof.f.d.ts

@@ -3,5 +3,6 @@ export declare const proof: {
     rangeEncode: () => void;
     toData: (() => void)[];
     variantTest: () => void;
+    emptyTagMap: (() => void)[];
     example: () => void;
 };