rip-lang 3.13.134 → 3.13.135

package/src/components.js

@@ -724,7 +724,7 @@ export function installComponentSupport(CodeEmitter, Lexer) {
       } else if (op === 'computed') {
         const varName = getMemberName(stmt[1]);
         if (varName) {
-          derivedVars.push({ name: varName, expr: stmt[2] });
+          derivedVars.push({ name: varName, expr: stmt[2], type: getMemberType(stmt[1]) });
           memberNames.add(varName);
           reactiveMembers.add(varName);
         }
@@ -803,8 +803,9 @@ export function installComponentSupport(CodeEmitter, Lexer) {
         .replace(/(\w+(?:<[^>]+>)?)\!/g, 'NonNullable<$1>') : null;
 
       const sl = [];
-      sl.push('class {');
-      sl.push('  declare _root: Element | null;');
+      const componentTypeParams = this._componentTypeParams || '';
+      sl.push(`class ${componentTypeParams}{`);
+      sl.push('  declare _root: Element | null; declare app: any;');
       sl.push('  emit(_name: string, _detail?: any): void {}');
 
       // Constructor — typed props for public state/readonly (matches DTS)
@@ -849,14 +850,16 @@ export function installComponentSupport(CodeEmitter, Lexer) {
         const ts = expandType(type) || inferLiteralType(value);
         sl.push(ts ? `  declare ${name}: ${ts};` : `  declare ${name}: any;`);
       }
-      for (const { name, expr } of derivedVars) {
+      for (const { name, expr, type } of derivedVars) {
+        const ts = expandType(type);
+        const typeAnnot = ts ? `: Computed<${ts}>` : '';
         if (this.is(expr, 'block')) {
           const transformed = this.transformComponentMembers(expr);
           const body = this.emitFunctionBody(transformed);
-          sl.push(`  ${name} = __computed(() => ${body});`);
+          sl.push(`  ${name}${typeAnnot} = __computed(() => ${body});`);
         } else {
           const val = this.emitInComponent(expr, 'value');
-          sl.push(`  ${name} = __computed(() => ${val});`);
+          sl.push(`  ${name}${typeAnnot} = __computed(() => ${val});`);
         }
       }
 
@@ -975,6 +978,7 @@ export function installComponentSupport(CodeEmitter, Lexer) {
       if (renderBlock) {
         const constructions = [];
         let constructionIdx = 0;
+        const sourceLines = this.options.source?.split('\n');
         const extractProps = (args) => {
           const props = [];
           for (const arg of args) {
@@ -1031,7 +1035,14 @@ export function installComponentSupport(CodeEmitter, Lexer) {
                   const val = this.emitInComponent(value, 'value');
                   props.push({ code: `'${eventKey}': ${val}`, srcLine });
                 } else if (typeof key === 'string') {
-                  if (key === 'key') continue;
+                  if (key === 'key') {
+                    // key: is not an HTML attribute, but emit its value
+                    // expression for type-checking and semantic tokens
+                    const val = this.emitInComponent(value, 'value');
+                    const marker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+                    constructions.push(`    (${val});${marker}`);
+                    continue;
+                  }
                   if (key.startsWith('__bind_') && key.endsWith('__')) {
                     const propName = key.slice(7, -2);
                     const val = this.emitInComponent(value, 'value');
@@ -1049,6 +1060,146 @@ export function installComponentSupport(CodeEmitter, Lexer) {
         const walkRender = (node) => {
           if (!Array.isArray(node)) return;
           const head = node[0]?.valueOf?.() ?? node[0];
+
+          // Object nodes are property bags (key-value pairs) — their values
+          // are code expressions (event handlers, bindings, literals), not
+          // render template. extractIntrinsicProps handles them separately.
+          // Walking into them would treat function bodies as template content
+          // (e.g. `@blur: (e) -> p(e)` would emit `e;` and `__ripEl('p')`).
+          if (head === 'object') return;
+
+          // Type-check conditional and loop expressions in render blocks.
+          // Without this, `if labelz` (a typo for `label`) silently evaluates
+          // as undefined and skips the block — the condition goes unchecked.
+          // Similarly, `switch statusz` and `for item in itemsz` go unchecked.
+          if (head === 'if' || head === 'unless') {
+            const condition = node[1];
+            if (condition != null) {
+              const condCode = this.emitInComponent(condition, 'value');
+              const srcLine = node.loc?.r;
+              const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+              constructions.push(`    ${condCode};${srcMarker}`);
+            }
+          } else if (head === '?:') {
+            // Emit the full ternary so all branches are type-checked
+            const ternCode = this.emitInComponent(node, 'value');
+            const srcLine = node.loc?.r;
+            const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+            constructions.push(`    ${ternCode};${srcMarker}`);
+          } else if (head === 'switch') {
+            const discriminant = node[1];
+            if (discriminant != null) {
+              const discCode = this.emitInComponent(discriminant, 'value');
+              const srcLine = node.loc?.r;
+              const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+              constructions.push(`    ${discCode};${srcMarker}`);
+            }
+          } else if (head === 'for-in' || head === 'for-of' || head === 'for-as') {
+            // Emit a real for-loop so the loop variable is in scope for the body.
+            // node: [head, vars, iterable, step, guard, body]
+            const vars = node[1];
+            const iterable = node[2];
+            if (iterable != null) {
+              const iterCode = this.emitInComponent(iterable, 'value');
+              const srcLine = node.loc?.r;
+              const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+              // Extract loop variable pattern
+              let varPattern;
+              if (Array.isArray(vars)) {
+                if (vars.length === 1) {
+                  const v = vars[0];
+                  varPattern = Array.isArray(v) ? this.emitDestructuringPattern(v) : String(v);
+                } else if (head === 'for-of') {
+                  // for key, val of obj — destructure as [key, val] from Object.entries
+                  varPattern = `[${vars.map(v => String(v)).join(', ')}]`;
+                } else {
+                  // for item, index in arr — first is the item
+                  varPattern = String(vars[0]);
+                }
+              } else {
+                varPattern = String(vars);
+              }
+              if (head === 'for-of') {
+                constructions.push(`    for (const ${varPattern} of Object.entries(${iterCode})) {${srcMarker}`);
+              } else {
+                constructions.push(`    for (const ${varPattern} of ${iterCode}) {${srcMarker}`);
+              }
+              // Walk body children (indices 3+ may contain guard, body, etc.)
+              for (let bi = 3; bi < node.length; bi++) {
+                if (node[bi] != null) walkRender(node[bi]);
+              }
+              constructions.push(`    }`);
+              return; // Don't walk children again below
+            }
+          } else if (head === '__text__') {
+            // = expr — text expression: emit the expression for type-checking
+            const textExpr = node[1];
+            if (textExpr != null) {
+              const exprCode = this.emitInComponent(textExpr, 'value');
+              const srcLine = node.loc?.r;
+              const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+              constructions.push(`    ${exprCode};${srcMarker}`);
+            }
+          }
+
+          // Emit a bare lowercase identifier as either a property access
+          // (component member used as text), __ripEl (tag name check when at
+          // block level), or a plain variable reference (text child of a tag).
+          const emitBareIdent = (child, parentNode, isTextChild) => {
+            if (typeof child !== 'string' || !/^[a-z][\w-]*$/.test(child)) return;
+            if (CodeEmitter.GENERATORS[child]) return;
+            if (child === 'null' || child === 'undefined' || child === 'true' || child === 'false') return;
+            let srcLine = parentNode.loc?.r;
+            if (srcLine != null && sourceLines) {
+              const re = new RegExp(`\\b${child}\\b`);
+              for (let ln = srcLine; ln < sourceLines.length; ln++) {
+                if (re.test(sourceLines[ln])) { srcLine = ln; break; }
+              }
+            }
+            const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+            if (this.componentMembers && this.componentMembers.has(child)) {
+              constructions.push(`    this.${child};${srcMarker}`);
+            } else if (isTextChild) {
+              // Text child of a tag — emit as variable reference so TS
+              // reports "Cannot find name 'x'" instead of "not a known element"
+              constructions.push(`    ${child};${srcMarker}`);
+            } else {
+              constructions.push(`    __ripEl('${child}');${srcMarker}`);
+            }
+          };
+
+          // Bare lowercase identifiers inside a block or as children of tag nodes
+          // — emit __ripEl so TS catches tag typos (e.g., slotz for slot), or
+          // emit this.prop for component member text references.
+          const isTagHead = typeof head === 'string' && /^[a-z][\w-]*$/.test(head) &&
+              !CodeEmitter.GENERATORS[head] && TEMPLATE_TAGS.has(head.split(/[.#]/)[0]);
+          if (head === 'block') {
+            for (let i = 1; i < node.length; i++) emitBareIdent(node[i], node, false);
+          } else if (isTagHead) {
+            for (let i = 1; i < node.length; i++) emitBareIdent(node[i], node, true);
+            // Emit expression children of intrinsic tags for type-checking.
+            // Without this, text content like "#{item.name}" in `li "#{item.name}"`
+            // is invisible to TypeScript and loop variables appear unused (TS 6133).
+            for (let i = 1; i < node.length; i++) {
+              const child = node[i];
+              if (!Array.isArray(child)) continue;
+              const ch = child[0]?.valueOf?.() ?? child[0];
+              if (ch === 'object' || ch === 'block' || ch === '__text__') continue;
+              if (typeof ch === 'string') {
+                if (/^[A-Z]/.test(ch)) continue;
+                if (TEMPLATE_TAGS.has(ch.split(/[.#]/)[0])) continue;
+                if (/^[a-z][\w-]*$/.test(ch) && !CodeEmitter.GENERATORS[ch]) continue;
+                if (/^(if|unless|switch|for-in|for-of|for-as|while|until|loop|loop-n|try|throw|break|continue|break-if|continue-if|control|when|return|def|->|=>|class|enum|state|computed|readonly|effect|=|program)$/.test(ch)) continue;
+              }
+              try {
+                const exprCode = this.emitInComponent(child, 'value');
+                const srcLine = child.loc?.r ?? node.loc?.r;
+                const srcMarker = srcLine != null ? ` // @rip-src:${srcLine}` : '';
+                constructions.push(`    ${exprCode};${srcMarker}`);
+              } catch {}
+            }
+          }
+          for (let i = 1; i < node.length; i++) walkRender(node[i]);
           if (typeof head === 'string' && /^[A-Z]/.test(head)) {
             const props = extractProps(node.slice(1));
             const varName = `_${constructionIdx++}`;
@@ -1100,7 +1251,6 @@ export function installComponentSupport(CodeEmitter, Lexer) {
               }
             }
           }
-          for (let i = 1; i < node.length; i++) walkRender(node[i]);
         };
         walkRender(renderBlock);
         if (constructions.length > 0) {
@@ -1346,15 +1496,15 @@ export function installComponentSupport(CodeEmitter, Lexer) {
    * Handle standalone render (outside component): error
    */
   proto.emitRender = function(head, rest, context, sexpr) {
-    throw new Error('render blocks can only be used inside a component');
+    this.error('render blocks can only be used inside a component', sexpr);
   };
 
   proto.emitOffer = function(head, rest, context, sexpr) {
-    throw new Error('offer can only be used inside a component');
+    this.error('offer can only be used inside a component', sexpr);
   };
 
   proto.emitAccept = function(head, rest, context, sexpr) {
-    throw new Error('accept can only be used inside a component');
+    this.error('accept can only be used inside a component', sexpr);
   };
 
   // ==========================================================================
@@ -1998,6 +2148,18 @@ export function installComponentSupport(CodeEmitter, Lexer) {
 
   proto.emitConditional = function(sexpr) {
     this._pendingAutoWire = false;
+
+    // Fold flat else-if chains into nested structure.
+    // Parser emits: ['if', c1, t1, ['if', c2, t2], ..., finalElse]
+    // We need:      ['if', c1, t1, ['if', c2, t2, [..., finalElse]]]
+    if (sexpr.length > 4) {
+      let chain = sexpr[sexpr.length - 1];
+      for (let i = sexpr.length - 2; i >= 3; i--) {
+        chain = [...sexpr[i], chain];
+      }
+      sexpr = [sexpr[0], sexpr[1], sexpr[2], chain];
+    }
+
     const [, condition, thenBlock, elseBlock] = sexpr;
 
     const anchorVar = this.newElementVar('anchor');
@@ -2055,6 +2217,9 @@ export function installComponentSupport(CodeEmitter, Lexer) {
       setupLines.push(`    }`);
     }
     setupLines.push(`  ${effClose}`);
+    if (this._factoryMode) {
+      setupLines.push(`  disposers.push(() => { if (currentBlock) { currentBlock.d(true); currentBlock = null; } });`);
+    }
     setupLines.push(`}`);
 
     this._setupLines.push(setupLines.join('\n    '));

package/src/error.js

@@ -0,0 +1,250 @@
+// RipError — structured diagnostics for the Rip compiler
+//
+// Unifies error reporting across lexer, parser, and codegen with source
+// locations, contextual snippets, and carets. Consumers (CLI, loader, browser,
+// REPL, server) call format() for terminal output or formatHTML() for browser.
+
+export class RipError extends Error {
+  constructor(message, {
+    code   = null,   // e.g. 'E_SYNTAX', 'E_CODEGEN', 'E_PARSE'
+    file   = null,   // source filename
+    line   = null,   // 0-based line number
+    column = null,   // 0-based column number
+    length = 1,      // length of the offending span
+    source = null,   // full original source text
+    suggestion = null,
+    phase  = null,   // 'lexer', 'parser', 'codegen'
+  } = {}) {
+    super(message);
+    this.name       = 'RipError';
+    this.code       = code;
+    this.file       = file;
+    this.line       = line;
+    this.column     = column;
+    this.length     = length;
+    this.source     = source;
+    this.suggestion = suggestion;
+    this.phase      = phase;
+  }
+
+  // Construct from a lexer SyntaxError (has .location)
+  static fromLexer(err, source, file) {
+    let loc = err.location || {};
+    return new RipError(err.message, {
+      code: 'E_SYNTAX',
+      file,
+      line: loc.first_line ?? null,
+      column: loc.first_column ?? null,
+      length: loc.last_column != null && loc.first_column != null
+        ? loc.last_column - loc.first_column + 1 : 1,
+      source,
+      phase: 'lexer',
+    });
+  }
+
+  // Construct from a parser Error (has .hash with line, loc, token, expected)
+  static fromParser(err, source, file) {
+    let h = err.hash || {};
+    let loc = h.loc || {};
+    let line = h.line ?? loc.r ?? null;
+    let column = loc.first_column ?? loc.c ?? null;
+    let suggestion = null;
+    if (h.expected?.length) {
+      let first5 = h.expected.slice(0, 5).map(e => e.replace(/'/g, ''));
+      suggestion = `Expected ${first5.join(', ')}`;
+      if (h.expected.length > 5) suggestion += `, ... (${h.expected.length} total)`;
+    }
+    // Build a clean message from the hash instead of using the parser's pre-formatted string
+    let token = h.token || 'token';
+    let near = h.text ? ` near '${h.text}'` : '';
+    let message = `Unexpected ${token}${near}`;
+    return new RipError(message, {
+      code: 'E_PARSE',
+      file,
+      line,
+      column,
+      length: h.text?.length || 1,
+      source,
+      suggestion,
+      phase: 'parser',
+    });
+  }
+
+  // Construct from an s-expression node's .loc in the codegen phase
+  static fromSExpr(message, sexpr, source, file, suggestion) {
+    let loc = sexpr?.loc || {};
+    return new RipError(message, {
+      code: 'E_CODEGEN',
+      file,
+      line: loc.r ?? null,
+      column: loc.c ?? null,
+      length: loc.n ?? 1,
+      source,
+      suggestion,
+      phase: 'codegen',
+    });
+  }
+
+  // Human-readable location string: "file.rip:3:5" or "3:5" or ""
+  get locationString() {
+    let parts = [];
+    if (this.file) parts.push(this.file);
+    if (this.line != null) {
+      parts.push(`${this.line + 1}:${(this.column ?? 0) + 1}`);
+    }
+    return parts.join(':');
+  }
+
+  // ---- Terminal formatter ----
+
+  format({ color = true } = {}) {
+    let c = color ? {
+      red:     '\x1b[31m',
+      yellow:  '\x1b[33m',
+      cyan:    '\x1b[36m',
+      dim:     '\x1b[2m',
+      bold:    '\x1b[1m',
+      reset:   '\x1b[0m',
+    } : { red: '', yellow: '', cyan: '', dim: '', bold: '', reset: '' };
+
+    let lines = [];
+
+    // Header: error message
+    let loc = this.locationString;
+    let header = loc ? `${c.cyan}${loc}${c.reset} ` : '';
+    lines.push(`${header}${c.red}${c.bold}error${c.reset}${c.bold}: ${this.message}${c.reset}`);
+
+    // Source snippet with caret
+    let snippet = this._snippet();
+    if (snippet) {
+      lines.push('');
+      for (let s of snippet) {
+        if (s.type === 'source') {
+          lines.push(`${c.dim}${s.gutter}${c.reset}${s.text}`);
+        } else if (s.type === 'caret') {
+          lines.push(`${c.dim}${s.gutter}${c.reset}${c.red}${c.bold}${s.text}${c.reset}`);
+        }
+      }
+    }
+
+    // Suggestion
+    if (this.suggestion) {
+      lines.push('');
+      lines.push(`${c.yellow}hint${c.reset}: ${this.suggestion}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  // ---- HTML formatter ----
+
+  formatHTML() {
+    let lines = [];
+    lines.push('<div class="rip-error">');
+    lines.push('<style>');
+    lines.push(`.rip-error { font-family: ui-monospace, "SF Mono", Menlo, Monaco, monospace; font-size: 13px; line-height: 1.5; padding: 16px 20px; background: #1e1e2e; color: #cdd6f4; border-radius: 8px; overflow-x: auto; }`);
+    lines.push(`.rip-error .re-header { color: #f38ba8; font-weight: 600; }`);
+    lines.push(`.rip-error .re-loc { color: #89b4fa; }`);
+    lines.push(`.rip-error .re-gutter { color: #585b70; user-select: none; }`);
+    lines.push(`.rip-error .re-caret { color: #f38ba8; font-weight: 700; }`);
+    lines.push(`.rip-error .re-hint { color: #f9e2af; }`);
+    lines.push(`.rip-error .re-snippet { margin: 8px 0; }`);
+    lines.push('</style>');
+
+    let loc = this.locationString;
+    let locSpan = loc ? `<span class="re-loc">${esc(loc)}</span> ` : '';
+    lines.push(`<div class="re-header">${locSpan}error: ${esc(this.message)}</div>`);
+
+    let snippet = this._snippet();
+    if (snippet) {
+      lines.push('<pre class="re-snippet">');
+      for (let s of snippet) {
+        if (s.type === 'source') {
+          lines.push(`<span class="re-gutter">${esc(s.gutter)}</span>${esc(s.text)}`);
+        } else if (s.type === 'caret') {
+          lines.push(`<span class="re-gutter">${esc(s.gutter)}</span><span class="re-caret">${esc(s.text)}</span>`);
+        }
+      }
+      lines.push('</pre>');
+    }
+
+    if (this.suggestion) {
+      lines.push(`<div class="re-hint">hint: ${esc(this.suggestion)}</div>`);
+    }
+
+    lines.push('</div>');
+    return lines.join('\n');
+  }
+
+  // ---- Snippet builder (shared by format and formatHTML) ----
+
+  _snippet() {
+    if (this.source == null || this.line == null) return null;
+
+    let sourceLines = this.source.split('\n');
+    let errLine = this.line;
+    if (errLine < 0 || errLine >= sourceLines.length) return null;
+
+    let contextRadius = 2;
+    let start = Math.max(0, errLine - contextRadius);
+    let end = Math.min(sourceLines.length - 1, errLine + contextRadius);
+    let gutterWidth = String(end + 1).length;
+
+    let result = [];
+
+    for (let i = start; i <= end; i++) {
+      let lineNum = String(i + 1).padStart(gutterWidth);
+      let gutter = ` ${lineNum} │ `;
+      result.push({ type: 'source', gutter, text: sourceLines[i] });
+
+      if (i === errLine && this.column != null) {
+        let pad = ' '.repeat(this.column);
+        let caretLen = Math.max(1, Math.min(this.length || 1, sourceLines[i].length - this.column));
+        let carets = '^'.repeat(caretLen);
+        let emptyGutter = ' '.repeat(gutterWidth + 2) + '│ ';
+        result.push({ type: 'caret', gutter: emptyGutter, text: `${pad}${carets}` });
+      }
+    }
+
+    return result;
+  }
+}
+
+// Detect whether an error is a lexer SyntaxError with .location
+export function isLexerError(err) {
+  return err instanceof SyntaxError && err.location != null;
+}
+
+// Detect whether an error is a parser error with .hash
+export function isParserError(err) {
+  return !(err instanceof SyntaxError) && err.hash != null;
+}
+
+// Upgrade any error to RipError (idempotent on RipError instances)
+export function toRipError(err, source, file) {
+  if (err instanceof RipError) {
+    if (file && !err.file) err.file = file;
+    if (source && !err.source) err.source = source;
+    return err;
+  }
+  if (isLexerError(err))  return RipError.fromLexer(err, source, file);
+  if (isParserError(err))  return RipError.fromParser(err, source, file);
+  // Unknown error — wrap with no location
+  return new RipError(err.message, { file, source, phase: 'unknown' });
+}
+
+// Format any error for terminal display (works on RipError and plain Error)
+export function formatError(err, { source, file, color = true } = {}) {
+  let re = (err instanceof RipError) ? err : toRipError(err, source, file);
+  return re.format({ color });
+}
+
+// Format any error for HTML display
+export function formatErrorHTML(err, { source, file } = {}) {
+  let re = (err instanceof RipError) ? err : toRipError(err, source, file);
+  return re.formatHTML();
+}
+
+function esc(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}

package/src/grammar/grammar.rip

@@ -70,7 +70,6 @@ grammar =
     o 'Code'
     o 'Operation'
     o 'Assign'
-    o 'RightwardAssign'
     o 'ReactiveAssign'
     o 'ComputedAssign'
     o 'ReadonlyAssign'
@@ -188,11 +187,6 @@ grammar =
     o 'Assignable = INDENT Expression OUTDENT', '["=", 1, 4]'
   ]
 
-  # Rightward assignment (:>) — expression first, target second
-  RightwardAssign: [
-    o 'Expression RIGHTWARD_ASSIGN Assignable', '["=", 3, 1]'
-  ]
-
   # Reactive state (:=) — mutable reactive values
   ReactiveAssign: [
     o 'Assignable REACTIVE_ASSIGN Expression'               , '["state", 1, 3]'
@@ -899,9 +893,6 @@ grammar =
     # Postfix existence check: expr? → (expr != null)
     o 'Value ?'               , '["?", 1]'
 
-    # Postfix defined check: expr!? → (expr !== undefined)
-    o 'Value DEFINED'         , '["defined", 1]'
-
     # Postfix presence check: expr?! → (expr ? true : undefined) — Houdini operator
     o 'Value PRESENCE'        , '["presence", 1]'
 
@@ -938,7 +929,6 @@ grammar =
     o 'Expression && Expression'      , '["&&", 1, 3]'
     o 'Expression || Expression'      , '["||", 1, 3]'
     o 'Expression ?? Expression'      , '["??", 1, 3]'
-    o 'Expression !? Expression'      , '["!?", 1, 3]'  # Otherwise (undefined-only coalescing)
 
     # Pipe
     o 'Expression PIPE Expression'    , '["|>", 1, 3]'
@@ -968,7 +958,7 @@ operators = """
   right       DO_IIFE
   left        . ?.
   left        CALL_START CALL_END
-  nonassoc    ++ -- ? DEFINED PRESENCE
+  nonassoc    ++ -- ? PRESENCE
   right       UNARY DO
   right       AWAIT
   right       **
@@ -987,7 +977,7 @@ operators = """
   right       TERNARY
   nonassoc    INDENT OUTDENT
   right       YIELD
-  right       = : COMPOUND_ASSIGN RIGHTWARD_ASSIGN RETURN THROW EXTENDS
+  right       = : COMPOUND_ASSIGN RETURN THROW EXTENDS
   right       FORIN FOROF FORAS FORASAWAIT BY WHEN
   right       IF ELSE FOR WHILE UNTIL LOOP SUPER CLASS COMPONENT RENDER IMPORT EXPORT DYNAMIC_IMPORT OFFER ACCEPT
   left        POST_IF POST_UNLESS

package/src/lexer.js

@@ -215,10 +215,9 @@ let UNARY_MATH = new Set(['!', '~']);
 // Identifier: word chars + optional trailing ! (await) or ? (predicate)
 // The ? suffix is only captured when NOT followed by . ? ! [ ( to avoid
 // conflict with ?. (optional chaining), ?? (nullish), ?! (presence), ?.( and ?.[
-// The ! suffix is NOT captured when followed by ? to preserve !? as operator
-let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!(?!\?)|[?](?![.?![(]))?)([^\n\S]*:(?![=:>]))?/;
+let IDENTIFIER_RE = /^(?!\d)((?:(?!\s)[$\w\x7f-\uffff])+(?:!|[?](?![.?![(]))?)([^\n\S]*:(?![=:]))?/;
 let NUMBER_RE     = /^0b[01](?:_?[01])*n?|^0o[0-7](?:_?[0-7])*n?|^0x[\da-f](?:_?[\da-f])*n?|^\d+(?:_\d+)*n|^(?:\d+(?:_\d+)*)?\.?\d+(?:_\d+)*(?:e[+-]?\d+(?:_\d+)*)?/i;
-let OPERATOR_RE   = /^(?:<=>|::|\*>|[-=]>|~>|~=|:>|:=|=!|===|!==|!\?|\?\!|\?\?|=~|\|>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
+let OPERATOR_RE   = /^(?:<=>|::|\*>|[-=]>|~>|~=|:=|=!|===|!==|\?\!|\?\?|=~|\|>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>*\/%])\2=?|\?\.?|\.{2,3})/;
 let WHITESPACE_RE = /^[^\n\S]+/;
 let NEWLINE_RE    = /^(?:\n[^\n\S]*)+/;
 let COMMENT_RE    = /^(\s*)###([^#][\s\S]*?)(?:###([^\n\S]*)|###$)|^((?:\s*#(?!##[^#]).*)+)/;
@@ -543,9 +542,12 @@ export class Lexer {
     }
 
     // Reserved words (check the base form, not the suffixed form)
-    if (tag === 'IDENTIFIER' && RESERVED.has(baseId) &&
-        !(baseId === 'void' && this.inTypeAnnotation)) {
-      syntaxError(`reserved word '${baseId}'`, {row: this.row, col: this.col, len: idLen});
+    if (tag === 'IDENTIFIER' && RESERVED.has(baseId)) {
+      if (baseId === 'void' && (this.inTypeAnnotation || this.prevTag() === '=>')) {
+        // ok — void used as a type (after :: or =>)
+      } else {
+        syntaxError(`reserved word '${baseId}'`, {row: this.row, col: this.col, len: idLen});
+      }
     }
 
     // Property-specific checks (new.target, import.meta)
@@ -779,15 +781,20 @@ export class Lexer {
         }
       }
     }
-    // A > that closes a generic type annotation is NOT a continuation
+    // A > or >> that closes a generic type annotation/alias is NOT a continuation
     let prev = this.tokens[this.tokens.length - 1];
-    if (prev?.[0] === 'COMPARE' && prev[1] === '>') {
+    let isGenericClose = (prev?.[0] === 'COMPARE' && prev[1] === '>') ||
+                         (prev?.[0] === 'SHIFT' && (prev[1] === '>>' || prev[1] === '>>>'));
+    if (isGenericClose) {
       let depth = 0;
       for (let k = this.tokens.length - 1; k >= 0; k--) {
         let tk = this.tokens[k];
         if (tk[0] === 'COMPARE' && tk[1] === '>') depth++;
+        else if (tk[0] === 'SHIFT' && tk[1] === '>>') depth += 2;
+        else if (tk[0] === 'SHIFT' && tk[1] === '>>>') depth += 3;
         else if (tk[0] === 'COMPARE' && tk[1] === '<') depth--;
         if (depth === 0 && tk[0] === 'TYPE_ANNOTATION') return false;
+        if (depth === 0 && tk[0] === 'IDENTIFIER' && tk[1] === 'type') return false;
         if (tk[0] === 'TERMINATOR' || tk[0] === 'INDENT' || tk[0] === 'OUTDENT') break;
       }
     }
@@ -1230,7 +1237,6 @@ export class Lexer {
     // Reactive and binding operators
     else if (val === '~=') tag = 'COMPUTED_ASSIGN';
     else if (val === ':=') tag = 'REACTIVE_ASSIGN';
-    else if (val === ':>') tag = 'RIGHTWARD_ASSIGN';
     else if (val === '<=>') tag = 'BIND';
     else if (val === '~>') { tag = 'EFFECT'; this.inTypeAnnotation = false; }
     else if (val === '=!') { tag = 'READONLY_ASSIGN'; this.inTypeAnnotation = false; }
@@ -1297,8 +1303,6 @@ export class Lexer {
     else if (SHIFT.has(val))           tag = 'SHIFT';
     // Spaced ? → TERNARY (ternary)
     else if (val === '?' && prev?.spaced) tag = 'TERNARY';
-    // Unspaced !? → DEFINED (postfix defined check: v!? → v !== undefined)
-    else if (val === '!?' && prev && !prev.spaced) tag = 'DEFINED';
     // Unspaced ?! → PRESENCE (Houdini: v?! → v ? true : undefined)
     else if (val === '?!' && prev && !prev.spaced) tag = 'PRESENCE';
     // ?[ and ?( without dot → treat as optional chaining (?.)