rip-lang 3.15.4 → 3.16.1

package/src/compiler.js

@@ -11,13 +11,14 @@
 import { Lexer } from './lexer.js';
 import { parser } from './parser.js';
 import { installComponentSupport } from './components.js';
-// Type emission is CLI/editor-only. types-emit.js registers itself via
-// setTypesEmitter() at module load. The browser never imports types-emit,
+// Type emission is CLI/editor-only. dts.js registers itself via
+// setTypesEmitter() at module load. The browser never imports dts.js,
 // so _typesEmitter stays null and .d.ts output is silently skipped.
 let _typesEmitter = null;
 export function setTypesEmitter(fn) { _typesEmitter = fn; }
 import { installSchemaSupport } from './schema/schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
+import { stringify, getStdlibCode } from './stdlib.js';
 import { RipError, toRipError } from './error.js';
 
 // =============================================================================
@@ -321,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) {
@@ -340,11 +355,30 @@ export class CodeEmitter {
   // matches (e.g. identifiers appearing as values inside union type strings).
   static _isColInsideString(line, col) {
     let inStr = false, quote = '';
+    // When inside a template literal (`...`), `${...}` opens an interpolation
+    // expression that is NOT part of the string.  Track interp depth so
+    // identifiers inside `${expr}` aren't incorrectly classified as strings.
+    let interpDepth = 0;
     for (let i = 0; i < line.length && i < col; i++) {
       let ch = line[i];
       if (inStr) {
         if (ch === '\\') { i++; continue; }
+        if (quote === '`' && ch === '$' && line[i + 1] === '{') {
+          interpDepth = 1;
+          inStr = false;
+          i++; // skip `{`
+          continue;
+        }
         if (ch === quote) inStr = false;
+      } else if (interpDepth > 0) {
+        if (ch === '{') interpDepth++;
+        else if (ch === '}') {
+          interpDepth--;
+          if (interpDepth === 0) { inStr = true; quote = '`'; }
+        } else if (ch === '"' || ch === "'" || ch === '`') {
+          // Nested string inside interpolation — recurse via inStr handling
+          inStr = true; quote = ch;
+        }
       } else if (ch === '"' || ch === "'" || ch === '`') {
         inStr = true; quote = ch;
       }
@@ -385,26 +419,106 @@ export class CodeEmitter {
       }
       return hi;
     };
+    // Track generated positions already claimed by an earlier sub-expression
+    // in this statement, so distinct source positions (e.g. `a` in two
+    // adjacent arrow functions) can't all collapse onto the first match.
+    // Without this, identical identifiers in repeated structures get
+    // mis-mapped — e.g. `else if` branches inheriting the `if` branch's
+    // generated coordinates, leaving the real branch unmapped.
+    const usedGenPositions = new Set();
+    // Cache `// @rip-src:N` annotations per generated line so render-block
+    // stub mappings can be honored over unrelated heuristic matches.
+    const ripSrcCache = new Map();
+    const getRipSrcAnnot = (genLineInStmt) => {
+      if (ripSrcCache.has(genLineInStmt)) return ripSrcCache.get(genLineInStmt);
+      const lt = codeLines[genLineInStmt];
+      const m = lt && lt.match(/\/\/ @rip-src:(\d+)\s*$/);
+      const v = m ? parseInt(m[1], 10) : null;
+      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');
-      let m, bestMatch = null, bestDist = Infinity;
+      let m;
+      let bestMatch = null, bestDist = Infinity;
+      let bestUnused = null, bestUnusedDist = Infinity;
       let origLineInStmt = origLine - stmtOrigLine;
       while ((m = re.exec(code)) !== null) {
         const genLineInStmt = offsetToLine(m.index);
         const genCol = m.index - lineStarts[genLineInStmt];
-        // Skip matches inside string literals — prevents false mappings when
-        // an identifier also appears as a string value (e.g. union type member)
         let lineText = codeLines[genLineInStmt];
-        if (lineText && CodeEmitter._isColInsideString(lineText, genCol)) continue;
+        // A `// @rip-src:N` annotation tags the generated line as derived
+        // from source line N (used by render-block stubs). When N matches
+        // the sub-expression's origLine, accept matches here even if they
+        // fall inside string literals — render stubs emit tag names as
+        // `'p'` and interpolations as `${...}` inside template strings.
+        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;
-        // Prefer matches on the same relative line within the statement,
-        // falling back to column distance as tiebreaker.
-        let dist = Math.abs(genLineInStmt - origLineInStmt) * 10000 + Math.abs(genCol - origCol);
+        // Annotation-matched lines are the authoritative gen position for
+        // their source line — score them as a perfect line match so they
+        // beat any heuristic match elsewhere in the statement.
+        let dist = annotMatches
+          ? Math.abs(genCol - origCol)
+          : Math.abs(genLineInStmt - origLineInStmt) * 10000 + Math.abs(genCol - origCol);
         if (dist < bestDist) { bestDist = dist; bestMatch = { genLine, genCol }; }
+        const key = genLine + ':' + genCol;
+        if (!usedGenPositions.has(key) && dist < bestUnusedDist) {
+          bestUnusedDist = dist; bestUnused = { genLine, genCol };
+        }
       }
-      if (bestMatch) {
-        this.sourceMap.addMapping(bestMatch.genLine, bestMatch.genCol, origLine, origCol);
+      const chosen = bestUnused || bestMatch;
+      if (chosen) {
+        this.sourceMap.addMapping(chosen.genLine, chosen.genCol, origLine, origCol);
+        usedGenPositions.add(chosen.genLine + ':' + chosen.genCol);
       }
     }
   }
@@ -419,25 +533,73 @@ export class CodeEmitter {
       for (let i = 0; i < node.length; i++) {
         if (Array.isArray(node[i])) this.collectSubExprs(node[i], result);
       }
+      // Also honor side-channel anchors attached to nodes whose head is an
+      // array (e.g. tag-shorthand `[(. p error), error]` where the tag
+      // node's head is itself an access expression). Without this, anchors
+      // attached by walkRender to such nodes are silently dropped.
+      if (Array.isArray(node._anchors)) {
+        for (const a of node._anchors) result.push(a);
+      }
       return;
     }
     if (node.loc) {
       head = str(head);
       let ident = null;
+      let identCol = node.loc.c;
       // Property access: anchor is the property name (check BEFORE operators
       // because the operator regex also matches '.' via ^\.\.?$)
       if (head === '.') {
-        if (typeof node[2] === 'string') ident = node[2];
+        if (typeof node[2] === 'string') {
+          ident = node[2];
+          // Adjust origCol to point at the property name itself, not the start
+          // of the access expression. node.loc.c marks the object start;
+          // shift past it and the `.` so source-mapping anchors land on the
+          // property identifier (e.g. `image` in `product.image`).
+          if (typeof node[1] === 'string') {
+            identCol = node.loc.c + node[1].length + 1;
+          }
+        }
       }
       // 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: node.loc.c });
+      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`).
+    // The s-expression child is a plain string atom with no .loc, so the
+    // walk would otherwise miss it; the anchor carries the source position
+    // computed from the parent's loc plus a regex scan over source lines.
+    if (Array.isArray(node._anchors)) {
+      for (const a of node._anchors) result.push(a);
     }
     // Recurse into children (skip head at index 0 — already processed via parent).
     // For arrow functions (-> / =>), skip index 1 (params array) — parameter
@@ -449,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
   // ---------------------------------------------------------------------------
@@ -498,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;
     }
@@ -549,14 +740,22 @@ export class CodeEmitter {
       if (Array.isArray(head)) { sexpr.forEach(item => collect(item)); return; }
       if (CodeEmitter.ASSIGNMENT_OPS.has(head)) {
         let [target, value] = rest;
-        if (typeof target === 'string') vars.add(target);
+        // Match collectProgramVariables: identifier targets may arrive as
+        // String wrappers when types.js attaches `.data.type` metadata
+        // to a typed local. Without unwrapping the wrapper, typed locals
+        // skip the function-top `let` declaration and silently leak to
+        // the global scope.
+        if (typeof target === 'string' || target instanceof String) vars.add(str(target));
         else if (this.is(target, 'array')) this.collectVarsFromArray(target, vars);
         else if (this.is(target, 'object')) this.collectVarsFromObject(target, vars);
         collect(value);
         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;
       }
@@ -584,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)`;
       }
 
@@ -653,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
@@ -674,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;
     }
@@ -700,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 {
@@ -766,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;
     }
 
@@ -936,6 +1176,15 @@ export class CodeEmitter {
     let [target, value] = rest;
     let op = head === '?=' ? '??=' : head;
 
+    // Reject destructuring shapes that aren't valid binding patterns. The
+    // grammar accepts the full Array / Object expression on the LHS of `=`,
+    // so things like `[a + b] = src` and `{x: y for x in arr} = src` parse
+    // and used to either silently produce broken JS or crash the compiler
+    // with an obscure error. This walk catches them with a clear message.
+    if (this.is(target, 'array') || this.is(target, 'object')) {
+      this._validateBindingPattern(target, sexpr);
+    }
+
     // Optional chain assignment: x?.prop = val → if (x != null) x.prop = val
     let optInfo = this._findOptionalInTarget(target);
     if (optInfo) {
@@ -949,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);
@@ -1046,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`;
@@ -1093,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)}`;
   }
 
@@ -1260,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);
@@ -1272,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);
@@ -1285,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('...') &&
@@ -1405,9 +1644,13 @@ export class CodeEmitter {
     let [cond, then_, else_] = rest;
 
     // Hoist assignment: (cond ? (x = a) : b) → x = (cond ? a : b)
-    // Enables: x = "admin" if cond else "member" without parens
+    // Enables the Python-style postfix-ternary idiom:
+    //   x = "admin" if cond else "member"  →  x = (cond ? "admin" : "member")
+    // Skip when the assignment is parenthesized — the parser tags those via
+    // `.parenthesized = true` so we can preserve "only assign when cond"
+    // semantics for the explicit form `(x = "a") if cond else "b"`.
     let thenHead = then_?.[0]?.valueOf?.() ?? then_?.[0];
-    if (thenHead === '=' && Array.isArray(then_)) {
+    if (thenHead === '=' && Array.isArray(then_) && !then_.parenthesized) {
       let target = this.emit(then_[1], 'value');
       let thenVal = this.emit(then_[2], 'value');
       let elseVal = this.emit(else_, 'value');
@@ -1799,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
@@ -1824,24 +2080,180 @@ export class CodeEmitter {
       return this.emit(['object-comprehension', keyVar, valueExpr, iterators, guards], context);
     }
 
-    let codes = pairs.map(pair => {
+    // Helper: scan source line for an identifier name within [fromCol, toCol).
+    // Used to attach _anchors so identifiers that the parser dropped position
+    // info from (method-shorthand params, property shorthand keys) can still
+    // produce source-map mappings.
+    const scanIdentCol = (srcRow, name, fromCol = 0, toCol = Infinity) => {
+      const source = this.options && this.options.source;
+      if (!source || typeof name !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(name)) return -1;
+      const lines = this._sourceLinesCache || (this._sourceLinesCache = source.split('\n'));
+      const line = lines[srcRow];
+      if (!line) return -1;
+      const re = new RegExp('\\b' + name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b', 'g');
+      re.lastIndex = Math.max(0, fromCol);
+      let m;
+      while ((m = re.exec(line)) !== null) {
+        if (m.index >= toCol) return -1;
+        return m.index;
+      }
+      return -1;
+    };
+
+    // Same as scanIdentCol but returns the LAST match in [fromCol, toCol).
+    // Property-shorthand pairs only carry .loc for the *end* of the pair,
+    // so to find the key's actual column we walk all occurrences and take
+    // the rightmost one (the param with the same name appears earlier on
+    // the line and would otherwise win).
+    const scanIdentColLast = (srcRow, name, fromCol = 0, toCol = Infinity) => {
+      const source = this.options && this.options.source;
+      if (!source || typeof name !== 'string' || !/^[A-Za-z_$][\w$]*$/.test(name)) return -1;
+      const lines = this._sourceLinesCache || (this._sourceLinesCache = source.split('\n'));
+      const line = lines[srcRow];
+      if (!line) return -1;
+      const re = new RegExp('\\b' + name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b', 'g');
+      re.lastIndex = Math.max(0, fromCol);
+      let m, last = -1;
+      while ((m = re.exec(line)) !== null) {
+        if (m.index >= toCol) break;
+        last = m.index;
+      }
+      return last;
+    };
+
+    // Track which pairs emit as method-shorthand so we can format the
+    // object multi-line. Joining sibling methods with `, ` collapses
+    // `}, name(args) {` onto the same generated line as the previous
+    // method's closing brace, which makes per-line source-map mappings
+    // ambiguous (the LSP can't tell which source line owns that gen line,
+    // so parameter classifications get attributed to the wrong source
+    // position). Putting each method on its own gen line keeps the
+    // line→source mapping one-to-one.
+    let hasMethod = false;
+    let isMethod = new Array(pairs.length).fill(false);
+
+    let codes = pairs.map((pair, idx) => {
       if (this.is(pair, '...')) return `...${this.emit(pair[1], 'value')}`;
       let [operator, key, value] = pair;
       let keyCode;
+      let isSimpleKey = false;
       if (this.is(key, 'dynamicKey')) keyCode = `[${this.emit(key[1], 'value')}]`;
       else if (this.is(key, 'str')) keyCode = `[${this.emit(key, 'value')}]`;
       else {
         this.suppressReactiveUnwrap = true;
         keyCode = this.emit(key, 'value');
         this.suppressReactiveUnwrap = false;
+        isSimpleKey = !Array.isArray(key) && typeof keyCode === 'string'
+                      && /^[A-Za-z_$][\w$]*$/.test(keyCode);
+      }
+
+      // Method-shorthand: `key: -> body` → `key(args) { body }`. Enables
+      // TypeScript contextual `this` binding when the object is assigned to
+      // a method-shorthand-typed slot, and produces cleaner JS output.
+      // Only for thin-arrow (`->`) — fat arrow has lexical `this` semantics.
+      // Skip when the value carries side-effect (`!`) or non-trivial meta.
+      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 = value.isVoid || false;
+        let mParamList = this.emitParamList(mParams);
+        let mBodyCode = this.emitFunctionBody(mBody, mParams, mSideEffect);
+        let mIsAsync = this.containsAwait(mBody);
+        let mIsGen = this.containsYield(mBody);
+        let prefix = mIsAsync ? 'async ' : '';
+        let star = mIsGen ? '*' : '';
+        // Inject source-map anchors for plain-string params (e.g. `quantity`
+        // in `(product, quantity) ->`). The parser drops .loc from non-data
+        // identifier tokens and collectSubExprs intentionally skips the
+        // params slot of arrow nodes, so without these the param positions
+        // produce no source mapping and the LSP's gen→src lookup falls back
+        // to a nearby unrelated identifier — typically classifying the
+        // param as `property`.
+        if (value && value.loc && Array.isArray(mParams) && mParams.length) {
+          const srcRow  = value.loc.r;
+          // value.loc.c marks the start of the params group (the `(` for
+          // parenthesized params, or the first param's column for bare
+          // single-param arrows). Scan forward from there for each param
+          // in declaration order.
+          const paramsStart = value.loc.c;
+          const anchors = [];
+          let cursor = paramsStart;
+          for (const p of mParams) {
+            if (typeof p !== 'string') continue;
+            const col = scanIdentCol(srcRow, p, cursor);
+            if (col >= 0) {
+              anchors.push({ name: p, origLine: srcRow, origCol: col });
+              cursor = col + p.length;
+            }
+          }
+          if (anchors.length) {
+            value._anchors = (value._anchors || []).concat(anchors);
+          }
+        }
+        hasMethod = true;
+        isMethod[idx] = true;
+        return `${prefix}${star}${keyCode}(${mParamList}) ${mBodyCode}`;
       }
+
       let valCode = this.emit(value, 'value');
+      // Anchor the key for simple `key: value` pairs so the source-map
+      // heuristic has one anchor per source occurrence (otherwise pairs
+      // like `quantity: 1` are silent and downstream same-named anchors
+      // get stolen by the wrong gen position).
+      if (operator === ':' && isSimpleKey && Array.isArray(pair) && pair.loc &&
+          typeof key === 'string') {
+        const col = scanIdentCol(pair.loc.r, key, 0, pair.loc.c + key.length + 1);
+        if (col >= 0) {
+          pair._anchors = (pair._anchors || []).concat([
+            { name: key, origLine: pair.loc.r, origCol: col }
+          ]);
+        }
+      }
       if (operator === '=') return `${keyCode} = ${valCode}`;
       if (operator === ':') return `${keyCode}: ${valCode}`;
-      if (keyCode === valCode && !Array.isArray(key)) return keyCode;
+      if (keyCode === valCode && !Array.isArray(key)) {
+        // Property shorthand `{ ...i, quantity }` → pair is [null, "quantity",
+        // "quantity"] with the *pair* carrying .loc but the key/value strings
+        // having none. Without an anchor the heuristic gives the gen position
+        // to whichever same-named identifier in the statement happens to be
+        // closest by line distance.
+        if (Array.isArray(pair) && pair.loc && typeof key === 'string') {
+          const col = scanIdentColLast(pair.loc.r, key, 0, pair.loc.c + 1);
+          if (col >= 0) {
+            pair._anchors = (pair._anchors || []).concat([
+              { name: key, origLine: pair.loc.r, origCol: col }
+            ]);
+          }
+        }
+        return keyCode;
+      }
       return `${keyCode}: ${valCode}`;
-    }).join(', ');
-    return `{${codes}}`;
+    });
+
+    if (!hasMethod) return `{${codes.join(', ')}}`;
+
+    // Multi-line output when any pair is a method. Pairs preceding the
+    // first method may stay on the opening-brace line, then each method
+    // (and any pair following a method) starts on its own line.
+    let parts = [];
+    let onOpenLine = [];
+    for (let i = 0; i < codes.length; i++) {
+      if (isMethod[i] || (i > 0 && isMethod[i - 1])) {
+        if (onOpenLine.length && parts.length === 0) {
+          parts.push(onOpenLine.join(', '));
+          onOpenLine = [];
+        }
+        parts.push(codes[i]);
+      } else if (parts.length === 0) {
+        onOpenLine.push(codes[i]);
+      } else {
+        parts.push(codes[i]);
+      }
+    }
+    if (onOpenLine.length && parts.length === 0) parts.push(onOpenLine.join(', '));
+    let head0 = parts[0];
+    let rest = parts.slice(1);
+    return rest.length === 0 ? `{${head0}}` : `{${head0},\n${rest.join(',\n')}}`;
   }
 
   emitMap(head, pairs, context) {
@@ -2266,14 +2678,18 @@ export class CodeEmitter {
           let atParamMap = isSubclass ? new Map() : null;
           cleanParams = params.map(p => {
             if (this.is(p, '.') && p[1] === 'this') {
-              let name = p[2];
+              // Unwrap String-wrapper identifiers — typed @field params
+              // arrive with their type metadata attached as `.data.type`
+              // and would otherwise miss the atParamMap key match (the
+              // map is queried with primitive strings via `str(prop)`).
+              let name = str(p[2]);
               let param = isSubclass ? `_${name}` : name;
               autoAssign.push(`this.${name} = ${param}`);
               if (isSubclass) atParamMap.set(name, param);
               return param;
             }
             if (this.is(p, 'default') && this.is(p[1], '.') && p[1][1] === 'this') {
-              let name = p[1][2];
+              let name = str(p[1][2]);
               let param = isSubclass ? `_${name}` : name;
               autoAssign.push(`this.${name} = ${param}`);
               if (isSubclass) atParamMap.set(name, param);
@@ -2320,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 '';
@@ -2329,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;
@@ -2337,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) {
@@ -2354,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;
@@ -2372,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;
@@ -2385,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')}`;
@@ -2518,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];
@@ -2565,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);
       }
     };
@@ -2612,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';
@@ -2936,20 +3457,21 @@ export class CodeEmitter {
   // ---------------------------------------------------------------------------
 
   emitIfElseWithEarlyReturns(ifStmt) {
-    let [head, condition, thenBranch, ...elseBranches] = ifStmt;
-    let code = '';
-    let condCode = this.emit(condition, 'value');
-    code += this.indent() + `if (${condCode}) {\n`;
+    let [, condition, thenBranch, ...elseBranches] = ifStmt;
+    return this.indent() + this.emitIfElseEarlyReturnsChain(condition, thenBranch, elseBranches);
+  }
+
+  // Recursive companion to emitIfElseWithEarlyReturns. Each branch body
+  // is wrapped in braces with the last expression promoted to a return.
+  emitIfElseEarlyReturnsChain(condition, thenBranch, elseBranches) {
+    let code = `if (${this.emit(condition, 'value')}) {\n`;
     code += this.withIndent(() => this.emitBranchWithReturn(thenBranch));
     code += this.indent() + '}';
     for (let branch of elseBranches) {
       code += ' else ';
       if (this.is(branch, 'if')) {
         let [, nc, nt, ...ne] = branch;
-        code += `if (${this.emit(nc, 'value')}) {\n`;
-        code += this.withIndent(() => this.emitBranchWithReturn(nt));
-        code += this.indent() + '}';
-        for (let rb of ne) { code += ' else {\n'; code += this.withIndent(() => this.emitBranchWithReturn(rb)); code += this.indent() + '}'; }
+        code += this.emitIfElseEarlyReturnsChain(nc, nt, ne);
       } else {
         code += '{\n';
         code += this.withIndent(() => this.emitBranchWithReturn(branch));
@@ -2979,31 +3501,7 @@ export class CodeEmitter {
     if (needsIIFE) {
       // Enclosed: condition, thenBranch, elseBranches
       let hasAwait = this.containsAwait(condition) || this.containsAwait(thenBranch) || elseBranches.some(b => this.containsAwait(b));
-      let code = this.asyncIIFEOpen(hasAwait) + ' ';
-      code += `if (${this.emit(condition, 'value')}) `;
-      code += this.emitBlockWithReturns(thenBranch);
-      for (let branch of elseBranches) {
-        code += ' else ';
-        if (this.is(branch, 'if')) {
-          let [_, nc, nt, ...ne] = branch;
-          code += `if (${this.emit(nc, 'value')}) `;
-          code += this.emitBlockWithReturns(nt);
-          for (let nb of ne) {
-            code += ' else ';
-            if (this.is(nb, 'if')) {
-              let [__, nnc, nnt, ...nne] = nb;
-              code += `if (${this.emit(nnc, 'value')}) `;
-              code += this.emitBlockWithReturns(nnt);
-              elseBranches.push(...nne);
-            } else {
-              code += this.emitBlockWithReturns(nb);
-            }
-          }
-        } else {
-          code += this.emitBlockWithReturns(branch);
-        }
-      }
-      return code + ' })()';
+      return this.asyncIIFEOpen(hasAwait) + ' ' + this.emitIfChain(condition, thenBranch, elseBranches) + ' })()';
     }
     let thenExpr = this.extractExpression(this.unwrapIfBranch(thenBranch));
     let elseExpr = this.buildTernaryChain(elseBranches);
@@ -3012,6 +3510,23 @@ export class CodeEmitter {
     return `(${condCode} ? ${thenExpr} : ${elseExpr})`;
   }
 
+  // Recursive emitter for `if / else if / else` chains in IIFE/value contexts.
+  // Walks the right-recursive AST: ["if", cond, then, else?] where `else` may
+  // itself be another `["if", ...]` for an elseif chain.
+  emitIfChain(condition, thenBranch, elseBranches) {
+    let code = `if (${this.emit(condition, 'value')}) ` + this.emitBlockWithReturns(thenBranch);
+    for (let branch of elseBranches) {
+      code += ' else ';
+      if (this.is(branch, 'if')) {
+        let [, nc, nt, ...ne] = branch;
+        code += this.emitIfChain(nc, nt, ne);
+      } else {
+        code += this.emitBlockWithReturns(branch);
+      }
+    }
+    return code;
+  }
+
   emitIfAsStatement(condition, thenBranch, elseBranches) {
     let code = `if (${this.unwrap(this.emit(condition, 'value'))}) `;
     code += this.emit(this.unwrapIfBranch(thenBranch), 'statement');
@@ -3210,6 +3725,67 @@ export class CodeEmitter {
     return null;
   }
 
+  // Walk a destructuring LHS and reject shapes that aren't valid binding
+  // patterns. `null` array elements are elision (valid). Identifiers are
+  // strings and parse as leaves. Member-access (`obj.x`) and bracket-index
+  // (`arr[i]`) shapes are valid as assignment targets. Optional chains
+  // (`obj?.x`, `arr?.[i]`) are NOT valid in JS destructuring assignment
+  // targets, so we reject them. Comprehensions, arithmetic, calls, etc.
+  // are unconditionally rejected.
+  _validateBindingPattern(node, sexpr) {
+    if (!Array.isArray(node)) return;
+    let head = node[0];
+    if (head === 'comprehension' || head === 'object-comprehension') {
+      this.error(`Cannot use ${head} as a destructuring target`, sexpr);
+    }
+    if (head === 'array') {
+      for (let elem of node.slice(1)) this._validateBindingPattern(elem, sexpr);
+      return;
+    }
+    if (head === 'object') {
+      // Object entry shapes used by the grammar:
+      //   [null, k, k]      — shorthand {x}; both slots are the same identifier
+      //   [":", k, target]  — rename {a: target}; recurse into target
+      //   ["=", k, default] — default {a = 5}; key is identifier, default is RHS
+      //   ["...", target]   — rest {...rest}; recurse into target
+      // Anything else is unexpected; fail loudly so future grammar additions
+      // can't silently pass through unvalidated.
+      for (let entry of node.slice(1)) {
+        if (!Array.isArray(entry)) continue;
+        let h = entry[0];
+        if (h === null) {
+          // Shorthand {x}: target is entry[2], which must be a bare identifier
+          // (validated by the array-leaf rules below).
+          this._validateBindingPattern(entry[2], sexpr);
+        } else if (h === ':') {
+          this._validateBindingPattern(entry[2], sexpr);
+        } else if (h === '=') {
+          // Default {a = 5}: key (entry[1]) is the binding target.
+          this._validateBindingPattern(entry[1], sexpr);
+        } else if (h === '...') {
+          this._validateBindingPattern(entry[1], sexpr);
+        } else {
+          this.error(`Unexpected object entry '${h}' in destructuring target`, sexpr);
+        }
+      }
+      return;
+    }
+    // Wrapper shapes that contain a nested target.
+    if (head === '...' || head === 'default' || head === '=') {
+      this._validateBindingPattern(node[1], sexpr);
+      return;
+    }
+    // Member access and bracket index are valid assignment targets.
+    if (head === '.' || head === '[]') return;
+    // Optional chains are NOT valid in JS destructuring-assignment context
+    // (only in optional-chain GET expressions). Reject explicitly.
+    if (head === '?.' || head === 'optindex' || head === 'optcall') {
+      this.error(`Cannot use optional chain as a destructuring target`, sexpr);
+    }
+    // Anything else is an expression that isn't a destructuring shape.
+    this.error(`Cannot use '${head}' expression as a destructuring target`, sexpr);
+  }
+
   unwrapLogical(code) {
     if (typeof code !== 'string') return code;
     while (code.startsWith('(') && code.endsWith(')')) {
@@ -3261,17 +3837,19 @@ export class CodeEmitter {
     return false;
   }
 
+  // Walk the right-recursive AST emitting nested ternaries. `branches` is the
+  // tail of an `if` s-expression — either empty (no else) or one element
+  // (the else, which may itself be another `["if", ...]`).
   buildTernaryChain(branches) {
     if (branches.length === 0) return 'undefined';
-    if (branches.length === 1) return this.extractExpression(this.unwrapIfBranch(branches[0]));
-    let first = branches[0];
-    if (this.is(first, 'if')) {
-      let [_, cond, then_, ...rest] = first;
+    let branch = this.unwrapIfBranch(branches[0]);
+    if (this.is(branch, 'if')) {
+      let [, cond, then_, ...rest] = branch;
       let thenPart = this.extractExpression(this.unwrapIfBranch(then_));
-      let elsePart = this.buildTernaryChain([...rest, ...branches.slice(1)]);
+      let elsePart = this.buildTernaryChain(rest);
       return `(${this.emit(cond, 'value')} ? ${thenPart} : ${elsePart})`;
     }
-    return this.extractExpression(this.unwrapIfBranch(first));
+    return this.extractExpression(branch);
   }
 
   // ---------------------------------------------------------------------------
@@ -3392,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;
@@ -3449,10 +4027,15 @@ let __pendingEffects = new Set();  // Effects queued to run
 let __batching = false;       // Are we inside a batch()?
 
 // Flush all pending effects (called after state updates, or at end of batch)
+// Defense in depth: skip disposed effects. The primary guard is in
+// effect.run() itself — but filtering here avoids even calling .run() on
+// a known-dead effect, which is faster and clearer in stack traces.
 function __flushEffects() {
   const effects = [...__pendingEffects];
   __pendingEffects.clear();
-  for (const effect of effects) effect.run();
+  for (const effect of effects) {
+    if (!effect._disposed) effect.run();
+  }
 }
 
 // Shared primitive coercion (used by state and computed)
@@ -3568,11 +4151,46 @@ function __computed(fn) {
   return computed;
 }
 
-function __effect(fn) {
+function __effect(fn, opts) {
+  let controller = null;
+  let runId = 0;        // increments per run; async resolutions check this to drop stale results
   const effect = {
     dependencies: new Set(),
+    _disposed: false,
+    signal: null,    // AbortSignal for the current run; aborts on re-run / dispose
 
     run() {
+      // Zombie-run guard. An effect can be queued in __pendingEffects
+      // (when a signal it subscribes to changes) and then disposed
+      // before the flush reaches it — e.g. its parent block was
+      // destroyed by an earlier effect in the same flush, and that
+      // destruction's disposers ran effect.dispose(). Without this
+      // guard, run() would execute fn() with __currentEffect = effect,
+      // and any signal .value read inside fn() would re-subscribe the
+      // effect by adding it back to the signal's subscribers Set —
+      // accumulating one leaked subscriber per flush cycle that hits
+      // this race. Symptom: each navigation creates one more component
+      // instance than the previous (N visits => N synchronous mounts
+      // on visit N).
+      if (effect._disposed) return;
+      // Abort the previous run's signal before allocating a new one.
+      // Any async work from the previous run that's still mid-flight
+      // (an await fetch with the signal, for example) sees its signal
+      // go aborted and can bail. This also fires the 'abort' event on
+      // the previous signal so user code subscribed via
+      // signal.addEventListener can run.
+      if (controller) {
+        try { controller.abort(); } catch {}
+      }
+      controller = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+      effect.signal = controller ? controller.signal : null;
+      // Per-run id captured by the closures below. When the effect
+      // re-runs (signal changed) while a prior async body is still
+      // awaiting, the prior body's eventual resolution sees myRun !==
+      // runId and bails — preventing stale cleanup from overwriting
+      // the current run's cleanup.
+      const myRun = ++runId;
+
       if (effect._cleanup) { effect._cleanup(); effect._cleanup = null; }
       for (const dep of effect.dependencies) dep.delete(effect);
       effect.dependencies.clear();
@@ -3580,11 +4198,63 @@ function __effect(fn) {
       __currentEffect = effect;
       try {
         const result = fn();
-        if (typeof result === 'function') effect._cleanup = result;
+        if (typeof result === 'function') {
+          effect._cleanup = result;
+        } else if (result && typeof result.then === 'function') {
+          // Async effect body. We can't unwind a pending await, but we
+          // CAN intercept the eventual resolution and decide whether
+          // to honor any cleanup it returned. Two failure modes are
+          // handled:
+          //   - Effect disposed while body was awaiting: run cleanup
+          //     immediately so resources release, but don't store it.
+          //   - Effect re-ran (newer run superseded this one): same.
+          // In both cases we do NOT touch effect._cleanup, which now
+          // belongs to a different run.
+          result.then(
+            (cleanup) => {
+              if (myRun !== runId || effect._disposed) {
+                if (typeof cleanup === 'function') {
+                  try { cleanup(); }
+                  catch (e) { console.error('[Rip] superseded async cleanup error:', e); }
+                }
+                return;
+              }
+              if (typeof cleanup === 'function') effect._cleanup = cleanup;
+            },
+            (err) => {
+              // AbortError from a dispose or supersede is expected
+              // (the user passed our signal to fetch/etc. and it
+              // aborted). Swallow silently.
+              if (err && err.name === 'AbortError') return;
+              // Stale rejection from a superseded run: caller has
+              // already moved on, no point surfacing.
+              if (myRun !== runId || effect._disposed) return;
+              console.error('[Rip] async effect error:', err);
+            }
+          );
+        }
       } finally { __currentEffect = prev; }
     },
 
     dispose() {
+      // Idempotent: a parent disposer chain may legitimately reach the
+      // same effect twice in tangled cleanup paths. Quick exit avoids
+      // re-running cleanup and re-walking already-empty dependencies.
+      if (effect._disposed) return;
+      effect._disposed = true;
+      // Proactive pending-set eviction. The flush-time guard in
+      // __flushEffects also handles this, but pulling the effect out
+      // of __pendingEffects here keeps the set bounded across long
+      // batched cycles and makes disposal semantics direct rather
+      // than dependent on flush ordering.
+      __pendingEffects.delete(effect);
+      // Abort the current signal so any in-flight async work (a
+      // user's fetch with the signal, a setTimeout-via-signal, etc.)
+      // unwinds via AbortError and the body can bail without mutating
+      // signals on a destroyed component.
+      if (controller) {
+        try { controller.abort(); } catch {}
+      }
       if (effect._cleanup) { effect._cleanup(); effect._cleanup = null; }
       for (const dep of effect.dependencies) dep.delete(effect);
       effect.dependencies.clear();
@@ -3592,7 +4262,29 @@ function __effect(fn) {
   };
 
   effect.run();
-  return () => effect.dispose();
+  const dispose = () => effect.dispose();
+  // Auto-register with the current component (if any) so disposers fire
+  // on component unmount. Without this, every __effect created inside a
+  // component's _init / _setup / _create lived forever — its callback
+  // stayed subscribed to its signals, the closure pinned the component,
+  // and any DOM/event-listener cleanup the effect had returned never
+  // fired. The bridge is intentionally cross-module: the reactive
+  // runtime (this file) doesn't depend on components.js, but components.js
+  // exposes a getter on globalThis.__ripComponent at registration time
+  // and we read it lazily so module-load order is irrelevant.
+  //
+  // {skipRegister: true} opts out of auto-registration. Used by factory
+  // blocks (for-loops, if-blocks in render) that maintain their own
+  // local disposers array and call them via the d(detaching) hook.
+  // Without skipRegister, those effects would be registered TWICE — once
+  // in the local factory disposers and again on the parent component's
+  // _disposers — leaking stale disposer references on every block
+  // re-render until the parent itself unmounts.
+  if (!opts || !opts.skipRegister) {
+    const cur = globalThis.__ripComponent?.__getCurrentComponent?.();
+    if (cur) (cur._disposers ??= []).push(dispose);
+  }
+  return dispose;
 }
 
 function __batch(fn) {
@@ -3606,6 +4298,24 @@ function __batch(fn) {
   }
 }
 
+// Returns the AbortSignal of the currently-running effect, or null if
+// called outside an effect or before AbortController is available.
+// Designed for async-aware effect bodies — capture the signal BEFORE
+// any await so it stays valid for the duration of the body:
+//
+//   (in Rip source)
+//     ~>
+//       signal = getEffectSignal()
+//       data = fetch! url, {signal}
+//       this.data = data
+//
+// On effect re-run or component unmount, the signal aborts; the
+// fetch rejects with AbortError; the body unwinds without touching
+// signals on a destroyed component.
+function __getEffectSignal() {
+  return __currentEffect ? __currentEffect.signal : null;
+}
+
 function __readonly(value) {
   return Object.freeze({ value });
 }
@@ -3647,7 +4357,11 @@ function __catchErrors(fn) {
 
 // Register on globalThis for runtime deduplication
 if (typeof globalThis !== 'undefined') {
-  globalThis.__rip = { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors };
+  globalThis.__rip = { __state, __computed, __effect, __batch, __readonly, __setErrorHandler, __handleError, __catchErrors, __getEffectSignal };
+  // Stdlib-style global so user code can call getEffectSignal() in a
+  // ~> body without importing or destructuring. Mirrors how p, pp,
+  // assert, etc. are registered for ergonomic use.
+  globalThis.getEffectSignal ??= __getEffectSignal;
 }
 
 // === End Reactive Runtime ===
@@ -3702,9 +4416,26 @@ export class Compiler {
 
     // Elide type-only imports — after type stripping, imported names that were
     // only used in type annotations no longer appear in the token stream.
-    // Only elide when at least one name was consumed by type annotation stripping.
-    if (lexer.typeRefNames?.size > 0) {
-      let typeRefNames = lexer.typeRefNames;
+    // The elision is per-specifier, not per-import: a single declaration like
+    // `import { ApiErrors, parseError } from 'm'` where only `ApiErrors` is
+    // type-only becomes `import { parseError } from 'm'`. If all named
+    // specifiers drop and no default/namespace specifier remains, the whole
+    // import is removed.
+    //
+    // A named specifier is "type-only" from the importing file's point of view
+    // when its local binding is unused at runtime. That catches both
+    // (a) names referenced solely in this file's type annotations (now in
+    // typeRefNames) and (b) names imported only as types but never referenced
+    // 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.
+    //
+    // 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) {
@@ -3713,6 +4444,7 @@ export class Compiler {
         if (inImport) continue;
         if (t[0] === 'IDENTIFIER') usedNames.add(t[1]);
       }
+      let isTypeOnly = (local) => !usedNames.has(local);
       for (let i = tokens.length - 1; i >= 0; i--) {
         if (tokens[i][0] !== 'IMPORT') continue;
         let j = i + 1;
@@ -3721,22 +4453,119 @@ export class Compiler {
         if (tokens[j][0] === 'CALL_START' || tokens[j][0] === '(') continue;
         // Skip side-effect imports: import 'module'
         if (tokens[j][0] === 'STRING') continue;
-        // Collect imported names between IMPORT and FROM
-        let names = [];
-        while (j < tokens.length && tokens[j][0] !== 'FROM' && tokens[j][0] !== 'TERMINATOR') {
-          if (tokens[j][0] === 'IDENTIFIER') names.push(tokens[j][1]);
-          j++;
+        // Find FROM / TERMINATOR bounds
+        let fromIdx = -1, endIdx = j;
+        while (endIdx < tokens.length && tokens[endIdx][0] !== 'TERMINATOR') {
+          if (fromIdx === -1 && tokens[endIdx][0] === 'FROM') fromIdx = endIdx;
+          endIdx++;
+        }
+        if (fromIdx === -1) continue;
+        // Locate `{` / `}` for named specifiers
+        let lbIdx = -1, rbIdx = -1;
+        for (let k = i + 1; k < fromIdx; k++) {
+          if (tokens[k][0] === '{') { lbIdx = k; break; }
+        }
+        if (lbIdx !== -1) {
+          for (let k = lbIdx + 1; k < fromIdx; k++) {
+            if (tokens[k][0] === '}') { rbIdx = k; break; }
+          }
+        }
+        // Determine whether a default or namespace specifier exists outside the braces
+        let hasOtherSpec = false;
+        let scanEnd = lbIdx !== -1 ? lbIdx : fromIdx;
+        for (let k = i + 1; k < scanEnd; k++) {
+          let tag = tokens[k][0];
+          if (tag === 'IDENTIFIER' || tag === '*') { hasOtherSpec = true; break; }
+        }
+        // No named specifiers — fall back to whole-import elision
+        if (lbIdx === -1 || rbIdx === -1) {
+          if (hasOtherSpec) {
+            // Default / namespace import: collect outer local names
+            let names = [];
+            let k = i + 1;
+            while (k < fromIdx) {
+              if (tokens[k][0] === 'AS' && k + 1 < fromIdx && tokens[k + 1][0] === 'IDENTIFIER') {
+                names.push(tokens[k + 1][1]); k += 2;
+              } else if (tokens[k][0] === 'IDENTIFIER') {
+                names.push(tokens[k][1]); k++;
+              } else { k++; }
+            }
+            if (names.length === 0 || !names.every(isTypeOnly)) continue;
+            let end = endIdx < tokens.length ? endIdx + 1 : endIdx;
+            tokens.splice(i, end - i);
+          }
+          continue;
+        }
+        // Split brace contents into specifier ranges (start inclusive, end exclusive)
+        // Each specifier is delimited by `,` at depth 0 (the `{}` themselves).
+        let specs = [];
+        let s = lbIdx + 1;
+        while (s < rbIdx) {
+          let e = s;
+          while (e < rbIdx && tokens[e][0] !== ',') e++;
+          if (e > s) specs.push({ start: s, end: e });
+          s = e + 1;
+        }
+        // Determine local name per specifier (after `as` if present)
+        for (let spec of specs) {
+          let local = null;
+          for (let k = spec.start; k < spec.end; k++) {
+            if (tokens[k][0] !== 'IDENTIFIER') continue;
+            if (local === null) local = tokens[k][1];
+            else if (tokens[k - 1]?.[0] === 'AS') local = tokens[k][1];
+          }
+          spec.local = local;
+          spec.drop = local != null && isTypeOnly(local);
+        }
+        let droppedAny = specs.some(s => s.drop);
+        if (!droppedAny) continue;
+        let allDropped = specs.every(s => s.drop);
+        // Outer (default / namespace) local names — needed when all named drop
+        let outerNames = [];
+        if (allDropped && hasOtherSpec) {
+          let k = i + 1;
+          while (k < lbIdx) {
+            if (tokens[k][0] === 'AS' && k + 1 < lbIdx && tokens[k + 1][0] === 'IDENTIFIER') {
+              outerNames.push(tokens[k + 1][1]); k += 2;
+            } else if (tokens[k][0] === 'IDENTIFIER') {
+              outerNames.push(tokens[k][1]); k++;
+            } else { k++; }
+          }
+        }
+        // Splice from right to left to preserve indices
+        if (allDropped) {
+          if (!hasOtherSpec) {
+            // Drop entire import
+            let end = endIdx < tokens.length ? endIdx + 1 : endIdx;
+            tokens.splice(i, end - i);
+          } else if (outerNames.length > 0 && outerNames.every(isTypeOnly)) {
+            // Outer specifiers are also type-only → drop whole import
+            let end = endIdx < tokens.length ? endIdx + 1 : endIdx;
+            tokens.splice(i, end - i);
+          } else {
+            // Remove `{ ... }` and the comma between default and `{`
+            let removeStart = lbIdx, removeEnd = rbIdx + 1;
+            // Strip a leading comma that separated default from `{`
+            let k = lbIdx - 1;
+            while (k > i && tokens[k][0] !== ',' && tokens[k][0] !== 'IDENTIFIER' && tokens[k][0] !== '*') k--;
+            if (k > i && tokens[k][0] === ',') removeStart = k;
+            tokens.splice(removeStart, removeEnd - removeStart);
+          }
+        } else {
+          // Remove dropped specifiers individually, right-to-left, taking one adjacent comma
+          for (let idx = specs.length - 1; idx >= 0; idx--) {
+            let spec = specs[idx];
+            if (!spec.drop) continue;
+            let removeStart = spec.start, removeEnd = spec.end;
+            // Prefer trailing comma; otherwise take leading comma
+            if (removeEnd < rbIdx && tokens[removeEnd][0] === ',') {
+              removeEnd++;
+            } else if (removeStart > lbIdx + 1 && tokens[removeStart - 1][0] === ',') {
+              removeStart--;
+            }
+            tokens.splice(removeStart, removeEnd - removeStart);
+          }
         }
-        if (names.length === 0) continue;
-        // Keep if any name is used at runtime
-        if (names.some(n => usedNames.has(n))) continue;
-        // Only elide if at least one name was used in a type annotation
-        if (!names.some(n => typeRefNames.has(n))) continue;
-        // All imported names are type-only — remove IMPORT through TERMINATOR
-        let end = j;
-        while (end < tokens.length && tokens[end][0] !== 'TERMINATOR') end++;
-        if (end < tokens.length) end++; // include TERMINATOR
-        tokens.splice(i, end - i);
       }
     }
 
@@ -3817,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
@@ -3920,24 +4754,6 @@ export function emit(sexpr, options = {}) {
   return new CodeEmitter(options).compile(sexpr);
 }
 
-export function getStdlibCode() {
-  return `\
-globalThis.abort  ??= (msg) => { if (msg) console.error(msg); process.exit(1); };
-globalThis.assert ??= (v, msg) => { if (!v) throw new Error(msg || "Assertion failed"); };
-globalThis.exit   ??= (code) => process.exit(code || 0);
-globalThis.kind   ??= (v) => v != null ? (v.constructor?.name || Object.prototype.toString.call(v).slice(8, -1)).toLowerCase() : String(v);
-globalThis.noop   ??= () => {};
-globalThis.p      ??= console.log;
-globalThis.pp     ??= (v) => { console.log(JSON.stringify(v, null, 2)); return v; };
-globalThis.raise  ??= (a, b) => { throw (b !== undefined ? new a(b) : new Error(a)); };
-globalThis.rand   ??= (a, b) => b !== undefined ? (a > b && ([a, b] = [b, a]), Math.floor(Math.random() * (b - a + 1) + a)) : a ? Math.floor(Math.random() * a) : Math.random();
-globalThis.sleep  ??= (ms) => new Promise(r => setTimeout(r, ms));
-globalThis.todo   ??= (msg) => { throw new Error(msg || "Not implemented"); };
-globalThis.warn   ??= console.warn;
-globalThis.zip    ??= (...a) => a[0].map((_, i) => a.map(b => b[i]));
-`;
-}
-
 export function getReactiveRuntime() {
   return new CodeEmitter({}).getReactiveRuntime();
 }
@@ -3947,4 +4763,5 @@ export function getComponentRuntime() {
 }
 
 export { formatSExpr };
+export { stringify, getStdlibCode };
 export { RipError, toRipError, formatError, formatErrorHTML } from './error.js';