functionalscript 0.44.0 → 0.46.0

package/README.md

@@ -5,13 +5,15 @@
 FunctionalScript is a safe, purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
-- [JSON](https://en.wikipedia.org/wiki/JSON) and [JSON5](https://json5.org/) as subsets of JavaScript.
-  JSON is also a subset of FunctionalScript.
+- [JSON](https://en.wikipedia.org/wiki/JSON) and [JSON5](https://json5.org/) as subsets of JavaScript values.
+  JSON is also a subset of FunctionalScript values.
 - [asm.JS](https://en.wikipedia.org/wiki/Asm.js) (a precursor of [WebAssembly](https://en.wikipedia.org/wiki/WebAssembly)),
   as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
-[A working draft of the FunctionalScript specification](./todo/lang/README.md).
+[The FunctionalScript specification](./spec/README.md) describes the language
+the compiler accepts today; features not implemented yet are in
+[`spec/todo/`](./spec/todo/README.md).
 
 Learn more about
 

package/fjs/asn.1/module.f.mjs

@@ -19,6 +19,7 @@ import {
     vec,
     vec8,
 } from '../types/bit_vec/module.f.mjs'
+import { assert } from '../asserts/module.f.mjs'
 import { identity } from '../types/function/module.f.mjs'
 import { max } from '../types/function/compare/module.f.mjs'
 import { encode as b128encode, decode as b128decode } from '../basen/base128/module.f.mjs'
@@ -65,7 +66,13 @@ const parsedTagEncode = ([classPc, number]) => {
 /** @type {(v: Vec) => readonly[_ParsedTag, Vec]} */
 const parsedTagDecode = v => {
     const [firstByte, rest] = pop8(v)
-    const classPc = /** @type {_ClassPc} */(firstByte & classPcMask)
+    const classPc = firstByte & classPcMask
+    // `classPcMask` is the top three bits, so the result is one of eight values;
+    // the assert is what narrows `bigint` to `_ClassPc`.
+    assert(classPc === 0b000_00000n || classPc === 0b001_00000n
+        || classPc === 0b010_00000n || classPc === 0b011_00000n
+        || classPc === 0b100_00000n || classPc === 0b101_00000n
+        || classPc === 0b110_00000n || classPc === 0b111_00000n, classPc)
     const firstByteNumber = firstByte & tagNumberMask
     const [number, rest1] = firstByteNumber < tagNumberMask
         ? [firstByteNumber, rest]

package/fjs/asn.1/proof.f.d.mts

@@ -1,3 +1,7 @@
+/**
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { SupportedRecord, ObjectIdentifier } from './types.ts'
+ */
 export declare const proof: {
     encodeSmall: () => void;
     encode7F: () => void;
@@ -38,11 +42,22 @@ export declare const proof: {
         integer: () => void;
         sequence: () => void;
         set: () => void;
+        objectIdentifier: () => void;
     };
     objectIdentifier: {
         simple: () => void;
         withArc: () => void;
     };
     unknownTag: () => void;
+    tagClass: {
+        universalPrimitive: () => void;
+        universalConstructed: () => void;
+        applicationPrimitive: () => void;
+        applicationConstructed: () => void;
+        contextPrimitive: () => void;
+        contextConstructed: () => void;
+        privatePrimitive: () => void;
+        privateConstructed: () => void;
+    };
     raw: (() => void)[];
 };

package/fjs/asn.1/proof.f.mjs

@@ -1,6 +1,9 @@
-/** @import { Vec } from '../types/bit_vec/types.ts' */
-import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from '../types/bit_vec/module.f.mjs'
+/**
+ * @import { Vec } from '../types/bit_vec/types.ts'
+ * @import { SupportedRecord, ObjectIdentifier } from './types.ts'
+ */
 
+import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from '../types/bit_vec/module.f.mjs'
 import { asBase } from '../types/nominal/module.f.mjs'
 
 import {
@@ -15,10 +18,10 @@ import {
     octetString,
     boolean,
     constructedSet,
+    objectIdentifier,
     encodeObjectIdentifier,
     decodeObjectIdentifier,
 } from './module.f.mjs'
-/** @import { SupportedRecord, ObjectIdentifier } from './types.ts' */
 
 import { assert, assertEq } from '../asserts/module.f.mjs'
 
@@ -252,6 +255,15 @@ export const proof = {
                 ])
             )
         },
+        objectIdentifier: () => {
+            // exercises the objectIdentifier case in recordToRaw/rawToRecord
+            // via the generic encode/decode dispatch (the objectIdentifier
+            // tests below only call encodeObjectIdentifier/decodeObjectIdentifier
+            // directly, never through decode()).
+            /** @type {SupportedRecord} */
+            const r = [objectIdentifier, [1n, 2n, 840n, 113549n]]
+            ch0(r, encode(r), empty)
+        },
     },
     objectIdentifier: {
         simple: () => {
@@ -284,6 +296,22 @@ export const proof = {
         // Re-encoding an UnsupportedRecord returns it unchanged (it is already the TLV bytes)
         assertEq(encode(decoded), raw, 'encode should round-trip UnsupportedRecord')
     },
+    // parsedTagDecode narrows the top three bits of the tag's first byte
+    // (class + primitive/constructed) to one of exactly eight values via an
+    // 8-way `||` assert. Every other test in this file only ever exercises
+    // the universal-primitive tag (top bits 000), so each of the other seven
+    // comparisons has never had a case where it's the one that turns the
+    // assert true — one round trip per class×P/C combination covers them all.
+    tagClass: {
+        universalPrimitive: () => check(0x02n, vec8(0x42n), empty),
+        universalConstructed: () => check(0x22n, vec8(0x42n), empty),
+        applicationPrimitive: () => check(0x42n, vec8(0x42n), empty),
+        applicationConstructed: () => check(0x62n, vec8(0x42n), empty),
+        contextPrimitive: () => check(0x82n, vec8(0x42n), empty),
+        contextConstructed: () => check(0xA2n, vec8(0x42n), empty),
+        privatePrimitive: () => check(0xC2n, vec8(0x42n), empty),
+        privateConstructed: () => check(0xE2n, vec8(0x42n), empty),
+    },
     raw: [
         () => {
             const e = encodeRaw([0x00n, vec8(0x23n)])

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

@@ -24,6 +24,20 @@ export declare const assert: (v: boolean, msg?: unknown) => asserts v;
  * @type {<T>(...x: readonly[T, T, unknown?]) => void}
  */
 export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
+/**
+ * Asserts that `a` and `b` are structurally the same — equal leaves under the
+ * same shape, property order irrelevant — throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ *
+ * This is the assertion to reach for when comparing two independently
+ * constructed values. `assertEq` is `===`, so it only ever answers "the same
+ * reference?" for objects, which is why proofs fell back to comparing
+ * `JSON.stringify` output; see `types/object/structurally_same/README.md` for
+ * why that is the wrong question and what this one does *not* cover.
+ *
+ * @type {(...x: readonly[unknown, unknown, unknown?]) => void}
+ */
+export declare const assertStructurallySame: (...x: readonly [unknown, unknown, unknown?]) => void;
 /**
  * Asserts that `a` is neither `null` nor `undefined` and returns it,
  * narrowed to `T`.

package/fjs/asserts/module.f.mjs

@@ -4,6 +4,8 @@
  * @module
  */
 
+import { structurallySame } from '../types/object/structurally_same/module.f.mjs'
+
 /**
  * Marks a code path as unimplemented. Always throws.
  * @type {() => never}
@@ -33,6 +35,24 @@ export const assertEq = (...x) => {
     assert(a === b, x)
 }
 
+/**
+ * Asserts that `a` and `b` are structurally the same — equal leaves under the
+ * same shape, property order irrelevant — throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ *
+ * This is the assertion to reach for when comparing two independently
+ * constructed values. `assertEq` is `===`, so it only ever answers "the same
+ * reference?" for objects, which is why proofs fell back to comparing
+ * `JSON.stringify` output; see `types/object/structurally_same/README.md` for
+ * why that is the wrong question and what this one does *not* cover.
+ *
+ * @type {(...x: readonly[unknown, unknown, unknown?]) => void}
+ */
+export const assertStructurallySame = (...x) => {
+    const [a, b] = x
+    assert(structurallySame(a, b), x)
+}
+
 /**
  * Asserts that `a` is neither `null` nor `undefined` and returns it,
  * narrowed to `T`.

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

@@ -1,9 +1,12 @@
 export declare const proof: {
     assertPassesOnTrue: () => void;
     assertEqPassesOnEqual: () => void;
+    assertStructurallySamePassesOnSame: () => void;
     throw: {
         assertEqThrowsOnUnequal: () => void;
         assertEqThrowsOnUnequal3: () => void;
+        assertStructurallySameThrowsOnDifferent: () => void;
+        assertStructurallySameThrowsOnDifferent3: () => void;
         assertThrowsDefaultMsg: () => void;
         assertThrowsCustomMsg: () => void;
         todoThrows: () => never;

package/fjs/asserts/proof.f.mjs

@@ -1,4 +1,9 @@
-import { assert, assertEq, todo } from './module.f.mjs'
+import {
+    assert,
+    assertEq,
+    assertStructurallySame,
+    todo,
+} from './module.f.mjs'
 
 export const proof = {
     assertPassesOnTrue: () => {
@@ -9,9 +14,18 @@ export const proof = {
         assertEq(1, 1)
         assertEq('x', 'x')
     },
+    assertStructurallySamePassesOnSame: () => {
+        // the case `assertEq` cannot do: two separately built values
+        assertStructurallySame({ a: 1, b: [2, { c: 3 }] }, { b: [2, { c: 3 }], a: 1 })
+        assertStructurallySame(1, 1, 'with message')
+    },
     throw: {
         assertEqThrowsOnUnequal: () => assertEq(1, 2),
         assertEqThrowsOnUnequal3: () => assertEq(1, 2, "message"),
+        assertStructurallySameThrowsOnDifferent:
+            () => assertStructurallySame({ a: 1 }, { a: 2 }),
+        assertStructurallySameThrowsOnDifferent3:
+            () => assertStructurallySame({ a: 1 }, { a: 2 }, 'message'),
         assertThrowsDefaultMsg: () => assert(false),
         assertThrowsCustomMsg: () => assert(false, 'oops'),
         todoThrows: () => todo(),

package/fjs/basen/base128/module.f.mjs

@@ -6,12 +6,27 @@
  * @import { Vec } from '../../types/bit_vec/types.ts'
  */
 
+import { mask } from '../../types/bigint/module.f.mjs'
 import { vec8, msb, empty } from '../../types/bit_vec/module.f.mjs'
 
 const { concat, popFront } = msb
 
 const pop8 = popFront(8n)
 
+/**
+ * The varint layout both halves below agree on, stated once: each byte carries
+ * seven payload bits in its low end, and its top bit is set on every byte
+ * except the last.
+ *
+ * `encode` and `decode` are exact inverses, so the two must agree bit for bit.
+ * The masks are derived from `payloadBits` rather than written as `0x7f` and
+ * `0x80` so that agreement is structural rather than a pair of literals a
+ * reader has to match up.
+ */
+const payloadBits = 7n
+const payloadMask = mask(payloadBits)
+const continuationFlag = 1n << payloadBits
+
 /**
  * Encodes a bigint into an MSB Base128 vector.
  *
@@ -22,10 +37,12 @@ export const encode = uint => {
     /** @type {Vec} */
     let result = empty
     while (true) {
-        const item = uint & 0x7Fn
-        const flag = result === empty ? 0n : 0x80n
+        const item = uint & payloadMask
+        // The first byte built is the last one emitted, so it is the only one
+        // without the continuation flag.
+        const flag = result === empty ? 0n : continuationFlag
         result = concat(vec8(flag | item))(result)
-        uint >>= 7n
+        uint >>= payloadBits
         if (uint === 0n) {
             return result
         }
@@ -42,8 +59,8 @@ export const decode = v => {
     let result = 0n
     while (true) {
         const [byte, rest] = pop8(v)
-        result = (result << 7n) | (byte & 0x7Fn)
-        if (byte < 0x80n) {
+        result = (result << payloadBits) | (byte & payloadMask)
+        if ((byte & continuationFlag) === 0n) {
             return [result, rest]
         }
         v = rest

package/fjs/basen/base128/proof.f.d.mts

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

package/fjs/basen/base128/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { empty, vec, vec8 } from '../../types/bit_vec/module.f.mjs'
 import { asBase } from '../../types/nominal/module.f.mjs'

package/fjs/basen/base64/module.f.mjs

@@ -7,7 +7,7 @@
  * @import { Nullable } from '../../types/nullable/types.ts'
  */
 
-import { msb, length, vec, maxLength } from '../../types/bit_vec/module.f.mjs'
+import { msb, length, vec } from '../../types/bit_vec/module.f.mjs'
 import { baseN } from "../module.f.mjs"
 
 const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
@@ -61,8 +61,12 @@ export const decode = input => {
     const lastChunk = stringToVec(body.slice(body.length - 1))
     if (lastChunk === null) { return null }
 
-    if (length(head) + realBits > maxLength) { return null }
-
+    // No `head`/`realBits` overflow check is needed here: `head` is built
+    // from whole 6-bit chunks, so its length is always a multiple of 6, and
+    // the largest such length `stringToVec` can return without itself
+    // failing is `maxLength - (maxLength % 6)` = `maxLength - 4`. Adding
+    // `realBits` (at most 4, when `padChars` is 1) reaches `maxLength`
+    // exactly and never exceeds it.
     const [kept, pad] = popFront(realBits)(lastChunk)
     // Padding bits must be zero (RFC 4648 §3.5).
     if (pad !== vec(removeBits)(0n)) { return null }

package/fjs/basen/base64/proof.f.d.mts

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 export declare const proof: {
     empty: () => void;
     oneByte: () => void;

package/fjs/basen/base64/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { assertEq } from '../../asserts/module.f.mjs'
 import { empty, vec, repeat, vec8, maxLength } from '../../types/bit_vec/module.f.mjs'
@@ -100,9 +102,10 @@ export const proof = {
         // ...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.
+        // Same as `decodeOverflow`, but with a padded tail: `head` (all
+        // characters but the last) is still over `maxLength` on its own, so
+        // this is rejected by `head`'s own `stringToVec` overflow check, not
+        // by a separate `head`-plus-`realBits` measurement.
         assertEq(decode('A'.repeat(174_764) + '='), null)
     },
     encodeAtMaxLengthSucceeds: () => {

package/fjs/basen/cbase32/proof.f.d.mts

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 export declare const proof: {
     roundtrip5x: () => void;
     roundtrip: () => void;

package/fjs/basen/cbase32/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
+/**
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ */
 
 import { empty, vec } from '../../types/bit_vec/module.f.mjs'
 import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from './module.f.mjs'

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

@@ -3,10 +3,11 @@
  * {@link toData} conversion from the functional grammar.
  *
  * 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 (`fjs/bnf/ll1`,
- * `fjs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
+ * {@link RuleSet} data form (`Rule = Variant | Sequence | TerminalRange |
+ * Repeat`) and converts a functional grammar into it. The automaton builders
+ * that consume a {@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.
  *
  * See `./types.ts` for the type-level API.
  *
@@ -14,11 +15,23 @@
  *
  * @import { DataRule, Rule as FRule, Sequence as FSequence } from '../types.ts'
  * @import { StringMap } from '../../types/object/types.ts'
- * @import { EmptyTag, Rule, RuleSet, Sequence, Variant } from './types.ts'
+ * @import { StringSet } from '../../types/string_set/types.ts'
+ * @import { EmptyTag, Repeat, Rule, RuleSet, Sequence, Variant } from './types.ts'
  */
 import type { Rule as FRule } from '../types.ts';
 import type { StringMap } from '../../types/object/types.ts';
-import type { EmptyTag, Rule, RuleSet } from './types.ts';
+import type { EmptyTag, Repeat, Rule, RuleSet } from './types.ts';
+/**
+ * Whether a data rule is a {@link Repeat}.
+ *
+ * Every rule-dispatch site asks this instead of testing for a string inline, so
+ * the repetition rule kind has exactly one discriminator to move when the
+ * surrounding rule model changes.
+ *
+ * @param {Rule} rule
+ * @returns {rule is Repeat}
+ */
+export declare const isRepeat: (rule: Rule) => rule is Repeat;
 export type _EmptyTagMap = StringMap<EmptyTag>;
 /**
  * Computes, for every rule in the set, whether it can match empty input, by
@@ -38,6 +51,19 @@ export type _EmptyTagMap = StringMap<EmptyTag>;
 export declare const emptyTagMap: (ruleSet: RuleSet) => _EmptyTagMap;
 export type _FRuleMap = StringMap<FRule>;
 export type _NewRule = (m: _FRuleMap) => readonly [_FRuleMap, RuleSet, Rule];
+/**
+ * Rewrites every right-recursive 0-or-more rule of a {@link RuleSet} into a
+ * {@link Repeat}, and drops the rules that the rewrite orphans.
+ *
+ * The dropped rules are the recursive branch and, unless something else still
+ * refers to it, the empty one: both are reachable only through the variant that
+ * the {@link Repeat} replaces. Pruning them keeps the invariant that every rule
+ * of a generated set is reachable from its entry, so the serialized form holds
+ * no dead grammar.
+ *
+ * @type {(ruleSet: RuleSet, entry: string) => RuleSet}
+ */
+export declare const detectRepeat: (ruleSet: RuleSet, entry: string) => RuleSet;
 /**
  * Converts a functional grammar rule into serializable BNF data and returns
  * the generated rule set with the entry rule identifier.

package/fjs/bnf/data/module.f.mjs

@@ -3,10 +3,11 @@
  * {@link toData} conversion from the functional grammar.
  *
  * 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 (`fjs/bnf/ll1`,
- * `fjs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
+ * {@link RuleSet} data form (`Rule = Variant | Sequence | TerminalRange |
+ * Repeat`) and converts a functional grammar into it. The automaton builders
+ * that consume a {@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.
  *
  * See `./types.ts` for the type-level API.
  *
@@ -14,13 +15,27 @@
  *
  * @import { DataRule, Rule as FRule, Sequence as FSequence } from '../types.ts'
  * @import { StringMap } from '../../types/object/types.ts'
- * @import { EmptyTag, Rule, RuleSet, Sequence, Variant } from './types.ts'
+ * @import { StringSet } from '../../types/string_set/types.ts'
+ * @import { EmptyTag, Repeat, Rule, RuleSet, Sequence, Variant } from './types.ts'
  */
 
 import { stringToCodePointList } from '../../text/utf16/module.f.mjs'
 import { map, toArray } from '../../types/list/module.f.mjs'
 import { oneEncode } from '../module.f.mjs'
-import { definedEntries } from '../../types/object/module.f.mjs'
+import { definedEntries, definedValues } from '../../types/object/module.f.mjs'
+import { contains, set } from '../../types/string_set/module.f.mjs'
+
+/**
+ * Whether a data rule is a {@link Repeat}.
+ *
+ * Every rule-dispatch site asks this instead of testing for a string inline, so
+ * the repetition rule kind has exactly one discriminator to move when the
+ * surrounding rule model changes.
+ *
+ * @param {Rule} rule
+ * @returns {rule is Repeat}
+ */
+export const isRepeat = rule => typeof rule === 'string'
 
 /** @typedef {StringMap<EmptyTag>} _EmptyTagMap */
 
@@ -30,6 +45,10 @@ const emptyTagOf = map => rule => {
         return undefined
     } else if (rule instanceof Array) {
         return rule.every(item => map[item] !== undefined) ? true : undefined
+    } else if (isRepeat(rule)) {
+        // Zero repetitions is a match whatever the body does, and it carries no
+        // tag of its own — a repetition is a sequence of items, not a choice.
+        return true
     } else {
         /** @type {EmptyTag} */
         let tag = undefined
@@ -176,6 +195,92 @@ const toDataAdd = map => fr => {
     return [map2, { ...set, [id]: rule }, id]
 }
 
+//
+
+const { fromEntries } = Object
+
+/** @type {(rule: Rule) => Sequence} */
+const refs = rule => {
+    if (typeof rule === 'number') {
+        return []
+    } else if (rule instanceof Array) {
+        return rule
+    } else if (isRepeat(rule)) {
+        return [rule]
+    } else {
+        return definedValues(rule)
+    }
+}
+
+/** @type {(ruleSet: RuleSet) => (visited: StringSet, name: string) => StringSet} */
+const visit = ruleSet => (visited, name) =>
+    contains(name)(visited)
+        ? visited
+        : refs(ruleSet[name]).reduce(visit(ruleSet), set(name)(visited))
+
+/**
+ * Every rule the entry rule can reach, itself included.
+ *
+ * @type {(ruleSet: RuleSet) => (entry: string) => StringSet}
+ */
+const reachable = ruleSet => entry => visit(ruleSet)(null, entry)
+
+/** @type {(rule: Rule) => boolean} */
+const isNone = rule => rule instanceof Array && rule.length === 0
+
+/**
+ * The {@link Repeat} — the name of the item to repeat — that `name` encodes as
+ * right-recursion, or `undefined` when it encodes something else.
+ *
+ * The shape recognized is exactly the unambiguous 0-or-more list: a two-branch
+ * variant whose branches are an empty sequence and `[item, name]`, in either
+ * order. Everything looser stays as it is — an operator-style tree, a separated
+ * list, or a 1-or-more chain all reach `name` again, but their extra items make
+ * the grouping a real choice rather than a list, so folding them into a flat
+ * sequence would discard structure no rule name is left to recover.
+ *
+ * Two further conditions keep the fold sound rather than merely plausible:
+ * `item` must not lead back to `name`, so `name`'s only self-reference is the
+ * tail one, and `item` must not match empty, since a body that can consume
+ * nothing has infinitely many parses of the same input.
+ *
+ * @type {(ruleSet: RuleSet, emptyTags: _EmptyTagMap) => (name: string) => Repeat | undefined}
+ */
+const repeatOf = (ruleSet, emptyTags) => name => {
+    const rule = ruleSet[name]
+    if (typeof rule === 'number' || rule instanceof Array || isRepeat(rule)) { return undefined }
+    const branches = definedValues(rule)
+    if (branches.length !== 2) { return undefined }
+    const [a, b] = branches
+    const step = isNone(ruleSet[a]) ? b : isNone(ruleSet[b]) ? a : undefined
+    if (step === undefined) { return undefined }
+    const stepRule = ruleSet[step]
+    if (!(stepRule instanceof Array) || stepRule.length !== 2 || stepRule[1] !== name) { return undefined }
+    const [item] = stepRule
+    if (emptyTags[item] !== undefined || contains(name)(reachable(ruleSet)(item))) { return undefined }
+    return item
+}
+
+/**
+ * Rewrites every right-recursive 0-or-more rule of a {@link RuleSet} into a
+ * {@link Repeat}, and drops the rules that the rewrite orphans.
+ *
+ * The dropped rules are the recursive branch and, unless something else still
+ * refers to it, the empty one: both are reachable only through the variant that
+ * the {@link Repeat} replaces. Pruning them keeps the invariant that every rule
+ * of a generated set is reachable from its entry, so the serialized form holds
+ * no dead grammar.
+ *
+ * @type {(ruleSet: RuleSet, entry: string) => RuleSet}
+ */
+export const detectRepeat = (ruleSet, entry) => {
+    const repeat = repeatOf(ruleSet, emptyTagMap(ruleSet))
+    /** @type {RuleSet} */
+    const next = fromEntries(entries(ruleSet).map(([k, v]) => [k, repeat(k) ?? v]))
+    const live = reachable(next)(entry)
+    return fromEntries(entries(next).filter(([k]) => contains(k)(live)))
+}
+
 /**
  * Converts a functional grammar rule into serializable BNF data and returns
  * the generated rule set with the entry rule identifier.
@@ -184,5 +289,5 @@ const toDataAdd = map => fr => {
  */
 export const toData = fr => {
     const [, ruleSet, id] = toDataAdd({})(fr)
-    return [ruleSet, id]
+    return [detectRepeat(ruleSet, id), id]
 }

package/fjs/bnf/data/proof.f.d.mts

@@ -7,6 +7,8 @@ export declare const proof: {
     rangeDecode: () => void;
     rangeEncode: () => void;
     toData: (() => void)[];
+    isRepeat: () => void;
+    detectRepeat: (() => void)[];
     variantTest: () => void;
     emptyTagMap: (() => void)[];
     example: () => void;