rip-lang 3.16.0 → 3.16.2

package/src/dts.js

@@ -36,11 +36,11 @@ export const INTRINSIC_TYPE_DECLS = [
   "type __RipAttrKeys<T> = { [K in keyof T]-?: K extends 'style' | 'classList' | 'className' | 'nodeValue' | 'textContent' | 'innerHTML' | 'innerText' | 'outerHTML' | 'outerText' | 'scrollLeft' | 'scrollTop' ? never : K extends `on${string}` | `aria${string}Element` | `aria${string}Elements` ? never : T[K] extends (...args: any[]) => any ? never : (<V>() => V extends Pick<T, K> ? 1 : 2) extends (<V>() => V extends { -readonly [P in K]: T[P] } ? 1 : 2) ? K : never }[keyof T] & string;",
   "type __RipEvents<K extends __RipTag> = { [E in keyof HTMLElementEventMap as `@${E}`]?: ((event: RipEvent<HTMLElementEventMap[E], __RipElementMap[K]>) => void) | null };",
   'type RipEvent<E extends Event, T extends EventTarget> = E & { readonly target: T; readonly currentTarget: T };',
-  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[];',
+  'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean | null | undefined> | __RipClassValue[];',
   "type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents<K> & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };",
 ];
 
-export const INTRINSIC_FN_DECL = 'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;';
+export const INTRINSIC_FN_DECL = 'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;\ndeclare function __ripRoute<const T extends string>(s: T): T;';
 
 export const ARIA_TYPE_DECLS = [
   'type __RipAriaNavHandlers = { next?: () => void; prev?: () => void; first?: () => void; last?: () => void; select?: () => void; dismiss?: () => void; tab?: () => void; char?: () => void; };',
@@ -67,12 +67,23 @@ export const SIGNAL_FN = 'declare function __state<T>(value: T | Signal<T>): Sig
 export const COMPUTED_INTERFACE = 'interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }';
 export const COMPUTED_FN = 'declare function __computed<T>(fn: () => T): Computed<T>;';
 export const EFFECT_FN = 'declare function __effect(fn: () => void | (() => void)): () => void;';
+export const BATCH_FN = 'declare function __batch<T>(fn: () => T): T;';
+
+// Names destructured from `globalThis.__rip` in the source. The DTS
+// preamble and the post-compile `declare function` injection both need
+// to skip auto-declaring these names — the explicit binding shadows the
+// global and would otherwise trip TS2630.
+export function ripDestructuredNames(source) {
+  if (typeof source !== 'string') return new Set();
+  const inside = (source.match(/\{\s*([^}]*?)\s*\}\s*=\s*globalThis\.__rip\b/) || [])[1] || '';
+  return new Set(inside.split(',').map(s => s.trim().split(/[:\s]/)[0]).filter(Boolean));
+}
 
 // ============================================================================
 // emitTypes — generate .d.ts from annotated tokens + s-expression tree
 // ============================================================================
 
-export function emitTypes(tokens, sexpr = null, source = '') {
+export function emitTypes(tokens, sexpr = null, source = '', schemaBehavior = null, schemaAnon = null) {
   let lines = [];
   let indentLevel = 0;
   let indentStr = '  ';
@@ -82,7 +93,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   let classFields = new Set(); // Track emitted field names to avoid duplicates
   let usesSignal = false;
   let usesComputed = false;
+  let usesBatch = false;
   let usesRipIntrinsicProps = false;
+  const explicitlyBound = ripDestructuredNames(source);
   const sourceLines = typeof source === 'string' ? source.split('\n') : [];
 
   // Pre-scan: detect reactive operators regardless of type annotations.
@@ -92,6 +105,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     const tag = tokens[i][0];
     if (tag === 'REACTIVE_ASSIGN') usesSignal = true;
     else if (tag === 'COMPUTED_ASSIGN') usesComputed = true;
+    else if (tag === 'IDENTIFIER' && tokens[i][1] === '__batch') usesBatch = true;
   }
 
   // Format { prop; prop } into multi-line block.  Only applies when the
@@ -195,7 +209,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           let type = tokens[j].data?.type;
           if (type) hasAnyType = true;
           let hasDefault = tokens[j + 1]?.[0] === '=';
-          props.push({ kind: 'rename', propName, localName, type: type ? expandSuffixes(type) : null, hasDefault });
+          props.push({ kind: 'rename', propName, localName, type: type ? tsType(type) : null, hasDefault });
           j++;
           if (hasDefault) j = skipDefault(tokens, j);
         }
@@ -208,7 +222,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let type = tokens[j].data?.type;
         if (type) hasAnyType = true;
         let hasDefault = tokens[j + 1]?.[0] === '=';
-        props.push({ kind: 'simple', propName: name, type: type ? expandSuffixes(type) : null, hasDefault });
+        props.push({ kind: 'simple', propName: name, type: type ? tsType(type) : null, hasDefault });
         j++;
         if (hasDefault) j = skipDefault(tokens, j);
         continue;
@@ -259,7 +273,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let name = tokens[j][1];
         let type = tokens[j].data?.type;
         names.push(name);
-        elemTypes.push(type ? expandSuffixes(type) : null);
+        elemTypes.push(type ? tsType(type) : null);
         if (type) hasAnyType = true;
       }
       j++;
@@ -308,8 +322,8 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           let name = tokens[j][1];
           let type = tokens[j].data?.type;
           let paramName = subclassConstructor ? `_${name}` : name;
-          params.push(type ? `${paramName}: ${expandSuffixes(type)}` : paramName);
-          if (type) fields.push({ name, type: expandSuffixes(type) });
+          params.push(type ? `${paramName}: ${tsType(type)}` : paramName);
+          if (type) fields.push({ name, type: tsType(type) });
           j++;
         }
         continue;
@@ -321,7 +335,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         if (tokens[j]?.[0] === 'IDENTIFIER') {
           let name = tokens[j][1];
           let type = tokens[j].data?.type;
-          params.push(type ? `...${name}: ${expandSuffixes(type)}` : `...${name}: any[]`);
+          params.push(type ? `...${name}: ${tsType(type)}` : `...${name}: any[]`);
           j++;
         }
         continue;
@@ -364,9 +378,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           hasDefault = true;
         }
 
-        let isOptional = hasDefault || tok.data?.predicate;
+        let isOptional = hasDefault || tok.data?.optional;
         if (paramType) {
-          params.push(`${paramName}${isOptional ? '?' : ''}: ${expandSuffixes(paramType)}`);
+          params.push(`${paramName}${isOptional ? '?' : ''}: ${tsType(paramType)}`);
         } else {
           params.push(paramName);
         }
@@ -486,7 +500,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let nameToken = ot[1]; // DEF is [0], name is [1]
         let { params: paramList } = collectParams(ot, 2);
         let returnType = nameToken.data?.returnType;
-        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+        let ret = returnType ? `: ${tsType(returnType)}` : '';
         let declare = inClass ? '' : (exp ? '' : 'declare ');
         let typeParams = data.typeParams || '';
         if (inClass) {
@@ -498,7 +512,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let ext = data.extends ? ` extends ${data.extends}` : '';
         emitBlock(`${exp}interface ${data.name}${params}${ext} `, data.typeText || '{}', '');
       } else {
-        let typeText = expandSuffixes(data.typeText || '');
+        let typeText = tsType(data.typeText || '');
         emitBlock(`${exp}type ${data.name}${params} = `, typeText, ';');
       }
       continue;
@@ -594,7 +608,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       if (!nameToken) continue;
       let fnName = nameToken[1];
       let returnType = nameToken.data?.returnType;
-      if (!returnType && nameToken.data?.await === true) returnType = 'void';
+      if (!returnType && nameToken.data?.bang === true) returnType = 'void';
       let typeParams = nameToken.data?.typeParams || '';
 
       let { params, endIdx } = collectParams(tokens, i + 2);
@@ -603,7 +617,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
       if (returnType || params.some(p => p.includes(':'))) {
         let exp = exported ? 'export ' : '';
         let declare = inClass ? '' : (exported ? '' : 'declare ');
-        let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+        let ret = returnType ? `: ${tsType(returnType)}` : '';
         let paramStr = params.join(', ');
         if (inClass) {
           lines.push(`${indent()}${fnName}${typeParams}(${paramStr})${ret};`);
@@ -664,7 +678,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           }
 
           if (returnType || params.some(p => p.includes(':'))) {
-            let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+            let ret = returnType ? `: ${tsType(returnType)}` : '';
             let paramStr = params.join(', ');
             // Emit field declarations for constructor @param:: type shorthand
             if (methodName === 'constructor' && fields.length) {
@@ -717,7 +731,12 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     //
     // The function-form is wrong inside bodies because it would create
     // a phantom global that shadows / collides with the actual local.
-    if (tag === 'IDENTIFIER' && !inClass &&
+    //
+    // If the IDENTIFIER carries an explicit `name:: T = arrow` annotation,
+    // skip this path and let the typed-variable-assignment path below
+    // emit the typed form (otherwise we'd lose the user's annotation in
+    // favor of inferred `any` rest-param emission).
+    if (tag === 'IDENTIFIER' && !inClass && !t.data?.type &&
         tokens[i + 1]?.[0] === '=' &&
         (tokens[i + 2]?.[0] === 'PARAM_START' || tokens[i + 2]?.[0] === '(')) {
       let fnName = t[1];
@@ -741,7 +760,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         let paramStr = params.join(', ');
         if (bodyDepth === 0) {
           let declare = exported ? '' : 'declare ';
-          let ret = returnType ? `: ${expandSuffixes(returnType)}` : '';
+          let ret = returnType ? `: ${tsType(returnType)}` : '';
           lines.push(`${indent()}${exp}${declare}function ${fnName}(${paramStr})${ret};`);
         } else {
           // `any` rather than `unknown` for the inferred-return case.
@@ -751,7 +770,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           // user didn't provide one. `unknown` would force callers to
           // narrow before using the result, creating new false
           // positives at every call site.
-          let ret = returnType ? expandSuffixes(returnType) : 'any';
+          let ret = returnType ? tsType(returnType) : 'any';
           lines.push(`${indent()}let ${fnName}: (${paramStr}) => ${ret};`);
         }
         continue;
@@ -761,7 +780,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     // Variable assignments with type annotations
     if (tag === 'IDENTIFIER' && t.data?.type) {
       let varName = t[1];
-      let type = expandSuffixes(t.data.type);
+      let type = tsType(t.data.type);
       let next = tokens[i + 1];
 
       if (next) {
@@ -778,6 +797,12 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           lines.push(`${indent()}${exp}${declare}const ${varName}: Computed<${type}>;`);
         } else if (next[0] === 'EFFECT') {
           lines.push(`${indent()}${exp}${declare}const ${varName}: () => void;`);
+        } else if (next[0] === 'GATE') {
+          // Render-ready gate (<~) — only valid inside component
+          // bodies, where the component stub (not this hoist) types the
+          // binding. Explicit no-op so an annotated gate never falls
+          // through to the `=` arrow-scan below.
+          continue;
         } else if (next[0] === '=') {
           // Check if RHS is an arrow function with return type
           let arrowIdx = i + 2;
@@ -795,14 +820,23 @@ export function emitTypes(tokens, sexpr = null, source = '') {
           if (arrowToken && (arrowToken[0] === '->' || arrowToken[0] === '=>') &&
               arrowToken.data?.returnType) {
             // Typed arrow function assignment
-            let returnType = expandSuffixes(arrowToken.data.returnType);
+            let returnType = tsType(arrowToken.data.returnType);
             let { params } = collectParams(tokens, i + 2);
             let paramStr = params.join(', ');
             lines.push(`${indent()}${exp}${declare}function ${varName}(${paramStr}): ${returnType};`);
           } else if (inClass) {
             lines.push(`${indent()}${varName}: ${type};`);
             classFields.add(varName);
-          } else {
+          } else if (bodyDepth === 0) {
+            // Module-scope typed binding: typecheck.js's inline-let pass
+            // merges this header line into the body's hoist by NAME. That
+            // name-based merge is only sound at module scope — for a
+            // function-local (`bodyDepth > 0`) the same name can exist
+            // untyped in sibling functions, and the merge would stamp this
+            // annotation onto every one of them. Function-locals don't
+            // need the header line anyway: the compiler's typed-local
+            // hoist (collectTypedLocals) annotates the owning function's
+            // own `let` in the body, scope-correctly.
             lines.push(`${indent()}${exp}let ${varName}: ${type};`);
           }
         } else if (inClass) {
@@ -833,7 +867,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
     // Schema declarations — strip any prior auto-emitted `declare let Foo`
     // for the same bindings (they are re-emitted as typed Schema<T>).
     let schemaLines = [];
-    hasSchemaDecls = emitSchemaTypes(sexpr, schemaLines);
+    hasSchemaDecls = emitSchemaTypes(sexpr, schemaLines, schemaBehavior, schemaAnon);
     if (hasSchemaDecls) {
       let bindings = new Set();
       for (let line of schemaLines) {
@@ -860,15 +894,18 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   }
   if (usesSignal) {
     preamble.push(SIGNAL_INTERFACE);
-    preamble.push(SIGNAL_FN);
+    if (!explicitlyBound.has('__state')) preamble.push(SIGNAL_FN);
   }
   if (usesComputed) {
     preamble.push(COMPUTED_INTERFACE);
-    preamble.push(COMPUTED_FN);
+    if (!explicitlyBound.has('__computed')) preamble.push(COMPUTED_FN);
   }
-  if (usesSignal || usesComputed) {
+  if ((usesSignal || usesComputed) && !explicitlyBound.has('__effect')) {
     preamble.push(EFFECT_FN);
   }
+  if ((usesSignal || usesComputed || usesBatch) && !explicitlyBound.has('__batch')) {
+    preamble.push(BATCH_FN);
+  }
   if (hasSchemaDecls) {
     preamble.push(...SCHEMA_INTRINSIC_DECLS);
   }
@@ -880,25 +917,16 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 }
 
 // ============================================================================
-// Suffix expansion — Rip type suffixes to TypeScript
+// Convert a Rip type expression to its TypeScript form.
 // ============================================================================
+//
+// Today this only strips the `::` annotation sigil to `:`. Kept as a
+// dedicated function so every call site routes through one place if the
+// conversion ever needs to grow.
 
-function expandSuffixes(typeStr) {
+function tsType(typeStr) {
   if (!typeStr) return typeStr;
-
-  // Convert :: to : (annotation sigil to type separator)
-  typeStr = typeStr.replace(/::/g, ':');
-
-  // T?? → T | null | undefined
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\?\?/g, '$1 | null | undefined');
-
-  // T? → T | undefined (but not ?. or ?: which are different)
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\?(?![.:])/g, '$1 | undefined');
-
-  // T! → NonNullable<T>
-  typeStr = typeStr.replace(/(\w+(?:<[^>]+>)?)\!/g, 'NonNullable<$1>');
-
-  return typeStr;
+  return typeStr.replace(/::/g, ':');
 }
 
 // ============================================================================
@@ -992,18 +1020,18 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
       if (!Array.isArray(member)) continue;
       let mHead = member[0]?.valueOf?.() ?? member[0];
 
-      let target, propName, isProp, type, hasDefault;
+      let target, propName, isProp, type, optional;
 
       if (mHead === 'state' || mHead === 'readonly' || mHead === 'computed') {
         target = member[1];
         isProp = Array.isArray(target) && (target[0]?.valueOf?.() ?? target[0]) === '.' && (target[1]?.valueOf?.() ?? target[1]) === 'this';
         propName = isProp ? (target[2]?.valueOf?.() ?? target[2]) : (target?.valueOf?.() ?? target);
         type = isProp ? target[2]?.type : target?.type;
-        hasDefault = true;
+        optional = isProp ? !!target[2]?.optional : !!target?.optional;
         if (!isProp) {
           componentVars.add(propName);
           let wrapper = (mHead === 'computed') ? 'Computed' : 'Signal';
-          let typeStr = type ? expandSuffixes(type) : (inferLiteralType(member[2]) || 'any');
+          let typeStr = type ? tsType(type) : (inferLiteralType(member[2]) || 'any');
           bodyMembers.push(`  ${propName}: ${wrapper}<${typeStr}>;`);
           continue;
         }
@@ -1011,7 +1039,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
         isProp = (member[1]?.valueOf?.() ?? member[1]) === 'this';
         propName = isProp ? (member[2]?.valueOf?.() ?? member[2]) : null;
         type = isProp ? member[2]?.type : null;
-        hasDefault = false;
+        optional = isProp ? !!member[2]?.optional : false;
         if (!isProp && propName) componentVars.add(propName);
       } else if (mHead === 'object') {
         // Method definitions: (object (: methodName (-> (params...) (block ...))))
@@ -1041,7 +1069,7 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
           for (let p of params) {
             let { inner, hasDefault } = unwrapDefault(p);
             let pName = inner?.valueOf?.() ?? inner;
-            let pType = inner?.type ? expandSuffixes(inner.type) : 'any';
+            let pType = inner?.type ? tsType(inner.type) : 'any';
             // Defaulted params are optional in the type signature so callers
             // may omit them.
             let opt = hasDefault ? '?' : '';
@@ -1060,9 +1088,11 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
 
       if (!isProp || !propName) continue;
 
-      let typeStr = type ? expandSuffixes(type) : 'any';
-      let opt = hasDefault ? '?' : '';
-      if (!hasDefault) hasRequired = true;
+      let typeStr = type ? tsType(type) : 'any';
+      // `?` on the prop name is the sole optionality marker;
+      // `:=` defaults do not imply optionality.
+      let opt = optional ? '?' : '';
+      if (!optional) hasRequired = true;
       publicProps.push(`    ${propName}${opt}: ${typeStr};`);
       if (mHead === 'state') {
         publicProps.push(`    __bind_${propName}__?: Signal<${typeStr}>;`);

package/src/grammar/README.md

@@ -1,27 +1,25 @@
-# Solar & Lunar — Dual Parser Generators
+# Solar — Rip's Parser Generator
 
-One grammar. Two parsers. Two fundamentally different parsing strategies.
+One grammar. One parser. Mathematically derived.
 
 ```
-grammar.rip ──→ Solar ──→ parser.js     (SLR(1) table-driven, 215KB)
-             └→ Lunar ──→ parser-rd.js  (predictive recursive descent, 110KB)
+grammar.rip ──→ Solar ──→ parser.js   (SLR(1) table-driven)
 ```
 
-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%.
+The parser accepts the token stream from the lexer and produces s-expression
+ASTs — simple arrays like `["=", "x", 42]` — that the code emitter consumes.
 
 ---
 
 ## Files
 
-| File | Lines | Purpose |
-|------|-------|---------|
-| `grammar.rip` | 944 | Grammar specification — defines all syntax rules |
-| `solar.rip` | 929 | SLR(1) parser generator — produces table-driven parsers |
-| `lunar.rip` | 2,412 | Predictive recursive descent generator — produces PRD parsers |
+| File | Purpose |
+|------|---------|
+| `grammar.rip` | Grammar specification — defines all syntax rules |
+| `solar.rip` | SLR(1) parser generator — produces the table-driven parser |
+
+`src/parser.js` is the generated output. Never edit it by hand — regenerate
+with `bun run parser` after any grammar change.
 
 ---
 
@@ -51,6 +49,13 @@ Operation: [
 ]
 ```
 
+Action format:
+
+- Numbers (`1`, `2`, `...3`) reference matched symbols by position
+- `...N` spreads the array at position N
+- String literals become s-expression nodes: `'["if", 2, 3]'`
+- Default action (no action given) returns position 1
+
 ---
 
 ## Solar (`solar.rip`) — SLR(1) Table Parser Generator
@@ -66,169 +71,23 @@ Grammar → Process Rules → Build LR Automaton → Compute FIRST/FOLLOW
 
 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.
+encodes all states with transitions delta-compressed for minimal size.
 
 ### How to use
 
 ```bash
+bun run parser                                     # Regenerate src/parser.js
 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 --info --conflicts grammar.rip  # Conflict details
 bun src/grammar/solar.rip --sexpr grammar.rip      # Show grammar as s-expression
+bun src/grammar/solar.rip -o out.js grammar.rip    # Custom output path
 ```
 
-### 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, Cases |
-| `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.
+### Workflow for grammar changes
 
-Same grammar. Same semantics. Two fundamentally different parsers.
+1. Edit `src/grammar/grammar.rip`
+2. Run `bun run parser`
+3. Verify the new parse shape with `echo 'code' | ./bin/rip -s`
+4. Update codegen in `src/compiler.js` if the node shape changed
+5. Run `bun run test`

package/src/grammar/grammar.rip

@@ -96,6 +96,7 @@ grammar =
     o 'ComputedAssign'
     o 'ReadonlyAssign'
     o 'Effect'
+    o 'Gate'
     o 'If'
     o 'Try'
     o 'While'
@@ -233,6 +234,13 @@ grammar =
     o 'Assignable READONLY_ASSIGN INDENT Expression OUTDENT', '["readonly", 1, 4]'
   ]
 
+  # Render-ready gate (<~) — load-before-render binding; component bodies only.
+  # One form on purpose: the RHS must be a one-line literal stash path, so the
+  # compiler can hoist it into the component's static gate-set.
+  Gate: [
+    o 'Assignable GATE Expression', '["gate", 1, 3]'
+  ]
+
   # Reactive effect (~>) — side effects that run when dependencies change
   Effect: [
     o 'Assignable EFFECT Expression'               , '["effect", 1, 3]'
@@ -592,14 +600,15 @@ grammar =
     o 'INDENT Body OUTDENT', '["block", ...2]'
   ]
 
-  # Parenthetical mark-up: when the inner expression is a single `=` assignment,
-  # tag it with `.parenthesized = true` so the codegen ternary-hoist doesn't
-  # silently turn `(x = "a") if cond else "b"` (conditional assign) into
-  # `x = (cond ? "a" : "b")` (unconditional). The marker is harmless for any
-  # other consumer; it's just a flag the hoist consults.
+  # Parenthetical mark-up: tag a single parenthesized expression with
+  # `.parenthesized = true`. Consumers that respect explicit grouping
+  # consult it: the codegen ternary-hoist (so `(x = "a") if cond else "b"`
+  # stays a conditional assign) and comparison chaining (so
+  # `(a == b) == c` compares the boolean instead of chaining). The marker
+  # is harmless for any other consumer.
   Parenthetical: [
-    o '( Body )'               , '$2.length === 1 ? (Array.isArray($2[0]) && $2[0][0] === "=" && ($2[0].parenthesized = true), $2[0]) : ["block", ...$2]'
-    o '( INDENT Body OUTDENT )', '$3.length === 1 ? (Array.isArray($3[0]) && $3[0][0] === "=" && ($3[0].parenthesized = true), $3[0]) : ["block", ...$3]'
+    o '( Body )'               , '$2.length === 1 ? (Array.isArray($2[0]) && ($2[0].parenthesized = true), $2[0]) : ["block", ...$2]'
+    o '( INDENT Body OUTDENT )', '$3.length === 1 ? (Array.isArray($3[0]) && ($3[0].parenthesized = true), $3[0]) : ["block", ...$3]'
   ]
 
   OptComma: [
@@ -1004,9 +1013,6 @@ grammar =
     o 'Expression || Expression'      , '["||", 1, 3]'
     o 'Expression ?? Expression'      , '["??", 1, 3]'
 
-    # Pipe
-    o 'Expression PIPE Expression'    , '["|>", 1, 3]'
-
     # Relational
     o 'Expression RELATION Expression', '[2, 1, 3]'     # in, of, instanceof
 
@@ -1046,8 +1052,7 @@ operators = """
   left        ^
   left        |
   left        &&
-  left        ||
-  left        PIPE
+  left        || ??
   right       TERNARY
   nonassoc    INDENT OUTDENT
   right       YIELD