rip-lang 3.7.4 → 3.8.8

package/src/components.js

@@ -101,8 +101,11 @@ export function installComponentSupport(CodeGenerator) {
       }
       current = current[1];
     }
-    const tag = typeof current === 'string' ? current : (current instanceof String ? current.valueOf() : 'div');
-    return { tag, classes };
+    let raw = typeof current === 'string' ? current : (current instanceof String ? current.valueOf() : 'div');
+    // Split tag#id — e.g. "div#content" → tag: "div", id: "content"
+    let [tag, id] = raw.split('#');
+    if (!tag) tag = 'div';  // bare #id → div
+    return { tag, classes, id };
   };
 
   // ==========================================================================
@@ -133,6 +136,11 @@ export function installComponentSupport(CodeGenerator) {
       return sexpr;
     }
 
+    // Dot access: transform the object but not the property name
+    if (sexpr[0] === '.') {
+      return ['.', this.transformComponentMembers(sexpr[1]), sexpr[2]];
+    }
+
     // Force thin arrows to fat arrows inside components to preserve this binding
     if (sexpr[0] === '->') {
       return ['=>', ...sexpr.slice(1).map(item => this.transformComponentMembers(item))];
@@ -264,9 +272,9 @@ export function installComponentSupport(CodeGenerator) {
 
     // Effects
     for (const effect of effects) {
-      const effectBody = effect[1];
+      const effectBody = effect[2];
       const effectCode = this.generateInComponent(effectBody, 'value');
-      lines.push(`    __effect(${effectCode});`);
+      lines.push(`    __effect(() => { ${effectCode}; });`);
     }
 
     lines.push('  }');
@@ -276,8 +284,10 @@ export function installComponentSupport(CodeGenerator) {
       if (Array.isArray(func) && (func[0] === '->' || func[0] === '=>')) {
         const [, params, methodBody] = func;
         const paramStr = Array.isArray(params) ? params.map(p => this.formatParam(p)).join(', ') : '';
-        const bodyCode = this.generateInComponent(methodBody, 'value');
-        lines.push(`  ${name}(${paramStr}) { return ${bodyCode}; }`);
+        const transformed = this.reactiveMembers ? this.transformComponentMembers(methodBody) : methodBody;
+        const isAsync = this.containsAwait(methodBody);
+        const bodyCode = this.generateFunctionBody(transformed, params || []);
+        lines.push(`  ${isAsync ? 'async ' : ''}${name}(${paramStr}) ${bodyCode}`);
       }
     }
 
@@ -285,8 +295,10 @@ export function installComponentSupport(CodeGenerator) {
     for (const { name, value } of lifecycleHooks) {
       if (Array.isArray(value) && (value[0] === '->' || value[0] === '=>')) {
         const [, , hookBody] = value;
-        const bodyCode = this.generateInComponent(hookBody, 'value');
-        lines.push(`  ${name}() { return ${bodyCode}; }`);
+        const transformed = this.reactiveMembers ? this.transformComponentMembers(hookBody) : hookBody;
+        const isAsync = this.containsAwait(hookBody);
+        const bodyCode = this.generateFunctionBody(transformed, []);
+        lines.push(`  ${isAsync ? 'async ' : ''}${name}() ${bodyCode}`);
       }
     }
 
@@ -428,9 +440,11 @@ export function installComponentSupport(CodeGenerator) {
         this._setupLines.push(`__effect(() => { ${textVar}.data = this.${str}.value; });`);
         return textVar;
       }
-      // Static tag without content
+      // Static tag without content (possibly with #id)
+      const [tagStr, idStr] = str.split('#');
       const elVar = this.newElementVar();
-      this._createLines.push(`${elVar} = document.createElement('${str}');`);
+      this._createLines.push(`${elVar} = document.createElement('${tagStr || 'div'}');`);
+      if (idStr) this._createLines.push(`${elVar}.id = '${idStr}';`);
       return elVar;
     }
 
@@ -448,9 +462,10 @@ export function installComponentSupport(CodeGenerator) {
       return this.generateChildComponent(headStr, rest);
     }
 
-    // HTML tag
+    // HTML tag (possibly with #id, e.g. div#content)
     if (headStr && this.isHtmlTag(headStr)) {
-      return this.generateTag(headStr, [], rest);
+      let [tagName, id] = headStr.split('#');
+      return this.generateTag(tagName || 'div', [], rest, id);
     }
 
     // Property chain (div.class or item.name)
@@ -471,10 +486,10 @@ export function installComponentSupport(CodeGenerator) {
         return slotVar;
       }
 
-      // HTML tag with classes (div.class)
-      const { tag, classes } = this.collectTemplateClasses(sexpr);
+      // HTML tag with classes (div.class) and optional #id
+      const { tag, classes, id } = this.collectTemplateClasses(sexpr);
       if (tag && this.isHtmlTag(tag)) {
-        return this.generateTag(tag, classes, []);
+        return this.generateTag(tag, classes, [], id);
       }
 
       // General property access (e.g., item.name in a loop)
@@ -494,13 +509,13 @@ export function installComponentSupport(CodeGenerator) {
         return this.generateDynamicTag(tag, classExprs, rest);
       }
 
-      const { tag, classes } = this.collectTemplateClasses(head);
+      const { tag, classes, id } = this.collectTemplateClasses(head);
       if (tag && this.isHtmlTag(tag)) {
         // Dynamic class syntax: div.("classes") → (. div __clsx) "classes"
         if (classes.length === 1 && classes[0] === '__clsx') {
           return this.generateDynamicTag(tag, rest, []);
         }
-        return this.generateTag(tag, classes, rest);
+        return this.generateTag(tag, classes, rest, id);
       }
     }
 
@@ -532,20 +547,12 @@ export function installComponentSupport(CodeGenerator) {
   };
 
   // --------------------------------------------------------------------------
-  // generateTag — HTML element with static classes and children
+  // appendChildren — shared child-processing loop for generateTag/generateDynamicTag
   // --------------------------------------------------------------------------
 
-  proto.generateTag = function(tag, classes, args) {
-    const elVar = this.newElementVar();
-    this._createLines.push(`${elVar} = document.createElement('${tag}');`);
-
-    if (classes.length > 0) {
-      this._createLines.push(`${elVar}.className = '${classes.join(' ')}';`);
-    }
-
+  proto.appendChildren = function(elVar, args) {
     for (const arg of args) {
-      // Arrow function = children
-      if (Array.isArray(arg) && (arg[0] === '->' || arg[0] === '=>')) {
+      if (this.is(arg, '->') || this.is(arg, '=>')) {
         const block = arg[2];
         if (this.is(block, 'block')) {
           for (const child of block.slice(1)) {
@@ -557,46 +564,47 @@ export function installComponentSupport(CodeGenerator) {
           this._createLines.push(`${elVar}.appendChild(${childVar});`);
         }
       }
-      // Object = attributes/events
       else if (this.is(arg, 'object')) {
         this.generateAttributes(elVar, arg);
       }
-      // String = text child
-      else if (typeof arg === 'string') {
+      else if (typeof arg === 'string' || arg instanceof String) {
         const textVar = this.newTextVar();
-        if (arg.startsWith('"') || arg.startsWith("'") || arg.startsWith('`')) {
-          this._createLines.push(`${textVar} = document.createTextNode(${arg});`);
-        } else if (this.reactiveMembers && this.reactiveMembers.has(arg)) {
-          this._createLines.push(`${textVar} = document.createTextNode('');`);
-          this._setupLines.push(`__effect(() => { ${textVar}.data = this.${arg}.value; });`);
-        } else if (this.componentMembers && this.componentMembers.has(arg)) {
-          this._createLines.push(`${textVar} = document.createTextNode(String(this.${arg}));`);
-        } else {
-          this._createLines.push(`${textVar} = document.createTextNode(String(${arg}));`);
-        }
-        this._createLines.push(`${elVar}.appendChild(${textVar});`);
-      }
-      // String object (from parser)
-      else if (arg instanceof String) {
         const val = arg.valueOf();
-        const textVar = this.newTextVar();
         if (val.startsWith('"') || val.startsWith("'") || val.startsWith('`')) {
           this._createLines.push(`${textVar} = document.createTextNode(${val});`);
         } else if (this.reactiveMembers && this.reactiveMembers.has(val)) {
           this._createLines.push(`${textVar} = document.createTextNode('');`);
           this._setupLines.push(`__effect(() => { ${textVar}.data = this.${val}.value; });`);
+        } else if (this.componentMembers && this.componentMembers.has(val)) {
+          this._createLines.push(`${textVar} = document.createTextNode(String(this.${val}));`);
         } else {
-          this._createLines.push(`${textVar} = document.createTextNode(String(${val}));`);
+          this._createLines.push(`${textVar} = document.createTextNode(${this.generateInComponent(arg, 'value')});`);
         }
         this._createLines.push(`${elVar}.appendChild(${textVar});`);
       }
-      // Other = nested element
       else if (arg) {
         const childVar = this.generateNode(arg);
         this._createLines.push(`${elVar}.appendChild(${childVar});`);
       }
     }
+  };
+
+  // --------------------------------------------------------------------------
+  // generateTag — HTML element with static classes and children
+  // --------------------------------------------------------------------------
 
+  proto.generateTag = function(tag, classes, args, id) {
+    const elVar = this.newElementVar();
+    this._createLines.push(`${elVar} = document.createElement('${tag}');`);
+
+    if (id) {
+      this._createLines.push(`${elVar}.id = '${id}';`);
+    }
+    if (classes.length > 0) {
+      this._createLines.push(`${elVar}.className = '${classes.join(' ')}';`);
+    }
+
+    this.appendChildren(elVar, args);
     return elVar;
   };
 
@@ -610,51 +618,13 @@ export function installComponentSupport(CodeGenerator) {
 
     if (classExprs.length > 0) {
       const classArgs = classExprs.map(e => this.generateInComponent(e, 'value')).join(', ');
-      const hasReactive = classExprs.some(e => this.hasReactiveDeps(e));
-      if (hasReactive) {
-        this._setupLines.push(`__effect(() => { ${elVar}.className = __clsx(${classArgs}); });`);
-      } else {
-        this._createLines.push(`${elVar}.className = __clsx(${classArgs});`);
-      }
-    }
-
-    for (const arg of children) {
-      const argHead = Array.isArray(arg) ? (arg[0] instanceof String ? arg[0].valueOf() : arg[0]) : null;
-      if (argHead === '->' || argHead === '=>') {
-        const block = arg[2];
-        const blockHead = Array.isArray(block) ? (block[0] instanceof String ? block[0].valueOf() : block[0]) : null;
-        if (blockHead === 'block') {
-          for (const child of block.slice(1)) {
-            const childVar = this.generateNode(child);
-            this._createLines.push(`${elVar}.appendChild(${childVar});`);
-          }
-        } else if (block) {
-          const childVar = this.generateNode(block);
-          this._createLines.push(`${elVar}.appendChild(${childVar});`);
-        }
-      }
-      else if (this.is(arg, 'object')) {
-        this.generateAttributes(elVar, arg);
-      }
-      else if (typeof arg === 'string' || arg instanceof String) {
-        const textVar = this.newTextVar();
-        const argStr = arg.valueOf();
-        if (argStr.startsWith('"') || argStr.startsWith("'") || argStr.startsWith('`')) {
-          this._createLines.push(`${textVar} = document.createTextNode(${argStr});`);
-        } else if (this.reactiveMembers && this.reactiveMembers.has(argStr)) {
-          this._createLines.push(`${textVar} = document.createTextNode('');`);
-          this._setupLines.push(`__effect(() => { ${textVar}.data = this.${argStr}.value; });`);
-        } else {
-          this._createLines.push(`${textVar} = document.createTextNode(${this.generateInComponent(arg, 'value')});`);
-        }
-        this._createLines.push(`${elVar}.appendChild(${textVar});`);
-      }
-      else {
-        const childVar = this.generateNode(arg);
-        this._createLines.push(`${elVar}.appendChild(${childVar});`);
-      }
+      // Dynamic classes are always wrapped in __effect — the .() syntax exists
+      // precisely for reactive class expressions. If a class were static, you'd
+      // just write div.foo.bar instead. The effect tracks signal reads at runtime.
+      this._setupLines.push(`__effect(() => { ${elVar}.className = __clsx(${classArgs}); });`);
     }
 
+    this.appendChildren(elVar, children);
     return elVar;
   };
 
@@ -688,6 +658,13 @@ export function installComponentSupport(CodeGenerator) {
           key = key.slice(1, -1);
         }
 
+        // Element ref: ref: "name" → this.name = element
+        if (key === 'ref') {
+          const refName = String(value).replace(/^["']|["']$/g, '');
+          this._createLines.push(`this.${refName} = ${elVar};`);
+          continue;
+        }
+
         // Two-way binding: __bind_value__ pattern
         if (key.startsWith(BIND_PREFIX) && key.endsWith(BIND_SUFFIX)) {
           const prop = key.slice(BIND_PREFIX.length, -BIND_SUFFIX.length);
@@ -1074,6 +1051,7 @@ export function installComponentSupport(CodeGenerator) {
 
     this._createLines.push(`${instVar} = new ${componentName}(${propsCode});`);
     this._createLines.push(`${elVar} = ${instVar}._create();`);
+    this._createLines.push(`(this._children || (this._children = [])).push(${instVar});`);
 
     this._setupLines.push(`if (${instVar}._setup) ${instVar}._setup();`);
 
@@ -1098,7 +1076,12 @@ export function installComponentSupport(CodeGenerator) {
         for (let i = 1; i < arg.length; i++) {
           const [key, value] = arg[i];
           if (typeof key === 'string') {
+            // Pass reactive members as signals (not values) for reactive prop binding.
+            // Child's __state passthrough returns the signal as-is — shared reactivity.
+            const prevReactive = this.reactiveMembers;
+            this.reactiveMembers = new Set();
             const valueCode = this.generateInComponent(value, 'value');
+            this.reactiveMembers = prevReactive;
             props.push(`${key}: ${valueCode}`);
           }
         }
@@ -1136,16 +1119,24 @@ export function installComponentSupport(CodeGenerator) {
   // --------------------------------------------------------------------------
 
   proto.hasReactiveDeps = function(sexpr) {
-    if (!this.reactiveMembers || this.reactiveMembers.size === 0) return false;
-
     if (typeof sexpr === 'string') {
-      return this.reactiveMembers.has(sexpr);
+      return !!(this.reactiveMembers && this.reactiveMembers.has(sexpr));
     }
 
     if (!Array.isArray(sexpr)) return false;
 
+    // Direct this.X — check reactive members
     if (sexpr[0] === '.' && sexpr[1] === 'this' && typeof sexpr[2] === 'string') {
-      return this.reactiveMembers.has(sexpr[2]);
+      return !!(this.reactiveMembers && this.reactiveMembers.has(sexpr[2]));
+    }
+
+    // Property chain through this (e.g., this.router.path, this.app.data.count)
+    // Props and members may hold reactive objects with signal-backed getters,
+    // so treat deeper this.X.Y chains as potentially reactive. The effect
+    // system handles actual tracking at runtime — wrapping a non-reactive
+    // chain in __effect just means it runs once with no overhead.
+    if (sexpr[0] === '.' && this._rootsAtThis(sexpr[1])) {
+      return true;
     }
 
     for (const child of sexpr) {
@@ -1155,6 +1146,15 @@ export function installComponentSupport(CodeGenerator) {
     return false;
   };
 
+  // _rootsAtThis — check if a property-access chain is rooted at 'this'
+  // --------------------------------------------------------------------------
+
+  proto._rootsAtThis = function(sexpr) {
+    if (typeof sexpr === 'string') return sexpr === 'this';
+    if (!Array.isArray(sexpr) || sexpr[0] !== '.') return false;
+    return this._rootsAtThis(sexpr[1]);
+  };
+
   // ==========================================================================
   // Component Runtime
   // ==========================================================================
@@ -1228,6 +1228,11 @@ class __Component {
     return this;
   }
   unmount() {
+    if (this._children) {
+      for (const child of this._children) {
+        child.unmount();
+      }
+    }
     if (this.unmounted) this.unmounted();
     if (this._root && this._root.parentNode) {
       this._root.parentNode.removeChild(this._root);

package/src/grammar/README.md

@@ -0,0 +1,234 @@
+# Solar & Lunar — Dual Parser Generators
+
+One grammar. Two parsers. Two fundamentally different parsing strategies.
+
+```
+grammar.rip ──→ Solar ──→ parser.js     (SLR(1) table-driven, 215KB)
+             └→ Lunar ──→ parser-rd.js  (predictive recursive descent, 110KB)
+```
+
+Both parsers accept the same token stream from the lexer and produce identical
+s-expression ASTs. They share no code at runtime — they are completely
+independent implementations derived from the same grammar specification.
+
+**Test parity:** 1,162 / 1,182 tests passing (98.3%) — 20 files at 100%.
+
+---
+
+## Files
+
+| File | Lines | Purpose |
+|------|-------|---------|
+| `grammar.rip` | 944 | Grammar specification — defines all syntax rules |
+| `solar.rip` | 926 | SLR(1) parser generator — produces table-driven parsers |
+| `lunar.rip` | 2,412 | Predictive recursive descent generator — produces PRD parsers |
+
+---
+
+## Grammar (`grammar.rip`)
+
+The grammar defines Rip's syntax as production rules with semantic actions.
+Each rule maps a pattern of tokens and nonterminals to an s-expression:
+
+```coffee
+# Assignment: Assignable = Expression → ["=", target, value]
+Assign: [
+  o 'Assignable = Expression'               , '["=", 1, 3]'
+  o 'Assignable = INDENT Expression OUTDENT' , '["=", 1, 4]'
+]
+
+# If/else: builds nested s-expression nodes
+IfBlock: [
+  o 'IF Expression Block'                    , '["if", 2, 3]'
+  o 'IfBlock ELSE IF Expression Block'       , '...'  # left-recursive chain
+]
+
+# Binary operators: Expression OP Expression with precedence
+Operation: [
+  o 'Expression + Expression'                , '["+", 1, 3]'
+  o 'Expression MATH Expression'             , '[2, 1, 3]'
+  o 'Expression ** Expression'               , '["**", 1, 3]'
+]
+```
+
+---
+
+## Solar (`solar.rip`) — SLR(1) Table Parser Generator
+
+Solar processes the grammar through a classic compiler-theory pipeline:
+
+```
+Grammar → Process Rules → Build LR Automaton → Compute FIRST/FOLLOW
+        → Build Parse Table → Resolve Conflicts → Generate Code
+```
+
+### What it produces
+
+A table-driven parser where every parsing decision is a lookup:
+`parseTable[state][symbol]` → shift, reduce, or accept. The parse table
+encodes 801 states with all transitions delta-compressed for minimal size.
+
+### How to use
+
+```bash
+bun src/grammar/solar.rip grammar.rip              # → parser.js (SLR table)
+bun src/grammar/solar.rip -r grammar.rip           # → parser-rd.js (PRD via Lunar)
+bun src/grammar/solar.rip --info grammar.rip       # Show grammar statistics
+bun src/grammar/solar.rip --sexpr grammar.rip      # Show grammar as s-expression
+```
+
+### Integration with Lunar
+
+Solar imports Lunar and installs it with one line:
+
+```coffee
+import { install as installLunar } from './lunar.rip'
+# ... (Generator class definition) ...
+installLunar Generator
+```
+
+This adds `generateRD()` to the Generator prototype. When `-r` is passed,
+Solar calls `generator.generateRD()` instead of `generator.generate()`.
+
+---
+
+## Lunar (`lunar.rip`) — Predictive Recursive Descent Generator
+
+Lunar analyzes the same grammar that Solar processes and generates a
+hand-rolled-looking recursive descent parser with Pratt expression parsing.
+
+### Architecture
+
+The generated parser has five layers:
+
+1. **Token management** — `advance()`, `expect()`, `match()`, `loc()`, `withLoc()`
+2. **Speculation** — `mark()`, `reset()`, `speculate()` for backtracking
+3. **Pratt expression parser** — `parseExpression(minBP)` with binding powers
+4. **Nonterminal functions** — one `parseX()` function per grammar nonterminal
+5. **Parser shell** — same API as the table parser (`parser.parse()`, exports)
+
+### How it works
+
+Lunar derives everything from the grammar — no hardcoded token or nonterminal
+names in the core generators:
+
+**Expression analysis** (`_analyzeExpressionRules`) — walks the grammar to detect:
+- Which nonterminal is the "expression" (contains Operation as an alternative)
+- Which is the "operation" (has the most `NT OP NT` binary rules with precedence)
+- Which is the "value" (pure choice nonterminal with the most atom alternatives)
+- Which is "code" (FIRST set contains `->` or `=>`)
+- Assignment operators (nonterminals where all rules are `LHS TOKEN RHS`)
+- Prefix starters (keyword tokens that begin expression alternatives)
+- Postfix chains (left-recursive property/index/call rules through Value chain)
+- Atom types (terminals reachable through the Value nonterminal chain)
+- Expression-handled tokens (for skipping redundant choice alternatives)
+
+**Pratt parser generation** (`_generateRDExpression`) — builds the while loop:
+- Prefix starters dispatch to keyword-led parsers (IF→parseIf, FOR→parseFor, etc.)
+- Assignment operators checked at binding power 0
+- Postfix operators from Operation rules (with INDENT/TERMINATOR variants)
+- Postfix chains from property/index/call rules (resolved to FIRST sets)
+- Infix binary operators with correct associativity and control-flow merging
+- Ternary operators
+- Postfix if/unless/while/until and comprehensions
+- Statement tokens (RETURN, STATEMENT) enter the Pratt loop for postfix patterns
+
+**Nonterminal classification** (`_classifyNonterminal`) — detects patterns:
+
+| Pattern | Detection | Example |
+|---------|-----------|---------|
+| `root` | Grammar start symbol | Root |
+| `body-list` | Left-recursive with TERMINATOR | Body, ComponentBody |
+| `comma-list` | Left-recursive with `,` | ArgList, ParamList |
+| `concat-list` | Left-recursive, no separator | Interpolations, Whens |
+| `left-rec-loop` | Self-referential with terminal continuation | IfBlock |
+| `expression` | Contains the operation nonterminal | Expression |
+| `operation` | Has binary operator rules | Operation |
+| `token` | Single rule, single terminal | Identifier, Property |
+| `keyword` | All rules start with unique terminals | Return, Def, Enum |
+| `choice` | All rules are single-nonterminal passthroughs | Value, Line, Statement |
+| `sequence` | Everything else | Assign, Catch, Block |
+
+**Shared prefix disambiguation** (`_generateRDSharedPrefix`) — handles rules
+that share a common beginning:
+- Optional chain detection with rule-length-based action dispatch
+- Same-token grouping with deeper disambiguation
+- Terminal and nonterminal suffix separation with FIRST set grouping
+- Empty-rule-as-default when nonterminal suffixes have FIRST checks
+
+**Speculation** — `mark()`/`reset()`/`speculate()` for grammar ambiguities:
+- Range vs Array: `[1..10]` vs `[1, 2, 3]` — try Range first
+- Slice vs Expression in INDEX_START: `arr[1..3]` vs `arr[0]`
+- Range vs destructuring in For: `for [1..5]` vs `for [a, b] as iter`
+- Terminal/nonterminal overlap: `...` as Splat vs expansion marker
+- Left-rec-loop lookahead: `ELSE IF` vs `ELSE Block` in IfBlock
+
+### Three specialized generators
+
+Three nonterminals (out of 93) have patterns that require multi-token lookahead
+and can't be handled by the generic generators:
+
+- **For** (34 rules) — FORIN/FOROF/FORAS variants with optional WHEN/BY in both orders
+- **Object** (5 rules) — comprehension vs regular object determined after parsing key:value
+- **AssignObj** (6 rules) — key:value vs key=default vs shorthand vs rest after parsing key
+
+90 of 93 nonterminals (96.8%) are generated purely from grammar analysis.
+
+### Remaining 20 test failures (98.3% → 100%)
+
+The remaining failures cluster into a few fixable categories:
+
+| Category | Tests | Root Cause |
+|----------|-------|------------|
+| **Array elisions** | 5 | `[,1]`, `[1,,3]` — ArgElisionList/Elision not parsed |
+| **Trailing comma** | 1 | `[1,2,]` — OptElisions at end of array |
+| **Export/Import edge** | 3 | `export { x }` without FROM, `export x ~= ...`, `import x, * as m` — deeper shared-prefix disambiguation generates duplicate conditions |
+| **Semicolons context** | 3 | `def foo(); 42` — Def/async without block body (CALL_END before Block) |
+| **Class patterns** | 2 | Class expression without name, `@bar:` static in class body |
+| **Postfix ternary** | 1 | `a = x if true else 0` — assignment context for postfix ternary |
+| **Other edge cases** | 5 | `invalid extends`, `array destructuring skip`, type alias, typed runtime |
+
+**Key fix needed for Export/Import:** The shared-prefix handler generates duplicate
+`else if` branches with identical conditions when two rules share a common prefix
+through nonterminals but diverge at a terminal after parsing (e.g., `} FROM` vs `}`).
+The inner terminal group disambiguator needs to check terminal continuation instead
+of generating separate branches.
+
+**Key fix needed for elisions:** The Array parser routes `[` to Range speculation
+then Array. Array uses ArgElisionList which calls Arg → Expression. But leading
+commas `[,1]` and sparse `[1,,3]` need the Elision nonterminal which the generic
+comma-list handler doesn't generate.
+
+---
+
+## Comparison
+
+| Aspect | Solar (SLR) | Lunar (PRD) |
+|--------|-------------|-------------|
+| Strategy | Bottom-up table lookup | Top-down predictive |
+| Output size | 215KB (encoded tables) | 110KB (readable code) |
+| Startup | Decode table on load | Zero initialization |
+| Debugging | "State 437" errors | Named function call stacks |
+| Correctness | Mathematically derived | Grammar-derived + 3 specializations |
+| Test parity | 1,235/1,235 (100%) | 1,162/1,182 (98.3%) |
+| Speed | O(n) tight loop | O(n) function calls |
+| Expressions | Shift/reduce with precedence | Pratt with binding powers |
+
+Both produce identical s-expressions for 98.3% of the test suite. Having two
+independent implementations from the same grammar provides cross-validation.
+
+---
+
+## The Innovation
+
+Most parser generators commit to one strategy: Yacc produces LALR tables,
+ANTLR produces LL recursive descent, PEG.js produces PEG parsers. Solar and
+Lunar generate **both** from a single grammar specification.
+
+The key insight: the FIRST/FOLLOW sets and operator precedence table that
+Solar computes for SLR(1) contain all the information a Pratt-based recursive
+descent parser needs. The data is the same — it's just read differently.
+Solar reads it as table entries. Lunar reads it as dispatch conditions and
+binding powers.
+
+Same grammar. Same semantics. Two fundamentally different parsers.