rip-lang 3.16.0 → 3.16.1

package/src/compiler.js

@@ -322,6 +322,20 @@ export class CodeEmitter {
   // Each entry pairs a statement's generated code with its source loc.
   // Output line positions are computed by exact arithmetic — no heuristics.
   buildMappings() {
+    // Imports are emitted at the top of the file (before the preamble),
+    // starting at line 0. Process them first with their own line offset.
+    if (this._importEntries) {
+      let importLineOffset = 0;
+      for (let entry of this._importEntries) {
+        if (entry.loc) {
+          this.sourceMap.addMapping(importLineOffset, 0, entry.loc.r, entry.loc.c);
+        }
+        if (entry.sexpr && entry.loc) {
+          this.recordSubMappings(entry.code, entry.sexpr, importLineOffset);
+        }
+        importLineOffset += entry.code.split('\n').length;
+      }
+    }
     if (!this._stmtEntries) return;
     let lineOffset = this._preambleLines;
     for (let entry of this._stmtEntries) {
@@ -423,6 +437,47 @@ export class CodeEmitter {
       ripSrcCache.set(genLineInStmt, v);
       return v;
     };
+    // Inline type annotations (emitted when `inlineTypes: true`) inject
+    // identifiers into function-signature lines that have no source
+    // counterpart — e.g. `header(name, value, opts: { append?: boolean })`.
+    // Their identifiers (`append`, `boolean`, etc.) would otherwise compete
+    // with real body identifiers in the regex matcher below, mis-mapping
+    // source positions onto the type literal. Detect those brace ranges
+    // per line and skip matches inside them.
+    const inlineTypeRangesCache = new Map();
+    const getInlineTypeRanges = (genLineInStmt) => {
+      if (inlineTypeRangesCache.has(genLineInStmt)) return inlineTypeRangesCache.get(genLineInStmt);
+      const lt = codeLines[genLineInStmt];
+      const ranges = [];
+      // Only look at function-signature shaped lines: contain `(...) {` or `(...) =>`.
+      if (lt && /\)\s*(\{|=>)\s*$/.test(lt)) {
+        // Find `: {` after an identifier (with optional `?` and whitespace).
+        const annotRe = /\b[a-zA-Z_$][\w$]*\??\s*:\s*\{/g;
+        let am;
+        while ((am = annotRe.exec(lt)) !== null) {
+          const braceStart = am.index + am[0].length - 1; // position of `{`
+          // Skip inside strings (defensive — unlikely here)
+          if (CodeEmitter._isColInsideString(lt, braceStart)) continue;
+          // Walk to matching `}` honoring brace depth and strings
+          let depth = 1, j = braceStart + 1, inStr = false, quote = '';
+          while (j < lt.length && depth > 0) {
+            const ch = lt[j];
+            if (inStr) {
+              if (ch === '\\') { j += 2; continue; }
+              if (ch === quote) inStr = false;
+            } else if (ch === '"' || ch === "'" || ch === '`') {
+              inStr = true; quote = ch;
+            } else if (ch === '{') depth++;
+            else if (ch === '}') depth--;
+            j++;
+          }
+          ranges.push([braceStart, j]); // exclude positions [braceStart, j)
+          annotRe.lastIndex = j;
+        }
+      }
+      inlineTypeRangesCache.set(genLineInStmt, ranges);
+      return ranges;
+    };
     for (let { name, origLine, origCol } of subs) {
       let escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
       let re = new RegExp('\\b' + escaped + '\\b', 'g');
@@ -442,6 +497,11 @@ export class CodeEmitter {
         const annotSrc = getRipSrcAnnot(genLineInStmt);
         const annotMatches = annotSrc != null && annotSrc === origLine;
         if (lineText && CodeEmitter._isColInsideString(lineText, genCol) && !annotMatches) continue;
+        // Skip matches inside inline type annotation brace ranges (e.g.
+        // `opts: { append?: boolean }`) — those identifiers are emitted
+        // for TS type-checking only and have no real source counterpart.
+        const itRanges = getInlineTypeRanges(genLineInStmt);
+        if (itRanges.length && itRanges.some(([s, e]) => genCol >= s && genCol < e)) continue;
         let genLine = lineOffset + genLineInStmt;
         // Annotation-matched lines are the authoritative gen position for
         // their source line — score them as a perfect line match so they
@@ -501,14 +561,37 @@ export class CodeEmitter {
         }
       }
       // Operators/keywords: anchor is the subject at index 1
-      else if (typeof head === 'string' && /^[=+\-*/%<>!&|?~^]|^\.\.?$|^def$|^class$|^state$|^computed$|^readonly$|^for-/.test(head)) {
-        if (typeof node[1] === 'string' && /^[a-zA-Z_$]/.test(node[1])) ident = node[1];
+      else if (typeof head === 'string' && /^[=+\-*/%<>!&|?~^]|^\.{1,3}$|^def$|^class$|^state$|^computed$|^readonly$|^for-/.test(head)) {
+        if (typeof node[1] === 'string' && /^[a-zA-Z_$]/.test(node[1])) {
+          ident = node[1];
+          // Spread `...x`: node.loc.c marks the `...` start; shift past the
+          // operator so the anchor lands on the operand identifier.
+          if (head === '...') identCol = node.loc.c + 3;
+        }
       }
       // Function call (head is identifier)
       else if (typeof head === 'string' && /^[a-zA-Z_$]/.test(head)) {
         ident = head;
       }
       if (ident) result.push({ name: ident, origLine: node.loc.r, origCol: identCol });
+
+      // Arrow body bare-identifier anchor: a single-expression arrow body
+      // like `-> products` parses as `['->', [], ['block', 'products']]`.
+      // The body atom has no .loc (parser only attaches loc to arrays), and
+      // the `block` wrapper has bogus `loc=0:0`, so the identifier reference
+      // is invisible to the heuristic mapping. Synthesize an anchor by
+      // scanning source forward from the arrow's location.
+      if ((head === '->' || head === '=>') && Array.isArray(node[2]) && str(node[2][0]) === 'block') {
+        const body = node[2];
+        for (let i = 1; i < body.length; i++) {
+          const leaf = body[i];
+          const leafStr = typeof leaf === 'string' || leaf instanceof String ? str(leaf) : null;
+          if (leafStr && /^[a-zA-Z_$][\w$]*$/.test(leafStr) && !leaf.loc) {
+            const anchor = this._scanForIdentAfter(leafStr, node.loc);
+            if (anchor) result.push(anchor);
+          }
+        }
+      }
     }
     // Side-channel anchors attached by walkRender for bare-identifier
     // children of template-tag nodes (e.g. `error` in `p.error error`).
@@ -528,6 +611,30 @@ export class CodeEmitter {
     }
   }
 
+  // Scan original source for the first occurrence of `ident` after the
+  // given start location (typically an arrow's `->` loc). Skips matches
+  // inside string/comment regions. Returns a sub-expression anchor or null.
+  _scanForIdentAfter(ident, startLoc) {
+    const source = this.options && this.options.source;
+    if (!source || !startLoc) return null;
+    const lines = this._sourceLinesCache || (this._sourceLinesCache = source.split('\n'));
+    const re = new RegExp('\\b' + ident.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b', 'g');
+    const startRow = startLoc.r;
+    const startCol = startLoc.c;
+    // Search current line from startCol forward, then up to 20 subsequent lines.
+    for (let r = startRow; r < Math.min(lines.length, startRow + 20); r++) {
+      const line = lines[r];
+      if (!line) continue;
+      re.lastIndex = r === startRow ? startCol : 0;
+      let m;
+      while ((m = re.exec(line)) !== null) {
+        if (CodeEmitter._isColInsideString(line, m.index)) continue;
+        return { name: ident, origLine: r, origCol: m.index };
+      }
+    }
+    return null;
+  }
+
   // ---------------------------------------------------------------------------
   // Variable collection
   // ---------------------------------------------------------------------------
@@ -577,7 +684,12 @@ export class CodeEmitter {
     }
 
     if (head === 'for-in' || head === 'for-of' || head === 'for-as') {
-      this.collectVarsFromLoopHead(rest[0], this.programVars);
+      // Don't hoist loop vars: emitForIn/emitForOf/emitForAs already
+      // emit `for (let x of ...)`, which is block-scoped AND gives JS's
+      // per-iteration binding semantics (critical for closures captured
+      // inside the loop). Hoisting `let x` to the surrounding scope
+      // would shadow that as dead code (TS6133 "declared but never
+      // read") without changing runtime behavior.
       rest.slice(1).forEach(item => this.collectProgramVariables(item));
       return;
     }
@@ -640,7 +752,10 @@ export class CodeEmitter {
         return;
       }
       if (head === 'for-in' || head === 'for-of' || head === 'for-as') {
-        this.collectVarsFromLoopHead(rest[0], vars);
+        // See collectProgramVariables for-loop branch: loop vars are
+        // block-scoped via the for-header's `let`; hoisting them here
+        // would only produce a redundant outer `let x` flagged as
+        // unused.
         rest.slice(1).forEach(collect);
         return;
       }
@@ -668,20 +783,55 @@ export class CodeEmitter {
     return vars;
   }
 
+  // Walk a function body and collect typed local assignments. Returns a
+  // Map<name, typeString> for every `name:: T = value` whose target is a
+  // String-wrapped identifier carrying `data.type` (attached by types.js).
+  //
+  // Used by `emitBodyWithReturns` in `inlineTypes` mode to annotate the
+  // function-top hoist (`let a, y: boolean, b;`) so shadow-TS sees the
+  // intended type instead of inferring a literal from the first RHS. Stops
+  // at nested function boundaries — each function owns its own typed locals.
+  //
+  // Conflict policy: first annotation wins. Same-name re-annotations are
+  // silently ignored; mixing different types on the same local is an
+  // unusual pattern best surfaced by TS itself once the hoist carries the
+  // first annotation.
+  collectTypedLocals(body) {
+    let typed = new Map();
+    let walk = (sexpr) => {
+      if (!Array.isArray(sexpr)) return;
+      let [head, ...rest] = sexpr;
+      head = str(head);
+      if (Array.isArray(head)) { sexpr.forEach(walk); return; }
+      if (CodeEmitter.ASSIGNMENT_OPS.has(head)) {
+        let [target, value] = rest;
+        if (target instanceof String && target.type && !typed.has(str(target))) {
+          typed.set(str(target), target.type);
+        }
+        walk(value);
+        return;
+      }
+      if (head === 'def' || head === '->' || head === '=>' || head === 'effect') return;
+      rest.forEach(walk);
+    };
+    walk(body);
+    return typed;
+  }
+
   // ---------------------------------------------------------------------------
   // Main dispatch
   // ---------------------------------------------------------------------------
 
   emit(sexpr, context = 'statement') {
-    // String object with metadata (quote, await, predicate, heregex, etc.)
+    // String object with metadata (quote, bang, optional, heregex, etc.)
     if (sexpr instanceof String) {
       // Dammit operator (!)
-      if (meta(sexpr, 'await') === true) {
+      if (meta(sexpr, 'bang') === true) {
         return `await ${str(sexpr)}()`;
       }
 
       // Existence check (?)
-      if (meta(sexpr, 'predicate')) {
+      if (meta(sexpr, 'optional')) {
         return `(${str(sexpr)} != null)`;
       }
 
@@ -737,8 +887,8 @@ export class CodeEmitter {
 
     let [head, ...rest] = sexpr;
 
-    // Preserve await metadata before converting head to primitive
-    let headAwaitMeta = meta(head, 'await');
+    // Preserve bang metadata before converting head to primitive
+    let headBangMeta = meta(head, 'bang');
     head = str(head);
 
     // Dispatch table
@@ -758,7 +908,7 @@ export class CodeEmitter {
       let postfix = this._tryPostfixCall(head, rest, context);
       if (postfix) return postfix;
 
-      let needsAwait = headAwaitMeta === true;
+      let needsAwait = headBangMeta === true;
       let callStr = `${this.emit(head, 'value')}(${this._emitArgs(rest)})`;
       return needsAwait ? `await ${callStr}` : callStr;
     }
@@ -784,15 +934,16 @@ export class CodeEmitter {
       let postfix = this._tryPostfixCall(head, rest, context);
       if (postfix) return postfix;
 
-      // Property access with await sigil on property
+      // Property access with bang sigil on property
       let needsAwait = false;
       let calleeCode;
-      if (head[0] === '.' && meta(head[2], 'await') === true) {
+      if (head[0] === '.' && meta(head[2], 'bang') === true) {
         needsAwait = true;
         let [obj, prop] = head.slice(1);
         let objCode = this.emit(obj, 'value');
         let needsParens = CodeEmitter.NUMBER_LITERAL_RE.test(objCode) ||
-                          ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield')));
+                          ((this.is(obj, 'object') || this.is(obj, 'await') || this.is(obj, 'yield'))) ||
+                          /^(await|yield)\s/.test(objCode);
         let base = needsParens ? `(${objCode})` : objCode;
         calleeCode = `${base}.${str(prop)}`;
       } else {
@@ -850,7 +1001,12 @@ export class CodeEmitter {
     let needsBlank = false;
 
     if (imports.length > 0) {
-      code += imports.map(s => this.addSemicolon(s, this.emit(s, 'statement'))).join('\n');
+      let importEntries = imports.map(s => {
+        let generated = this.addSemicolon(s, this.emit(s, 'statement'));
+        return { code: generated, loc: Array.isArray(s) ? s.loc : null, sexpr: Array.isArray(s) ? s : null };
+      });
+      this._importEntries = importEntries;
+      code += importEntries.map(e => e.code).join('\n');
       needsBlank = true;
     }
 
@@ -1042,15 +1198,7 @@ export class CodeEmitter {
     }
 
     // Validate: no sigils in assignment targets (except void function syntax)
-    let isFnValue = (this.is(value, '->') || this.is(value, '=>') || this.is(value, 'def'));
-    if (target instanceof String && meta(target, 'await') !== undefined && !isFnValue) {
-      let sigil = meta(target, 'await') === true ? '!' : '&';
-      this.error(`Cannot use ${sigil} sigil in variable declaration '${str(target)}'`, sexpr);
-    }
-
-    if (target instanceof String && meta(target, 'await') === true && isFnValue) {
-      this.nextFunctionIsVoid = true;
-    }
+    this.applyVoidMarker(target, value, sexpr);
 
     // Empty destructuring — just evaluate RHS
     let isEmptyArr = this.is(target, 'array', 0);
@@ -1139,7 +1287,7 @@ export class CodeEmitter {
 
     // Generate target (handle reactive, sigils)
     let targetCode;
-    if (target instanceof String && meta(target, 'await') !== undefined) {
+    if (target instanceof String && meta(target, 'bang') !== undefined) {
       targetCode = str(target);
     } else if (typeof target === 'string' && this.reactiveVars?.has(target)) {
       targetCode = `${target}.value`;
@@ -1186,8 +1334,8 @@ export class CodeEmitter {
                       objCode.startsWith('await ') ||
                       ((this.is(obj, 'object') || this.is(obj, 'yield')));
     let base = needsParens ? `(${objCode})` : objCode;
-    if (meta(prop, 'await') === true) return `await ${base}.${str(prop)}()`;
-    if (meta(prop, 'predicate')) return `(${base}.${str(prop)} != null)`;
+    if (meta(prop, 'bang') === true) return `await ${base}.${str(prop)}()`;
+    if (meta(prop, 'optional')) return `(${base}.${str(prop)} != null)`;
     return `${base}.${str(prop)}`;
   }
 
@@ -1353,7 +1501,7 @@ export class CodeEmitter {
 
   emitDef(head, rest, context, sexpr) {
     let [name, params, body] = rest;
-    let sideEffectOnly = meta(name, 'await') === true;
+    let sideEffectOnly = meta(name, 'bang') === true;
     let cleanName = str(name);
     let paramList = this.emitParamList(params);
     let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
@@ -1365,8 +1513,7 @@ export class CodeEmitter {
   emitThinArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
     if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
-    let sideEffectOnly = this.nextFunctionIsVoid || false;
-    this.nextFunctionIsVoid = false;
+    let sideEffectOnly = sexpr.isVoid || false;
     let paramList = this.emitParamList(params);
     let bodyCode = this.emitFunctionBody(body, params, sideEffectOnly);
     let isAsync = this.containsAwait(body);
@@ -1378,8 +1525,7 @@ export class CodeEmitter {
   emitFatArrow(head, rest, context, sexpr) {
     let [params, body] = rest;
     if ((!params || (Array.isArray(params) && params.length === 0)) && this.containsIt(body)) params = ['it'];
-    let sideEffectOnly = this.nextFunctionIsVoid || false;
-    this.nextFunctionIsVoid = false;
+    let sideEffectOnly = sexpr.isVoid || false;
     let paramList = this.emitParamList(params);
     let isSingle = params.length === 1 && typeof params[0] === 'string' &&
                    !paramList.includes('=') && !paramList.includes('...') &&
@@ -1896,7 +2042,20 @@ export class CodeEmitter {
   // Symbol literals
   // ---------------------------------------------------------------------------
 
-  emitSymbol(head, rest) { return `Symbol.for(${JSON.stringify(rest[0])})`; }
+  emitSymbol(head, rest, context, sexpr) {
+    // Anchor the symbol name's source position to the generated `Symbol`
+    // identifier so hover on `:foo` shows `SymbolConstructor` (the
+    // generated `"foo"` is a string literal that TS has no hover for).
+    // sexpr.loc points at the `:`; the name starts at col + 1.
+    if (sexpr && sexpr.loc && typeof rest[0] === 'string') {
+      sexpr._anchors = (sexpr._anchors || []).concat([{
+        name: 'Symbol',
+        origLine: sexpr.loc.r,
+        origCol: sexpr.loc.c + 1,
+      }]);
+    }
+    return `Symbol.for(${JSON.stringify(rest[0])})`;
+  }
 
   // ---------------------------------------------------------------------------
   // Data structures
@@ -1996,8 +2155,7 @@ export class CodeEmitter {
       if (operator === ':' && isSimpleKey && this.is(value, '->')) {
         let [, mParams, mBody] = value;
         if ((!mParams || (Array.isArray(mParams) && mParams.length === 0)) && this.containsIt(mBody)) mParams = ['it'];
-        let mSideEffect = this.nextFunctionIsVoid || false;
-        this.nextFunctionIsVoid = false;
+        let mSideEffect = value.isVoid || false;
         let mParamList = this.emitParamList(mParams);
         let mBodyCode = this.emitFunctionBody(mBody, mParams, mSideEffect);
         let mIsAsync = this.containsAwait(mBody);
@@ -2578,7 +2736,7 @@ export class CodeEmitter {
   emitImport(head, rest, context, sexpr) {
     if (rest.length === 1) {
       let importExpr = `import(${this.emit(rest[0], 'value')})`;
-      if (meta(sexpr[0], 'await') === true) return `(await ${importExpr})`;
+      if (meta(sexpr[0], 'bang') === true) return `(await ${importExpr})`;
       return importExpr;
     }
     if (this.options.skipImports) return '';
@@ -2587,6 +2745,7 @@ export class CodeEmitter {
       let fixedSource = this.addJsExtensionAndAssertions(source);
       if (named[0] === '*' && named.length === 2) return `import ${def}, * as ${named[1]} from ${fixedSource}`;
       let names = named.map(i => Array.isArray(i) && i.length === 2 ? `${i[0]} as ${i[1]}` : i).join(', ');
+      this._attachImportSpecifierAnchors(sexpr, [def, ...named.flatMap(i => Array.isArray(i) ? i : [i])]);
       return `import ${def}, { ${names} } from ${fixedSource}`;
     }
     let [specifier, source] = rest;
@@ -2595,11 +2754,70 @@ export class CodeEmitter {
     if (Array.isArray(specifier)) {
       if (specifier[0] === '*' && specifier.length === 2) return `import * as ${specifier[1]} from ${fixedSource}`;
       let names = specifier.map(i => Array.isArray(i) && i.length === 2 ? `${i[0]} as ${i[1]}` : i).join(', ');
+      this._attachImportSpecifierAnchors(sexpr, specifier.flatMap(i => Array.isArray(i) ? i : [i]));
       return `import { ${names} } from ${fixedSource}`;
     }
     return `import ${this.emit(specifier, 'value')} from ${fixedSource}`;
   }
 
+  // Attach source-map anchors for each named import specifier so hover /
+  // go-to-def works on individual names in `import { foo, bar } from '...'`.
+  // The parser drops .loc from specifier strings, so we recover positions
+  // by scanning the source forward from the `import` keyword.
+  _attachImportSpecifierAnchors(sexpr, names) {
+    if (!sexpr || !sexpr.loc) return;
+    const source = this.options && this.options.source;
+    if (!source || !names || !names.length) return;
+    const lines = this._sourceLinesCache || (this._sourceLinesCache = source.split('\n'));
+    let row = sexpr.loc.r;
+    let col = sexpr.loc.c;
+    const anchors = [];
+    for (const name of names) {
+      if (typeof name !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(name)) continue;
+      const re = new RegExp('\\b' + name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+      let found = false;
+      while (row < lines.length) {
+        const line = lines[row] || '';
+        // Strip trailing line comment so '# foo' doesn't match
+        const codePart = line.replace(/#.*$/, '');
+        re.lastIndex = 0;
+        const slice = codePart.slice(col);
+        const m = re.exec(slice);
+        if (m) {
+          const c = col + m.index;
+          anchors.push({ name, origLine: row, origCol: c });
+          col = c + name.length;
+          found = true;
+          break;
+        }
+        row++;
+        col = 0;
+      }
+      if (!found) break;
+    }
+    if (anchors.length) sexpr._anchors = (sexpr._anchors || []).concat(anchors);
+  }
+
+  // Propagate the void marker from a `name! = fn` LHS onto the function node.
+  // The `!` suffix is recorded as `.bang === true` metadata on the target
+  // identifier; when the value is a function (`->`/`=>`/`def`) the bang means
+  // the function is void (no implicit return). We stamp `isVoid` directly on
+  // the function node so the arrow emitters read it locally — the same way
+  // `emitDef` reads `meta(name, 'bang')` off its own node. Used by assignment
+  // and export declaration paths so `export name! = ->` matches the bare
+  // `name! = ->` semantics. Rejects `!`/`&` sigils on non-function values,
+  // exactly like a plain assignment.
+  applyVoidMarker(target, value, sexpr) {
+    let isFnValue = (this.is(value, '->') || this.is(value, '=>') || this.is(value, 'def'));
+    if (target instanceof String && meta(target, 'bang') !== undefined && !isFnValue) {
+      let sigil = meta(target, 'bang') === true ? '!' : '&';
+      this.error(`Cannot use ${sigil} sigil in variable declaration '${str(target)}'`, sexpr);
+    }
+    if (target instanceof String && meta(target, 'bang') === true && isFnValue) {
+      value.isVoid = true;
+    }
+  }
+
   emitExport(head, rest) {
     let [decl] = rest;
     if (this.options.skipExports) {
@@ -2612,6 +2830,7 @@ export class CodeEmitter {
           this._componentTypeParams = decl[1]?.typeParams || '';
         }
         if (this.is(decl[2], 'schema')) this._schemaName = str(decl[1]);
+        this.applyVoidMarker(decl[1], decl[2], decl);
         const result = `const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
         this._componentName = prev;
         this._componentTypeParams = prevTP;
@@ -2630,6 +2849,7 @@ export class CodeEmitter {
         this._componentTypeParams = decl[1]?.typeParams || '';
       }
       if (this.is(decl[2], 'schema')) this._schemaName = str(decl[1]);
+      this.applyVoidMarker(decl[1], decl[2], decl);
       const result = `export const ${decl[1]} = ${this.emit(decl[2], 'value')}`;
       this._componentName = prev;
       this._componentTypeParams = prevTP;
@@ -2643,10 +2863,14 @@ export class CodeEmitter {
   emitExportDefault(head, rest) {
     let [expr] = rest;
     if (this.options.skipExports) {
-      if (this.is(expr, '=')) return `const ${expr[1]} = ${this.emit(expr[2], 'value')}`;
+      if (this.is(expr, '=')) {
+        this.applyVoidMarker(expr[1], expr[2], expr);
+        return `const ${expr[1]} = ${this.emit(expr[2], 'value')}`;
+      }
       return this.emit(expr, 'statement');
     }
     if (this.is(expr, '=')) {
+      this.applyVoidMarker(expr[1], expr[2], expr);
       return `const ${expr[1]} = ${this.emit(expr[2], 'value')};\nexport default ${expr[1]}`;
     }
     return `export default ${this.emit(expr, 'statement')}`;
@@ -2776,14 +3000,36 @@ export class CodeEmitter {
 
   formatParam(param) {
     if (typeof param === 'string') return param;
-    if (param instanceof String) return param.valueOf();
-    if (this.is(param, 'rest')) return `...${param[1]}`;
+    if (param instanceof String) {
+      // In `inlineTypes` mode (set by typecheck.compileForCheck), emit the
+      // type annotation inline so shadow TS sees `name: T` for typed params
+      // in every function-like position — top-level arrows, class methods,
+      // object-literal method shorthand, nested functions, etc. The user-
+      // facing `-c` output stays untouched because this flag is off by
+      // default. `.type` carries the raw Rip type string (with `::`),
+      // which converts to TS form by swapping `::` → `:`.
+      if (this.options.inlineTypes && param.type) {
+        return `${param.valueOf()}: ${param.type.replace(/::/g, ':')}`;
+      }
+      return param.valueOf();
+    }
+    if (this.is(param, 'rest')) {
+      // Rest param: `...name`. When the name is a String wrapper carrying
+      // a type, emit `...name: T` so shadow TS sees the rest tuple/array.
+      let restName = param[1];
+      if (this.options.inlineTypes && restName instanceof String && restName.type) {
+        return `...${restName.valueOf()}: ${restName.type.replace(/::/g, ':')}`;
+      }
+      return `...${restName}`;
+    }
     if (this.is(param, 'default')) {
       // `param[1]` is either a plain identifier string (e.g. `x = 5`) or a
       // destructuring pattern AST node (e.g. `{a, b} = {}`). Recurse via
       // `formatParam` so patterns emit as `{a, b}` / `[x, y]` instead of
       // being coerced to a string via `Array.prototype.toString`, which
       // produced the famous `(object,,a,a,,b,b = {})` mis-rendering.
+      // The recursion also picks up any inline type annotation on the
+      // name in `inlineTypes` mode, yielding `name: T = default`.
       return `${this.formatParam(param[1])} = ${this.emit(param[2], 'value')}`;
     }
     if (this.is(param, '.') && param[1] === 'this') return param[2];
@@ -2823,10 +3069,14 @@ export class CodeEmitter {
 
     let paramNames = new Set();
     let extractPN = (p) => {
-      if (typeof p === 'string') paramNames.add(p);
+      // Unwrap String wrappers — typed params arrive as `new String('name')`
+      // with `.data.type` metadata. Without unwrapping, `paramNames.has('name')`
+      // misses (Set compares wrappers by identity), causing the param name to
+      // be re-hoisted as a local `let`, producing duplicate-declaration errors.
+      if (typeof p === 'string' || p instanceof String) paramNames.add(str(p));
       else if (Array.isArray(p)) {
-        if (p[0] === 'rest' || p[0] === '...') { if (typeof p[1] === 'string') paramNames.add(p[1]); }
-        else if (p[0] === 'default') { if (typeof p[1] === 'string') paramNames.add(p[1]); }
+        if (p[0] === 'rest' || p[0] === '...') { if (typeof p[1] === 'string' || p[1] instanceof String) paramNames.add(str(p[1])); }
+        else if (p[0] === 'default') { if (typeof p[1] === 'string' || p[1] instanceof String) paramNames.add(str(p[1])); }
         else if (p[0] === 'array' || p[0] === 'object') this.collectVarsFromArray(p, paramNames);
       }
     };
@@ -2870,7 +3120,20 @@ export class CodeEmitter {
 
       this.indentLevel++;
       let code = '{\n';
-      if (newVars.size > 0) code += this.indent() + `let ${Array.from(newVars).sort().join(', ')};\n`;
+      if (newVars.size > 0) {
+        // In `inlineTypes` mode, propagate `name:: T = value` annotations from
+        // body-level typed assignments onto the hoisted `let`. Without this,
+        // the hoist emits `let y;` (no type), shadow-TS infers from the first
+        // RHS literal (`y = true` → `y: true`), and any later `y = false`
+        // fails TS2322. With this, the hoist emits `let y: boolean;` and the
+        // body's `y = true` / `y = false` both check cleanly.
+        let typedLocals = this.options.inlineTypes ? this.collectTypedLocals(body) : null;
+        let names = Array.from(newVars).sort().map(n => {
+          let t = typedLocals?.get(n);
+          return t ? `${n}: ${t}` : n;
+        });
+        code += this.indent() + `let ${names.join(', ')};\n`;
+      }
 
       let firstIsSuper = autoAssignments.length > 0 && statements.length > 0 &&
                          Array.isArray(statements[0]) && statements[0][0] === 'super';
@@ -3707,7 +3970,7 @@ export class CodeEmitter {
 
   containsAwait(sexpr) {
     if (!sexpr) return false;
-    if (sexpr instanceof String && meta(sexpr, 'await') === true) return true;
+    if (sexpr instanceof String && meta(sexpr, 'bang') === true) return true;
     if (typeof sexpr !== 'object') return false;
     if (this.is(sexpr, 'await')) return true;
     if (this.is(sexpr, 'for-as') && sexpr[3] === true) return true;
@@ -4166,7 +4429,13 @@ export class Compiler {
     // in this file at all — the exporting module strips its `export type` to
     // nothing, so leaving the specifier in place would cause a runtime
     // "module does not provide an export named X" error.
-    if (lexer.typeRefNames?.size > 0) {
+    //
+    // Skip elision in `inlineTypes` mode (set by typecheck.compileForCheck).
+    // The shadow-TS output is fed to the TypeScript language service, not
+    // executed — so keeping the specifiers preserves go-to-definition and
+    // hover for type-only imports like `RetryConfig` that resolve to
+    // `export type` declarations in the target module.
+    if (lexer.typeRefNames?.size > 0 && !this.options.inlineTypes) {
       let usedNames = new Set();
       let inImport = false;
       for (let t of tokens) {
@@ -4377,6 +4646,11 @@ export class Compiler {
       skipDataPart: this.options.skipDataPart,
       stubComponents: this.options.stubComponents,
       reactiveVars: this.options.reactiveVars,
+      // Emit `name: T` inline on typed params so shadow TS in compileForCheck
+      // sees annotations on every function-like position (top-level arrows,
+      // class methods, object-literal method shorthand, nested functions).
+      // Off by default — only set when producing input for the shadow TS pass.
+      inlineTypes: this.options.inlineTypes,
       // Schema runtime mode: 'browser' / 'validate' / 'server' / 'migration'.
       // Default 'migration' covers the common case (CLI, server, tests) where
       // the user might call any schema feature including .toSQL(). The browser