parser-lr 0.2.4 → 0.3.0

package/bin/parser-lr.js

@@ -3781,7 +3781,7 @@ const {
   Help,
 } = commander;
 
-var version$1 = "0.2.4";
+var version$1 = "0.3.0";
 var packageDefinition = {
 	version: version$1};
 
@@ -5264,6 +5264,7 @@ async function lexChunkStreamAsync(grammar, chunks) {
  * Returns the ACTION table key for a lexer token.
  *
  * @param token - Current input token.
+ * @returns The ACTION table key for the token, or `$eof` for end-of-input.
  */
 function tokenActionKey(token) {
     if (isEofToken(token)) {
@@ -5275,6 +5276,7 @@ function tokenActionKey(token) {
  * Builds a terminal CST node from a shifted token.
  *
  * @param token - Lexer token that was shifted.
+ * @returns A terminal CST node carrying the token name, text, and location.
  */
 function astNodeFromToken(token) {
     return AstNode.terminal(token.name, token.text, token.location);
@@ -5283,10 +5285,12 @@ function astNodeFromToken(token) {
  * Merges child spans into one source location.
  *
  * @param children - Reduced child subtrees.
+ * @returns The smallest span covering all child locations, or null when none exist.
  */
 function mergeChildLocations(children) {
     let offset = null;
     let end = null;
+    // Walk children to find the earliest offset and latest end position.
     for (const child of children) {
         if (child.location === null) {
             continue;
@@ -5346,6 +5350,7 @@ class ShiftReduceEngine {
         const stateStack = [0];
         const valueStack = [];
         let tokenIndex = 0;
+        // Drive the parser until accept, error, or an unrecoverable reduce failure.
         while (true) {
             const state = stateStack[stateStack.length - 1];
             const currentToken = tokens[tokenIndex];
@@ -5402,6 +5407,7 @@ class ShiftReduceEngine {
      * @param productionId - Production to reduce by.
      * @param stateStack - Parser state stack.
      * @param valueStack - Semantic value stack.
+     * @returns The reduced subtree pushed onto the value stack, or null on stack underflow.
      */
     static reduce(table, productionId, stateStack, valueStack) {
         const production = table.production(productionId);
@@ -5410,6 +5416,7 @@ class ShiftReduceEngine {
         }
         const rhsLength = production.rhs.length;
         const children = [];
+        // Pop one state and value per right-hand side symbol.
         for (let index = 0; index < rhsLength; index += 1) {
             if (stateStack.length === 0 || valueStack.length === 0) {
                 return null;
@@ -5424,6 +5431,7 @@ class ShiftReduceEngine {
         if (stateStack.length === 0) {
             return null;
         }
+        // Follow GOTO for the production left-hand side and push the new subtree.
         const gotoState = table.goto(stateStack[stateStack.length - 1], production.name);
         if (gotoState === null) {
             return null;
@@ -5438,6 +5446,7 @@ class ShiftReduceEngine {
      *
      * @param production - Reduced production metadata.
      * @param children - Child subtrees matching the production right-hand side.
+     * @returns A rule CST node spanning the reduced children.
      */
     static nodeFromProduction(production, children) {
         return AstNode.rule(production.name, children, mergeChildLocations(children), production.variant, production.id, production.origin);
@@ -5448,6 +5457,7 @@ class ShiftReduceEngine {
  *
  * @param table - Parse table with ACTION, GOTO, and production metadata.
  * @param tokens - Token stream ending with `$eof`.
+ * @returns The start symbol parse tree, or null on syntax error.
  */
 function parseWithTable(table, tokens) {
     return ShiftReduceEngine.parse(table, tokens);
@@ -5457,6 +5467,7 @@ function parseWithTable(table, tokens) {
  *
  * @param table - Parse table with ACTION, GOTO, and production metadata.
  * @param tokens - Token stream ending with `$eof`.
+ * @returns Parse tree on success, or error offset and message on failure.
  */
 function parseWithTableResult(table, tokens) {
     return ShiftReduceEngine.parseWithResult(table, tokens);
@@ -5683,6 +5694,7 @@ class EbnfDesugarer {
      */
     desugarProduction(production) {
         const alternatives = this.expandExpression(production.name, production.expression, null);
+        // Record one BNF production per desugared alternative.
         for (const alternative of alternatives) {
             this.addProduction(production.name, alternative.symbols, alternative.variant, production.name);
         }
@@ -5760,6 +5772,7 @@ class EbnfDesugarer {
      */
     expandSequence(ownerName, elements, variant) {
         let results = [{ symbols: [], variant }];
+        // Cartesian product: combine each prefix alternative with each next-element alternative.
         for (const element of elements) {
             const elementAlternatives = this.expandExpression(ownerName, element, variant);
             const combined = [];
@@ -5882,6 +5895,7 @@ class GrammarAnalysis {
      * Returns whether a non-terminal can derive the empty string.
      *
      * @param name - Non-terminal name to test.
+     * @returns True when the non-terminal can derive ε.
      */
     isNullable(name) {
         return this.nullable.has(name);
@@ -5906,10 +5920,12 @@ class GrammarAnalysis {
      * Returns FIRST symbols for a symbol sequence.
      *
      * @param symbols - Right-hand side prefix or full sequence.
+     * @returns Encoded terminal keys in FIRST of the sequence.
      */
     firstOfSequence(symbols) {
         const result = new Set();
         let allNullable = true;
+        // Accumulate FIRST of each prefix symbol until a non-nullable symbol stops propagation.
         for (const symbol of symbols) {
             const symbolFirst = this.firstOfSymbol(symbol);
             GrammarAnalysis.addAll(result, symbolFirst);
@@ -5918,6 +5934,7 @@ class GrammarAnalysis {
                 break;
             }
         }
+        // Every symbol is nullable, so end-of-input is in FIRST.
         if (allNullable) {
             result.add(EOF_TOKEN_NAME);
         }
@@ -5949,10 +5966,12 @@ class GrammarAnalysis {
      * Computes nullable non-terminals by fixed-point iteration.
      *
      * @param grammar - Plain BNF grammar to analyze.
+     * @returns The set of non-terminal names that derive ε.
      */
     static computeNullable(grammar) {
         const nullable = new Set();
         let changed = true;
+        // Fixed-point: mark A nullable when every production A → α has nullable α.
         while (changed) {
             changed = false;
             for (const production of grammar.productions) {
@@ -5976,6 +5995,7 @@ class GrammarAnalysis {
      *
      * @param grammar - Plain BNF grammar to analyze.
      * @param nullable - Nullable non-terminal names.
+     * @returns FIRST set for every non-terminal name.
      */
     static computeFirst(grammar, nullable) {
         const firstByNonTerminal = new Map();
@@ -5983,6 +6003,7 @@ class GrammarAnalysis {
             firstByNonTerminal.set(name, new Set());
         }
         let changed = true;
+        // Fixed-point: add FIRST(α) into FIRST(A) for each production A → α.
         while (changed) {
             changed = false;
             for (const production of grammar.productions) {
@@ -6003,16 +6024,19 @@ class GrammarAnalysis {
      * @param grammar - Plain BNF grammar to analyze.
      * @param firstByNonTerminal - Precomputed FIRST sets.
      * @param nullable - Nullable non-terminal names.
+     * @returns FOLLOW set for every non-terminal name.
      */
     static computeFollow(grammar, firstByNonTerminal, nullable) {
         const followByNonTerminal = new Map();
         for (const name of grammar.nonTerminalNames()) {
             followByNonTerminal.set(name, new Set());
         }
+        // Seed FOLLOW of the start symbol with end-of-input.
         const startFollow = followByNonTerminal.get(grammar.startSymbol) ?? new Set();
         startFollow.add(EOF_TOKEN_NAME);
         followByNonTerminal.set(grammar.startSymbol, startFollow);
         let changed = true;
+        // Fixed-point: propagate FOLLOW through every production A → α B β.
         while (changed) {
             changed = false;
             for (const production of grammar.productions) {
@@ -6026,6 +6050,7 @@ class GrammarAnalysis {
                     const beta = production.rhs.slice(index + 1);
                     const betaFirst = GrammarAnalysis.firstOfSequenceStatic(beta, firstByNonTerminal, nullable);
                     GrammarAnalysis.addAll(follow, betaFirst);
+                    // When β is empty or nullable, inherit FOLLOW of the production lhs.
                     if (beta.length === 0 || GrammarAnalysis.isSequenceNullableStatic(beta, nullable)) {
                         const lhsFollow = followByNonTerminal.get(production.name) ?? new Set();
                         GrammarAnalysis.addAll(follow, lhsFollow);
@@ -6107,6 +6132,7 @@ class GrammarAnalysis {
  * Computes nullable, FIRST, and FOLLOW sets for a BNF grammar.
  *
  * @param grammar - Plain BNF grammar to analyze.
+ * @returns Nullable, FIRST, and FOLLOW analysis for the grammar.
  */
 function analyzeGrammar(grammar) {
     return new GrammarAnalysis(grammar);
@@ -6125,38 +6151,60 @@ function sortLr0Items(items) {
         return left.dot - right.dot;
     });
 }
+/**
+ * Returns encoded symbol keys that appear immediately after the dot in an item set.
+ *
+ * @param grammar - BNF grammar containing referenced productions.
+ * @param items - Closed item set.
+ * @returns Sorted terminal and non-terminal keys eligible for GOTO from this state.
+ */
+function symbolsAfterDot(grammar, items) {
+    const keys = new Set();
+    for (const item of items) {
+        const production = grammar.production(item.productionId);
+        if (production === null) {
+            continue;
+        }
+        const nextSymbol = production.rhs[item.dot];
+        if (nextSymbol === undefined) {
+            continue;
+        }
+        keys.add(bnfParserSymbolKey(nextSymbol));
+    }
+    return [...keys].sort();
+}
 /**
  * Computes the LR(0) closure of an item set.
  *
  * @param grammar - Plain or augmented BNF grammar.
  * @param items - Seed items.
+ * @returns The seed items plus all items implied by dotted non-terminal prefixes.
  */
 function lr0Closure(grammar, items) {
     const result = sortLr0Items(items);
     const itemKeys = new Set(result.map((item) => Lr0ItemSetBuilder.itemIdentity(item)));
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const item of [...result]) {
-            const production = grammar.production(item.productionId);
-            if (production === null) {
-                continue;
-            }
-            const nextSymbol = production.rhs[item.dot];
-            if (nextSymbol === undefined || nextSymbol.kind !== 'nonTerminal') {
-                continue;
-            }
-            for (const candidate of grammar.productionsFor(nextSymbol.name)) {
-                const closureItem = {
-                    productionId: candidate.id,
-                    dot: 0,
-                };
-                const identity = Lr0ItemSetBuilder.itemIdentity(closureItem);
-                if (!itemKeys.has(identity)) {
-                    itemKeys.add(identity);
-                    result.push(closureItem);
-                    changed = true;
-                }
+    const pendingIndices = result.map((_, index) => index);
+    // Expand closure from each newly discovered item only.
+    while (pendingIndices.length > 0) {
+        const item = result[pendingIndices.pop()];
+        const production = grammar.production(item.productionId);
+        if (production === null) {
+            continue;
+        }
+        const nextSymbol = production.rhs[item.dot];
+        if (nextSymbol === undefined || nextSymbol.kind !== 'nonTerminal') {
+            continue;
+        }
+        for (const candidate of grammar.productionsFor(nextSymbol.name)) {
+            const closureItem = {
+                productionId: candidate.id,
+                dot: 0,
+            };
+            const identity = Lr0ItemSetBuilder.itemIdentity(closureItem);
+            if (!itemKeys.has(identity)) {
+                itemKeys.add(identity);
+                pendingIndices.push(result.length);
+                result.push(closureItem);
             }
         }
     }
@@ -6168,9 +6216,11 @@ function lr0Closure(grammar, items) {
  * @param grammar - Plain or augmented BNF grammar.
  * @param items - Closed item set.
  * @param symbolKey - Encoded terminal or non-terminal symbol.
+ * @returns The closed item set reached after advancing the dot past `symbolKey`.
  */
 function lr0Goto(grammar, items, symbolKey) {
     const moved = [];
+    // Advance the dot on every item expecting `symbolKey`.
     for (const item of items) {
         const production = grammar.production(item.productionId);
         if (production === null) {
@@ -6196,15 +6246,30 @@ function lr0Goto(grammar, items, symbolKey) {
 class Lr0ItemSetCollection {
     grammar;
     itemSets;
+    indexByIdentity;
     /**
      * Creates a collection from an ordered list of closed item sets.
      *
      * @param grammar - Grammar the item sets were built from.
      * @param itemSets - Closed LR(0) item sets in discovery order.
+     * @param indexByIdentity - Optional precomputed identity-to-state map.
      */
-    constructor(grammar, itemSets) {
+    constructor(
+    /** Grammar analyzed when the item sets were constructed. */
+    grammar, 
+    /** Closed LR(0) item sets indexed by parser state number. */
+    itemSets, indexByIdentity) {
         this.grammar = grammar;
         this.itemSets = itemSets;
+        if (indexByIdentity !== undefined) {
+            this.indexByIdentity = indexByIdentity;
+            return;
+        }
+        const builtIndex = new Map();
+        for (let index = 0; index < itemSets.length; index += 1) {
+            builtIndex.set(Lr0ItemSetBuilder.setIdentity(itemSets[index] ?? [], true), index);
+        }
+        this.indexByIdentity = builtIndex;
     }
     /**
      * Returns the index of an item set matching `items`, or null when absent.
@@ -6212,13 +6277,8 @@ class Lr0ItemSetCollection {
      * @param items - Closed item set to locate.
      */
     indexOf(items) {
-        const target = Lr0ItemSetBuilder.setIdentity(items);
-        for (let index = 0; index < this.itemSets.length; index += 1) {
-            if (Lr0ItemSetBuilder.setIdentity(this.itemSets[index]) === target) {
-                return index;
-            }
-        }
-        return null;
+        const target = Lr0ItemSetBuilder.setIdentity(items, true);
+        return this.indexByIdentity.get(target) ?? null;
     }
 }
 /**
@@ -6229,42 +6289,42 @@ class Lr0ItemSetBuilder {
      * Builds the canonical LR(0) collection for a grammar.
      *
      * @param grammar - Augmented or plain BNF grammar.
+     * @returns The canonical LR(0) item set collection for the grammar.
      */
     static build(grammar) {
         const startProductions = grammar.productionsFor(grammar.startSymbol);
         if (startProductions.length === 0) {
             return new Lr0ItemSetCollection(grammar, []);
         }
+        // Seed state 0 from the start production at dot zero.
         const initial = lr0Closure(grammar, [{
                 productionId: startProductions[0].id,
                 dot: 0,
             }]);
         const itemSets = [[...initial]];
-        const itemSetKeys = new Map([
-            [Lr0ItemSetBuilder.setIdentity(initial), 0],
+        const indexByIdentity = new Map([
+            [Lr0ItemSetBuilder.setIdentity(initial, true), 0],
         ]);
-        const symbols = Lr0ItemSetBuilder.grammarSymbolKeys(grammar);
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const itemSet of [...itemSets]) {
-                for (const symbolKey of symbols) {
-                    const gotoSet = lr0Goto(grammar, itemSet, symbolKey);
-                    if (gotoSet.length === 0) {
-                        continue;
-                    }
-                    const gotoKey = Lr0ItemSetBuilder.setIdentity(gotoSet);
-                    const existingIndex = itemSetKeys.get(gotoKey);
-                    if (existingIndex === undefined) {
-                        const nextIndex = itemSets.length;
-                        itemSetKeys.set(gotoKey, nextIndex);
-                        itemSets.push([...gotoSet]);
-                        changed = true;
-                    }
+        const pendingStates = [0];
+        // Discover new states from each state exactly once.
+        while (pendingStates.length > 0) {
+            const stateIndex = pendingStates.pop();
+            const itemSet = itemSets[stateIndex] ?? [];
+            for (const symbolKey of symbolsAfterDot(grammar, itemSet)) {
+                const gotoSet = lr0Goto(grammar, itemSet, symbolKey);
+                if (gotoSet.length === 0) {
+                    continue;
+                }
+                const gotoKey = Lr0ItemSetBuilder.setIdentity(gotoSet, true);
+                if (!indexByIdentity.has(gotoKey)) {
+                    const nextIndex = itemSets.length;
+                    indexByIdentity.set(gotoKey, nextIndex);
+                    itemSets.push([...gotoSet]);
+                    pendingStates.push(nextIndex);
                 }
             }
         }
-        return new Lr0ItemSetCollection(grammar, itemSets);
+        return new Lr0ItemSetCollection(grammar, itemSets, indexByIdentity);
     }
     /**
      * Returns every terminal and non-terminal key that can appear in GOTO.
@@ -6290,9 +6350,11 @@ class Lr0ItemSetBuilder {
      * Returns a stable identity string for an item set.
      *
      * @param items - Closed item set.
+     * @param alreadySorted - When true, skips re-sorting because items are canonical.
      */
-    static setIdentity(items) {
-        return sortLr0Items(items)
+    static setIdentity(items, alreadySorted = false) {
+        const sorted = alreadySorted ? items : sortLr0Items(items);
+        return sorted
             .map((item) => Lr0ItemSetBuilder.itemIdentity(item))
             .join('|');
     }
@@ -6301,6 +6363,7 @@ class Lr0ItemSetBuilder {
  * Builds the canonical LR(0) item set collection for a grammar.
  *
  * @param grammar - Augmented or plain BNF grammar.
+ * @returns The canonical LR(0) item set collection for the grammar.
  */
 function buildLr0ItemSets(grammar) {
     return Lr0ItemSetBuilder.build(grammar);
@@ -6325,21 +6388,6 @@ function parseActionsEqual(left, right) {
             return true;
     }
 }
-/**
- * Returns a readable parse action label for tests and diagnostics.
- *
- * @param action - Parse action to format.
- */
-function formatParseAction(action) {
-    switch (action.kind) {
-        case 'shift':
-            return `s${String(action.state)}`;
-        case 'reduce':
-            return `r${String(action.productionId)}`;
-        case 'accept':
-            return 'acc';
-    }
-}
 /**
  * Classifies a conflict between two distinct parse actions.
  *
@@ -6365,13 +6413,14 @@ class TableBuilderBase {
      * @param grammar - Augmented BNF grammar.
      * @param itemSets - Canonical item set collection.
      * @param gotoItems - Computes the GOTO item set for one state and symbol.
+     * @returns Map from `state:symbol` keys to target state indices.
      */
     static buildGotoTargets(grammar, itemSets, indexOf, gotoItems) {
         const targets = new Map();
-        const symbols = Lr0ItemSetBuilder.grammarSymbolKeys(grammar);
+        // Precompute GOTO for every state and symbol reachable from its items.
         for (let state = 0; state < itemSets.length; state += 1) {
             const itemSet = itemSets[state] ?? [];
-            for (const symbolKey of symbols) {
+            for (const symbolKey of symbolsAfterDot(grammar, itemSet)) {
                 const gotoSet = gotoItems(grammar, itemSet, symbolKey);
                 if (gotoSet.length === 0) {
                     continue;
@@ -6394,9 +6443,10 @@ class TableBuilderBase {
      * @param gotoTargets - Precomputed GOTO target indices.
      * @param stateActions - ACTION map for the state.
      * @param stateGotos - GOTO map for the state.
-     * @param conflicts - Conflict list to append to when actions disagree.
+     * @param conflicts - Resolved conflict list to append to when actions disagree.
      */
     static fillShiftsAndGotos(grammar, state, itemSet, gotoTargets, stateActions, stateGotos, conflicts) {
+        // Derive shift and GOTO entries from every incomplete item in the state.
         for (const item of itemSet) {
             const production = grammar.production(item.productionId);
             if (production === null) {
@@ -6411,6 +6461,7 @@ class TableBuilderBase {
             if (targetState === undefined) {
                 continue;
             }
+            // Non-terminal symbols populate GOTO; terminals populate ACTION shift entries.
             if (nextSymbol.kind === 'nonTerminal') {
                 stateGotos.set(nextSymbol.name, targetState);
                 continue;
@@ -6424,7 +6475,7 @@ class TableBuilderBase {
      * @param state - Parser state index.
      * @param productionName - Left-hand side of the completed production.
      * @param stateActions - ACTION map for the state.
-     * @param conflicts - Conflict list to append to when actions disagree.
+     * @param conflicts - Resolved conflict list to append to when actions disagree.
      */
     static setAcceptAction(state, productionName, stateActions, conflicts) {
         if (productionName !== AUGMENTED_START_SYMBOL) {
@@ -6442,10 +6493,10 @@ class TableBuilderBase {
         return `${String(state)}:${symbolKey}`;
     }
     /**
-     * Inserts one ACTION entry, recording a conflict when the slot is already occupied.
+     * Inserts one ACTION entry, resolving shift/reduce and reduce/reduce conflicts.
      *
      * @param stateActions - ACTION map for the current state.
-     * @param conflicts - Conflict list to append to when actions disagree.
+     * @param conflicts - Resolved conflict list to append to when actions disagree.
      * @param state - Parser state index.
      * @param symbol - Encoded terminal or `$eof` key.
      * @param incoming - Candidate parse action.
@@ -6456,15 +6507,32 @@ class TableBuilderBase {
             stateActions.set(symbol, incoming);
             return;
         }
+        // Identical re-insertions are ignored; disagreeing actions are resolved by conflict kind.
         if (parseActionsEqual(existing, incoming)) {
             return;
         }
+        const conflictKind = classifyParseConflict(existing, incoming);
+        if (conflictKind === 'shift-reduce') {
+            const shiftAction = existing.kind === 'shift' ? existing : incoming;
+            stateActions.set(symbol, shiftAction);
+            conflicts.push({
+                kind: 'shift-reduce',
+                state,
+                symbol,
+                existing,
+                incoming,
+                resolution: 'shift',
+            });
+            return;
+        }
+        // Reduce/reduce: keep the first reduce action already in the table.
         conflicts.push({
-            kind: classifyParseConflict(existing, incoming),
+            kind: 'reduce-reduce',
             state,
             symbol,
             existing,
             incoming,
+            resolution: 'reduce',
         });
     }
     /**
@@ -6483,6 +6551,7 @@ class TableBuilderBase {
  * Sorts LR(1) items for canonical set comparison.
  *
  * @param items - Items to sort.
+ * @returns A new array sorted by production id, dot, then lookahead.
  */
 function sortLr1Items(items) {
     return [...items].sort((left, right) => {
@@ -6499,6 +6568,7 @@ function sortLr1Items(items) {
  * Returns the LR(0) core key for one LR(1) item.
  *
  * @param item - LR(1) item to encode.
+ * @returns A string `productionId:dot` shared by all lookaheads at the same dot position.
  */
 function lr1CoreKey(item) {
     return `${String(item.productionId)}:${String(item.dot)}`;
@@ -6507,6 +6577,7 @@ function lr1CoreKey(item) {
  * Returns a stable identity string for one LR(1) item.
  *
  * @param item - Item to encode.
+ * @returns A string `productionId:dot:lookahead` for set membership tests.
  */
 function lr1ItemIdentity(item) {
     return `${lr1CoreKey(item)}:${item.lookahead}`;
@@ -6515,9 +6586,12 @@ function lr1ItemIdentity(item) {
  * Returns a stable identity string for an LR(1) item set.
  *
  * @param items - Closed item set.
+ * @param alreadySorted - When true, skips re-sorting because items are canonical.
+ * @returns A pipe-separated, sorted identity string for canonical set comparison.
  */
-function lr1SetIdentity(items) {
-    return sortLr1Items(items)
+function lr1SetIdentity(items, alreadySorted = false) {
+    const sorted = alreadySorted ? items : sortLr1Items(items);
+    return sorted
         .map((item) => lr1ItemIdentity(item))
         .join('|');
 }
@@ -6525,6 +6599,7 @@ function lr1SetIdentity(items) {
  * Returns the LR(0) core identity for an LR(1) item set.
  *
  * @param items - LR(1) item set.
+ * @returns A pipe-separated, sorted string of LR(0) cores with lookaheads removed.
  */
 function lr1CoreSetIdentity(items) {
     const cores = new Set(items.map((item) => lr1CoreKey(item)));
@@ -6536,9 +6611,11 @@ function lr1CoreSetIdentity(items) {
  * @param beta - Remaining right-hand side symbols after a non-terminal.
  * @param lookahead - Lookahead terminal following β.
  * @param analysis - Nullable and FIRST analysis for the grammar.
+ * @returns Terminal keys that may follow the dotted non-terminal in this item.
  */
 function firstAfterSymbols(beta, lookahead, analysis) {
     const result = new Set();
+    // Accumulate FIRST of each prefix symbol until a non-nullable symbol stops propagation.
     for (const symbol of beta) {
         for (const terminal of analysis.firstOfSymbol(symbol)) {
             result.add(terminal);
@@ -6547,6 +6624,7 @@ function firstAfterSymbols(beta, lookahead, analysis) {
             return result;
         }
     }
+    // Every symbol in β is nullable, so the item's own lookahead is reachable.
     result.add(lookahead);
     return result;
 }
@@ -6556,36 +6634,37 @@ function firstAfterSymbols(beta, lookahead, analysis) {
  * @param grammar - Augmented BNF grammar.
  * @param analysis - Nullable and FIRST analysis for the grammar.
  * @param items - Seed items.
+ * @returns The seed items plus all items implied by dotted non-terminal prefixes.
  */
 function lr1Closure(grammar, analysis, items) {
     const result = sortLr1Items(items);
     const itemKeys = new Set(result.map((item) => lr1ItemIdentity(item)));
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const item of [...result]) {
-            const production = grammar.production(item.productionId);
-            if (production === null) {
-                continue;
-            }
-            const nextSymbol = production.rhs[item.dot];
-            if (nextSymbol === undefined || nextSymbol.kind !== 'nonTerminal') {
-                continue;
-            }
-            const beta = production.rhs.slice(item.dot + 1);
-            for (const candidate of grammar.productionsFor(nextSymbol.name)) {
-                for (const lookahead of firstAfterSymbols(beta, item.lookahead, analysis)) {
-                    const closureItem = {
-                        productionId: candidate.id,
-                        dot: 0,
-                        lookahead,
-                    };
-                    const identity = lr1ItemIdentity(closureItem);
-                    if (!itemKeys.has(identity)) {
-                        itemKeys.add(identity);
-                        result.push(closureItem);
-                        changed = true;
-                    }
+    const pendingIndices = result.map((_, index) => index);
+    // Expand closure from each newly discovered item only.
+    while (pendingIndices.length > 0) {
+        const item = result[pendingIndices.pop()];
+        const production = grammar.production(item.productionId);
+        if (production === null) {
+            continue;
+        }
+        const nextSymbol = production.rhs[item.dot];
+        if (nextSymbol === undefined || nextSymbol.kind !== 'nonTerminal') {
+            continue;
+        }
+        const beta = production.rhs.slice(item.dot + 1);
+        // For each production of the non-terminal after the dot, propagate lookaheads.
+        for (const candidate of grammar.productionsFor(nextSymbol.name)) {
+            for (const lookahead of firstAfterSymbols(beta, item.lookahead, analysis)) {
+                const closureItem = {
+                    productionId: candidate.id,
+                    dot: 0,
+                    lookahead,
+                };
+                const identity = lr1ItemIdentity(closureItem);
+                if (!itemKeys.has(identity)) {
+                    itemKeys.add(identity);
+                    pendingIndices.push(result.length);
+                    result.push(closureItem);
                 }
             }
         }
@@ -6599,9 +6678,11 @@ function lr1Closure(grammar, analysis, items) {
  * @param analysis - Nullable and FIRST analysis for the grammar.
  * @param items - Closed item set.
  * @param symbolKey - Encoded terminal or non-terminal symbol.
+ * @returns The closed item set reached after advancing the dot past `symbolKey`.
  */
 function lr1Goto(grammar, analysis, items, symbolKey) {
     const moved = [];
+    // Advance the dot on every item expecting `symbolKey`, preserving lookaheads.
     for (const item of items) {
         const production = grammar.production(item.productionId);
         if (production === null) {
@@ -6628,34 +6709,45 @@ function lr1Goto(grammar, analysis, items, symbolKey) {
 class Lr1ItemSetCollection {
     grammar;
     itemSets;
+    indexByIdentity;
     /**
      * Creates a collection from an ordered list of closed item sets.
      *
      * @param grammar - Grammar the item sets were built from.
      * @param itemSets - Closed LR(1) item sets in discovery order.
+     * @param indexByIdentity - Optional precomputed identity-to-state map.
      */
-    constructor(grammar, itemSets) {
+    constructor(
+    /** Grammar analyzed when the item sets were constructed. */
+    grammar, 
+    /** Closed LR(1) item sets indexed by parser state number. */
+    itemSets, indexByIdentity) {
         this.grammar = grammar;
         this.itemSets = itemSets;
+        if (indexByIdentity !== undefined) {
+            this.indexByIdentity = indexByIdentity;
+            return;
+        }
+        const builtIndex = new Map();
+        for (let index = 0; index < itemSets.length; index += 1) {
+            builtIndex.set(lr1SetIdentity(itemSets[index] ?? [], true), index);
+        }
+        this.indexByIdentity = builtIndex;
     }
     /**
      * Returns the index of an item set matching `items`, or null when absent.
      *
      * @param items - Closed item set to locate.
+     * @returns State index, or null when no set has the same canonical identity.
      */
     indexOf(items) {
-        const target = lr1SetIdentity(items);
-        for (let index = 0; index < this.itemSets.length; index += 1) {
-            if (lr1SetIdentity(this.itemSets[index]) === target) {
-                return index;
-            }
-        }
-        return null;
+        return this.indexByIdentity.get(lr1SetIdentity(items, true)) ?? null;
     }
     /**
      * Returns LR(0) items derived from one LR(1) item set.
      *
      * @param items - LR(1) item set.
+     * @returns Deduplicated LR(0) cores with lookaheads stripped.
      */
     static lr0Core(items) {
         const cores = new Map();
@@ -6678,43 +6770,43 @@ class Lr1ItemSetBuilder {
      * @param grammar - Augmented BNF grammar.
      * @param analysis - Nullable and FIRST analysis for the grammar.
      * @param startLookahead - Lookahead terminal for the initial item.
+     * @returns The canonical LR(1) item set collection for the grammar.
      */
     static build(grammar, analysis, startLookahead) {
         const startProductions = grammar.productionsFor(grammar.startSymbol);
         if (startProductions.length === 0) {
             return new Lr1ItemSetCollection(grammar, []);
         }
+        // Seed state 0 from the augmented start production and its initial lookahead.
         const initial = lr1Closure(grammar, analysis, [{
                 productionId: startProductions[0].id,
                 dot: 0,
                 lookahead: startLookahead,
             }]);
         const itemSets = [[...initial]];
-        const itemSetKeys = new Map([
-            [lr1SetIdentity(initial), 0],
+        const indexByIdentity = new Map([
+            [lr1SetIdentity(initial, true), 0],
         ]);
-        const symbols = grammar.terminalKeys().concat(grammar.nonTerminalNames()).sort();
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const itemSet of [...itemSets]) {
-                for (const symbolKey of symbols) {
-                    const gotoSet = lr1Goto(grammar, analysis, itemSet, symbolKey);
-                    if (gotoSet.length === 0) {
-                        continue;
-                    }
-                    const gotoKey = lr1SetIdentity(gotoSet);
-                    const existingIndex = itemSetKeys.get(gotoKey);
-                    if (existingIndex === undefined) {
-                        const nextIndex = itemSets.length;
-                        itemSetKeys.set(gotoKey, nextIndex);
-                        itemSets.push([...gotoSet]);
-                        changed = true;
-                    }
+        const pendingStates = [0];
+        // Discover new states from each state exactly once.
+        while (pendingStates.length > 0) {
+            const stateIndex = pendingStates.pop();
+            const itemSet = itemSets[stateIndex] ?? [];
+            for (const symbolKey of symbolsAfterDot(grammar, itemSet)) {
+                const gotoSet = lr1Goto(grammar, analysis, itemSet, symbolKey);
+                if (gotoSet.length === 0) {
+                    continue;
+                }
+                const gotoKey = lr1SetIdentity(gotoSet, true);
+                if (!indexByIdentity.has(gotoKey)) {
+                    const nextIndex = itemSets.length;
+                    indexByIdentity.set(gotoKey, nextIndex);
+                    itemSets.push([...gotoSet]);
+                    pendingStates.push(nextIndex);
                 }
             }
         }
-        return new Lr1ItemSetCollection(grammar, itemSets);
+        return new Lr1ItemSetCollection(grammar, itemSets, indexByIdentity);
     }
 }
 /**
@@ -6723,6 +6815,7 @@ class Lr1ItemSetBuilder {
  * @param grammar - Augmented BNF grammar.
  * @param analysis - Nullable and FIRST analysis for the grammar.
  * @param startLookahead - Lookahead terminal for the initial item.
+ * @returns The canonical LR(1) item set collection for the grammar.
  */
 function buildLr1ItemSets(grammar, analysis, startLookahead) {
     return Lr1ItemSetBuilder.build(grammar, analysis, startLookahead);
@@ -6731,11 +6824,13 @@ function buildLr1ItemSets(grammar, analysis, startLookahead) {
  * Merges LR(1) item sets that share the same LR(0) core into LALR item sets.
  *
  * @param collection - Canonical LR(1) item set collection.
+ * @returns A new collection with LR(1) states merged by LR(0) core.
  */
 function mergeLalrItemSets(collection) {
     const coreToLalrIndex = new Map();
     const lr1ToLalr = new Map();
     const mergedItemSets = [];
+    // Assign each LR(1) state to an LALR state keyed by its LR(0) core identity.
     for (let lr1Index = 0; lr1Index < collection.itemSets.length; lr1Index += 1) {
         const itemSet = collection.itemSets[lr1Index] ?? [];
         const core = lr1CoreSetIdentity(itemSet);
@@ -6759,17 +6854,18 @@ function mergeLalrItemSets(collection) {
  * @param lr1Collection - Canonical LR(1) item set collection.
  * @param lalrCollection - Merged LALR item set collection.
  * @param lr1ToLalr - LR(1) state index to LALR state index map.
+ * @returns Map from `state:symbol` keys to LALR GOTO target state indices.
  */
 function buildLalrGotoTargets(grammar, analysis, lr1Collection, lr1ToLalr) {
     const targets = new Map();
-    const symbols = grammar.terminalKeys().concat(grammar.nonTerminalNames()).sort();
+    // Recompute LR(1) GOTOs and remap each target through the LR(1) → LALR index map.
     for (let lr1State = 0; lr1State < lr1Collection.itemSets.length; lr1State += 1) {
         const lalrState = lr1ToLalr.get(lr1State);
         if (lalrState === undefined) {
             continue;
         }
         const itemSet = lr1Collection.itemSets[lr1State] ?? [];
-        for (const symbolKey of symbols) {
+        for (const symbolKey of symbolsAfterDot(grammar, itemSet)) {
             const gotoSet = lr1Goto(grammar, analysis, itemSet, symbolKey);
             if (gotoSet.length === 0) {
                 continue;
@@ -6796,9 +6892,11 @@ function buildLalrGotoTargets(grammar, analysis, lr1Collection, lr1ToLalr) {
      *
      * @param left - Existing merged item set.
      * @param right - Additional LR(1) item set to merge in.
+     * @returns Items with lookaheads unioned for each shared LR(0) core.
      */
     function mergeItems(left, right) {
         const lookaheadsByCore = new Map();
+        // Collect every lookahead grouped by dotted-production core.
         for (const item of [...left, ...right]) {
             const core = lr1CoreKey(item);
             const lookaheads = lookaheadsByCore.get(core) ?? new Set();
@@ -6806,6 +6904,7 @@ function buildLalrGotoTargets(grammar, analysis, lr1Collection, lr1ToLalr) {
             lookaheadsByCore.set(core, lookaheads);
         }
         const merged = [];
+        // Expand each core into one item per distinct lookahead.
         for (const [core, lookaheads] of lookaheadsByCore.entries()) {
             const [productionIdText, dotText] = core.split(':');
             const productionId = Number(productionIdText);
@@ -6826,13 +6925,16 @@ function buildLalrGotoTargets(grammar, analysis, lr1Collection, lr1ToLalr) {
      *
      * @param lr1Collection - Canonical LR(1) item set collection.
      * @param lalrCollection - Merged LALR item set collection.
+     * @returns Map from LR(1) state index to merged LALR state index.
      */
     function buildLr1ToLalrMap(lr1Collection, lalrCollection) {
         const coreToLalrIndex = new Map();
+        // Index LALR states by their LR(0) core identity.
         for (let lalrIndex = 0; lalrIndex < lalrCollection.itemSets.length; lalrIndex += 1) {
             coreToLalrIndex.set(lr1CoreSetIdentity(lalrCollection.itemSets[lalrIndex] ?? []), lalrIndex);
         }
         const lr1ToLalr = new Map();
+        // Map each LR(1) state to the LALR state sharing its core.
         for (let lr1Index = 0; lr1Index < lr1Collection.itemSets.length; lr1Index += 1) {
             const core = lr1CoreSetIdentity(lr1Collection.itemSets[lr1Index] ?? []);
             const lalrIndex = coreToLalrIndex.get(core);
@@ -6865,7 +6967,7 @@ class LrParseTable {
      * @param stateCount - Number of parser states in the item set collection.
      * @param actions - ACTION entries keyed by state and terminal symbol.
      * @param gotos - GOTO entries keyed by state and non-terminal name.
-     * @param conflicts - Shift/reduce and reduce/reduce conflicts encountered while building.
+     * @param conflicts - Shift/reduce and reduce/reduce conflicts resolved during construction.
      */
     constructor(algorithm, grammar, productions, stateCount, actions, gotos, conflicts) {
         this.algorithm = algorithm;
@@ -6877,7 +6979,7 @@ class LrParseTable {
         this.conflicts = conflicts;
     }
     /**
-     * Whether the table has no unresolved conflicts.
+     * Whether the table was built without conflicts.
      */
     get isConflictFree() {
         return this.conflicts.length === 0;
@@ -6902,14 +7004,31 @@ class LrParseTable {
     }
 }
 /**
- * Returns readable conflict labels for tests and diagnostics.
+ * Formats one resolved conflict as a warning line.
  *
- * @param table - LR parse table to format.
+ * @param conflict - Resolved shift/reduce or reduce/reduce conflict.
  */
-function formatLrConflicts(table) {
-    return table.conflicts.map((conflict) => `${String(conflict.state)}/${conflict.symbol} `
-        + `${formatParseAction(conflict.existing)} vs ${formatParseAction(conflict.incoming)} `
-        + `(${conflict.kind})`);
+function formatParseConflictWarning(conflict) {
+    const tokenLabel = formatConflictTokenLabel(conflict.symbol);
+    if (conflict.kind === 'shift-reduce') {
+        return `state ${String(conflict.state)}: shift/reduce conflict on ${tokenLabel} resolved as shift`;
+    }
+    const keptProduction = conflict.existing.kind === 'reduce'
+        ? conflict.existing.productionId
+        : conflict.incoming.productionId;
+    return `state ${String(conflict.state)}: reduce/reduce conflict on ${tokenLabel} `
+        + `resolved using rule ${String(keptProduction)}`;
+}
+/**
+ * Returns a readable terminal label for conflict warning text.
+ *
+ * @param symbol - Encoded terminal or `$eof` key from the ACTION table.
+ */
+function formatConflictTokenLabel(symbol) {
+    if (symbol === '$eof') {
+        return 'token $eof';
+    }
+    return `token ${symbol}`;
 }
 /**
  * Returns encoded right-hand side symbols for one production.
@@ -6925,6 +7044,7 @@ function encodeProductionRhs(production) {
  *
  * @param grammar - Plain BNF grammar to analyze.
  * @param algorithm - LR table construction algorithm.
+ * @returns A populated LR parse table, possibly recording conflicts.
  */
 function buildLrTable(grammar, algorithm) {
     const augmented = grammar.augment();
@@ -6948,7 +7068,7 @@ class LrTableBuilder {
      * Builds an LR(0) parse table.
      *
      * @param grammar - Augmented BNF grammar.
-     * @param analysis - Nullable, FIRST, and FOLLOW analysis for the grammar.
+     * @returns An LR(0) parse table using all terminals as reduce lookaheads.
      */
     static buildLr0(grammar) {
         const itemSets = buildLr0ItemSets(grammar);
@@ -6965,6 +7085,7 @@ class LrTableBuilder {
      *
      * @param grammar - Augmented BNF grammar.
      * @param analysis - Nullable, FIRST, and FOLLOW analysis for the grammar.
+     * @returns An SLR parse table using FOLLOW sets as reduce lookaheads.
      */
     static buildSlr(grammar, analysis) {
         const itemSets = buildLr0ItemSets(grammar);
@@ -6980,6 +7101,7 @@ class LrTableBuilder {
      *
      * @param grammar - Augmented BNF grammar.
      * @param analysis - Nullable, FIRST, and FOLLOW analysis for the grammar.
+     * @returns An LR(1) parse table with per-item lookaheads.
      */
     static buildLr1(grammar, analysis) {
         const itemSets = buildLr1ItemSets(grammar, analysis, EOF_TOKEN_NAME);
@@ -6990,6 +7112,7 @@ class LrTableBuilder {
      *
      * @param grammar - Augmented BNF grammar.
      * @param analysis - Nullable, FIRST, and FOLLOW analysis for the grammar.
+     * @returns An LALR parse table merged from the canonical LR(1) collection.
      */
     static buildLalr(grammar, analysis) {
         const lr1ItemSets = buildLr1ItemSets(grammar, analysis, EOF_TOKEN_NAME);
@@ -7005,12 +7128,14 @@ class LrTableBuilder {
      * @param grammar - Augmented BNF grammar.
      * @param itemSets - Canonical LR(0) item set collection.
      * @param reduceLookaheads - Returns terminal keys for one completed production.
+     * @returns A parse table with ACTION, GOTO, and any recorded conflicts.
      */
     static buildFromLr0ItemSets(algorithm, grammar, itemSets, reduceLookaheads) {
         const gotoTargets = TableBuilderBase.buildGotoTargets(grammar, itemSets.itemSets, (items) => itemSets.indexOf(items), TableBuilderBase.lr0GotoItems);
         const actions = new Map();
         const gotos = new Map();
         const conflicts = [];
+        // Fill ACTION and GOTO rows for every LR(0) state.
         for (let state = 0; state < itemSets.itemSets.length; state += 1) {
             const itemSet = itemSets.itemSets[state] ?? [];
             const stateActions = new Map();
@@ -7018,6 +7143,7 @@ class LrTableBuilder {
             actions.set(state, stateActions);
             gotos.set(state, stateGotos);
             TableBuilderBase.fillShiftsAndGotos(grammar, state, itemSet, gotoTargets, stateActions, stateGotos, conflicts);
+            // Record reduce and accept actions for every completed item in the state.
             for (const item of itemSet) {
                 const production = grammar.production(item.productionId);
                 if (production === null || item.dot !== production.rhs.length) {
@@ -7042,12 +7168,14 @@ class LrTableBuilder {
      * @param itemSets - LR(1) or merged LALR item set collection used for ACTION/GOTO rows.
      * @param lr1Collection - Canonical LR(1) collection used for LALR GOTO remapping.
      * @param gotoTargetsOverride - Optional precomputed GOTO indices for LALR.
+     * @returns A parse table with ACTION, GOTO, and any recorded conflicts.
      */
     static buildFromLr1ItemSets(algorithm, grammar, analysis, itemSets, gotoTargetsOverride) {
         const gotoTargets = gotoTargetsOverride ?? TableBuilderBase.buildGotoTargets(grammar, itemSets.itemSets, (items) => itemSets.indexOf(items), (grammarArg, items, symbolKey) => lr1Goto(grammarArg, analysis, items, symbolKey));
         const actions = new Map();
         const gotos = new Map();
         const conflicts = [];
+        // Fill ACTION and GOTO rows for every LR(1) or merged LALR state.
         for (let state = 0; state < itemSets.itemSets.length; state += 1) {
             const itemSet = itemSets.itemSets[state] ?? [];
             const stateActions = new Map();
@@ -7055,6 +7183,7 @@ class LrTableBuilder {
             actions.set(state, stateActions);
             gotos.set(state, stateGotos);
             TableBuilderBase.fillShiftsAndGotos(grammar, state, itemSet, gotoTargets, stateActions, stateGotos, conflicts);
+            // Record reduce or accept for each completed item using its lookahead.
             for (const item of itemSet) {
                 const production = grammar.production(item.productionId);
                 if (production === null || item.dot !== production.rhs.length) {
@@ -7071,25 +7200,6 @@ class LrTableBuilder {
     }
 }
 
-/**
- * Thrown when LR table construction encounters unresolved conflicts.
- */
-class ParseTableBuildError extends ParserLrError {
-    algorithm;
-    conflicts;
-    /**
-     * Creates a parse table build error from detected conflicts.
-     *
-     * @param algorithm - LR algorithm that was attempted.
-     * @param conflicts - Readable conflict descriptions.
-     */
-    constructor(algorithm, conflicts) {
-        super(`LR table build failed for ${algorithm}: ${conflicts.join('; ')}`);
-        this.algorithm = algorithm;
-        this.conflicts = conflicts;
-    }
-}
-
 /**
  * Thrown when serialized parse table JSON cannot be loaded.
  */
@@ -7129,6 +7239,7 @@ class ParseTable {
     states;
     algorithm;
     parserStateCount;
+    conflicts;
     actionByState;
     gotoByState;
     productionById;
@@ -7146,8 +7257,9 @@ class ParseTable {
      * @param productions - Flat BNF production metadata for reduce actions.
      * @param actions - ACTION entries keyed by state and terminal symbol.
      * @param gotos - GOTO entries keyed by state and non-terminal name.
+     * @param conflicts - Shift/reduce and reduce/reduce conflicts resolved during construction.
      */
-    constructor(grammarName, startSymbol, tokens, tokenRules, skipRules, states, algorithm, parserStateCount = 0, productions = [], actions = new Map(), gotos = new Map()) {
+    constructor(grammarName, startSymbol, tokens, tokenRules, skipRules, states, algorithm, parserStateCount = 0, productions = [], actions = new Map(), gotos = new Map(), conflicts = []) {
         this.grammarName = grammarName;
         this.startSymbol = startSymbol;
         this.tokens = tokens;
@@ -7156,6 +7268,7 @@ class ParseTable {
         this.states = states;
         this.algorithm = algorithm;
         this.parserStateCount = parserStateCount;
+        this.conflicts = conflicts;
         this.actionByState = actions;
         this.gotoByState = gotos;
         const productionById = new Map();
@@ -7170,6 +7283,18 @@ class ParseTable {
     get hasParserTable() {
         return this.parserStateCount > 0 || this.actionByState.size > 0;
     }
+    /**
+     * Whether the table was built without conflicts.
+     */
+    get isConflictFree() {
+        return this.conflicts.length === 0;
+    }
+    /**
+     * Returns conflict warning lines for this table.
+     */
+    formatConflictWarnings() {
+        return this.conflicts.map((conflict) => formatParseConflictWarning(conflict));
+    }
     /**
      * Builds a parse table from a parsed grammar.
      *
@@ -7180,9 +7305,6 @@ class ParseTable {
     static fromGrammar(grammar, algorithm = 'lr1') {
         const bnf = desugarEbnf(grammar);
         const lrTable = buildLrTable(bnf, algorithm);
-        if (!lrTable.isConflictFree) {
-            throw new ParseTableBuildError(algorithm, formatLrConflicts(lrTable));
-        }
         return ParseTable.fromLrParseTable(grammar, lrTable);
     }
     /**
@@ -7298,7 +7420,7 @@ class ParseTable {
      * Creates a {@link ParseTable} from a built LR table and source grammar.
      *
      * @param grammar - Parsed `.grammar` file model.
-     * @param lrTable - Conflict-free LR parse table.
+     * @param lrTable - Built LR parse table, including any resolved conflict warnings.
      */
     static fromLrParseTable(grammar, lrTable) {
         const productions = lrTable.productions.map((production) => ({
@@ -7308,7 +7430,7 @@ class ParseTable {
             variant: production.variant,
             origin: production.origin,
         }));
-        return new ParseTable(grammar.name, grammar.startSymbol, tokenInventory(grammar), [...grammar.tokenRules], [...grammar.skipRules], [...grammar.states], lrTable.algorithm, lrTable.stateCount, productions, lrTable.actions, lrTable.gotos);
+        return new ParseTable(grammar.name, grammar.startSymbol, tokenInventory(grammar), [...grammar.tokenRules], [...grammar.skipRules], [...grammar.states], lrTable.algorithm, lrTable.stateCount, productions, lrTable.actions, lrTable.gotos, [...lrTable.conflicts]);
     }
     /**
      * Converts ACTION maps into JSON rows.
@@ -15535,6 +15657,15 @@ function productionSlots(production) {
         };
     });
 }
+/**
+ * Returns the shared `$repeat` prefix for a numbered synthetic repeat symbol or reference.
+ *
+ * @param name - Repeat non-terminal or transform reference name.
+ */
+function repeatSymbolPrefix(name) {
+    const match = /^(.+\$repeat)_\d+$/.exec(name);
+    return match?.[1] ?? null;
+}
 /**
  * Finds the child index for a transform reference name.
  *
@@ -15552,6 +15683,14 @@ function referenceSlotIndex(production, reference) {
             return slot.index;
         }
     }
+    const repeatPrefix = repeatSymbolPrefix(reference);
+    if (repeatPrefix !== null) {
+        for (const slot of productionSlots(production)) {
+            if (slot.binding === null && repeatSymbolPrefix(slot.symbol) === repeatPrefix) {
+                return slot.index;
+            }
+        }
+    }
     return null;
 }
 
@@ -15610,7 +15749,7 @@ class CstTransformer {
                 ? this.transformNode(node.children[0])
                 : null;
         }
-        const rule = this.schema.rule(node.symbol) ?? (node.origin === null ? null : this.schema.rule(node.origin));
+        const rule = this.resolveTransformRule(node);
         if (rule === null) {
             return this.defaultTransform(node);
         }
@@ -15857,6 +15996,28 @@ class CstTransformer {
         }
         return null;
     }
+    /**
+     * Resolves a transform rule for a CST node, aliasing numbered repeat symbols to `$repeat_0`.
+     *
+     * @param node - CST node being transformed.
+     */
+    resolveTransformRule(node) {
+        const candidates = [node.symbol];
+        if (node.origin !== null && node.origin !== node.symbol) {
+            candidates.push(node.origin);
+        }
+        const repeatPrefix = repeatSymbolPrefix(node.symbol);
+        if (repeatPrefix !== null) {
+            candidates.push(`${repeatPrefix}_0`);
+        }
+        for (const candidate of candidates) {
+            const rule = this.schema.rule(candidate);
+            if (rule !== null) {
+                return rule;
+            }
+        }
+        return null;
+    }
     /**
      * Returns whether a CST node represents an epsilon production.
      *
@@ -16305,6 +16466,10 @@ function registerTableCommands(program) {
             algorithm: options.algorithm,
         });
         const json = context.table.toJsonString();
+        // Write conflict warnings to stderr after table generation.
+        for (const warning of context.table.formatConflictWarnings()) {
+            process.stderr.write(`${warning}\n`);
+        }
         // Write JSON to disk or stdout.
         if (options.output !== undefined) {
             await writeTextFile(options.output, json);