rip-lang 3.16.0 → 3.16.2

package/src/compiler.js

@@ -16,7 +16,7 @@ import { installComponentSupport } from './components.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 { installSchemaSupport, foldDerivedSchemas } from './schema/schema.js';
 import { SourceMapGenerator } from './sourcemaps.js';
 import { stringify, getStdlibCode } from './stdlib.js';
 import { RipError, toRipError } from './error.js';
@@ -220,6 +220,7 @@ export class CodeEmitter {
     'computed': 'emitComputed',
     'readonly': 'emitReadonly',
     'effect': 'emitEffect',
+    'gate': 'emitGate',
 
     // Control flow — simple
     'break': 'emitBreak',
@@ -227,7 +228,6 @@ export class CodeEmitter {
     '?': 'emitExistential',
     'presence': 'emitPresence',
     '?:': 'emitTernary',
-    '|>': 'emitPipe',
     'loop': 'emitLoop',
     'loop-n': 'emitLoopN',
     'await': 'emitAwait',
@@ -309,6 +309,11 @@ export class CodeEmitter {
     this.functionVars = new Map();
     this.helpers = new Set();
     this.scopeStack = [];  // Track enclosing function scopes for proper variable hoisting
+    // Opt-in projection folding: rewrite foldable `X = Base.pick(...)` derived
+    // schemas into self-contained schema literals before emit (and before DTS,
+    // which reads the same s-expr). Off by default — the browser-bundle
+    // extractor enables it so projections can cross the client boundary.
+    if (this.options.foldProjections) foldDerivedSchemas(sexpr);
     this.collectProgramVariables(sexpr);
     let code = this.emit(sexpr);
 
@@ -322,6 +327,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 +442,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 +502,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 +566,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 +616,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 +689,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 +757,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 +788,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 +892,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 +913,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 +939,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 +1006,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;
     }
 
@@ -919,9 +1080,9 @@ export class CodeEmitter {
 
     if (this.usesTemplates && !skip) {
       if (skipRT) {
-        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        code += 'var { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __gateBind, __Component } = globalThis.__ripComponent;\n';
       } else if (typeof globalThis !== 'undefined' && globalThis.__ripComponent) {
-        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __Component } = globalThis.__ripComponent;\n';
+        code += 'const { __pushComponent, __popComponent, setContext, getContext, hasContext, __clsx, __lis, __reconcile, __transition, __handleComponentError, __gateBind, __Component } = globalThis.__ripComponent;\n';
       } else {
         code += this.getComponentRuntime();
       }
@@ -972,19 +1133,35 @@ export class CodeEmitter {
         return `${this.emit(left, 'value')}.repeat(${this.emit(right, 'value')})`;
       }
     }
-    // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c))
-    let COMPARE_OPS = new Set(['<', '>', '<=', '>=']);
-    if (COMPARE_OPS.has(op) && Array.isArray(left)) {
+    // Chained comparisons: (< (< a b) c) → ((a < b) && (b < c)).
+    // All COMPARE-level ops chain, including equality — otherwise
+    // a == b < c silently compares a boolean to c. Recursing through
+    // the left side handles chains of any length.
+    let COMPARE_OPS = new Set(['<', '>', '<=', '>=', '==', '===', '!=', '!==']);
+    if (COMPARE_OPS.has(op) && Array.isArray(left) && !left.parenthesized) {
       let leftOp = left[0]?.valueOf?.() ?? left[0];
       if (COMPARE_OPS.has(leftOp)) {
-        let a = this.emit(left[1], 'value');
+        let jsOp = (o) => o === '==' ? '===' : o === '!=' ? '!==' : o;
+        let leftCode = this.emit(left, 'value');
         let b = this.emit(left[2], 'value');
         let c = this.emit(right, 'value');
-        return `((${a} ${leftOp} ${b}) && (${b} ${op} ${c}))`;
+        return `(${leftCode} && (${b} ${jsOp(op)} ${c}))`;
       }
     }
     if (op === '==') op = '===';
     if (op === '!=') op = '!==';
+    // JS requires the base of ** to be an UpdateExpression: a bare unary
+    // (typeof x ** 2, !a ** b, await f() ** 2) is a SyntaxError unless
+    // parenthesized. Wrap unary-headed left operands that emit bare.
+    if (op === '**' && Array.isArray(left)) {
+      let UNARY_HEADS = new Set(['!', '~', 'typeof', 'void', 'delete', 'await', 'not', '+', '-']);
+      let leftHead = left[0]?.valueOf?.() ?? left[0];
+      if (UNARY_HEADS.has(leftHead)) {
+        let lc = this.emit(left, 'value');
+        if (!lc.startsWith('(')) lc = `(${lc})`;
+        return `(${lc} ** ${this.emit(right, 'value')})`;
+      }
+    }
     return `(${this.emit(left, 'value')} ${op} ${this.emit(right, 'value')})`;
   }
 
@@ -1042,15 +1219,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 +1308,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 +1355,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 +1522,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 +1534,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 +1546,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('...') &&
@@ -1461,6 +1628,12 @@ export class CodeEmitter {
     return `const ${str(name) ?? name} = ${this.emit(expr, 'value')}`;
   }
 
+  // The component macro consumes 'gate' statements before generator dispatch,
+  // so reaching this generator means the binding sits outside a component body.
+  emitGate(head, rest, context, sexpr) {
+    this.error(`'<~' (render-ready gate) is only valid at the top of a component body`, sexpr);
+  }
+
   emitEffect(head, rest) {
     let [target, body] = rest;
     this.usesReactivity = true;
@@ -1514,31 +1687,63 @@ export class CodeEmitter {
     return `(${this.unwrap(this.emit(cond, 'value'))} ? ${this.emit(then_, 'value')} : ${this.emit(else_, 'value')})`;
   }
 
-  emitPipe(head, rest) {
-    let [left, right] = rest;
-    let leftCode = this.emit(left, 'value');
-    // Detect function calls: [fn, ...args] where fn is an identifier or accessor
-    if (Array.isArray(right) && right.length > 1) {
-      let fn = right[0];
-      let isCall = Array.isArray(fn) || (typeof fn === 'string' && /^[a-zA-Z_$]/.test(fn));
-      if (isCall) {
-        let fnCode = this.emit(fn, 'value');
-        let args = right.slice(1).map(a => this.emit(a, 'value'));
-        return `${fnCode}(${leftCode}, ${args.join(', ')})`;
-      }
-    }
-    // Simple reference or property access — call with left as sole arg
-    return `${this.emit(right, 'value')}(${leftCode})`;
-  }
-
-  emitLoop(head, rest) {
+  emitLoop(head, rest, context) {
+    if (context === 'value') return this.emitLoopAsValue('while (true)', rest[0]);
     return `while (true) ${this.emitLoopBody(rest[0])}`;
   }
 
-  emitLoopN(head, rest) {
+  emitLoopN(head, rest, context) {
     let [count, body] = rest;
     let n = this.emit(count, 'value');
-    return `for (let it = 0; it < ${n}; it++) ${this.emitLoopBody(body)}`;
+    let header = `for (let it = 0; it < ${n}; it++)`;
+    if (context === 'value') return this.emitLoopAsValue(header, body);
+    return `${header} ${this.emitLoopBody(body)}`;
+  }
+
+  // Loops used as expressions collect each iteration's last body value into
+  // an array (CoffeeScript semantics): x = (f() while c) → x = [f(), ...].
+  // Mirrors emitForIn's value-context routing through comprehensions.
+  emitLoopAsValue(header, body, guard) {
+    let hasAwait = this.containsAwait(body) || (guard != null && this.containsAwait(guard));
+    let code = this.asyncIIFEOpen(hasAwait) + '\n';
+    this.indentLevel++;
+    code += this.indent() + 'const result = [];\n';
+    code += this.indent() + header + ' {\n';
+    this.indentLevel++;
+    if (guard != null) {
+      code += this.indent() + `if (!(${this.unwrap(this.emit(guard, 'value'))})) continue;\n`;
+    }
+
+    let stmts;
+    if (!Array.isArray(body)) stmts = [body];
+    else if (body[0] === 'block') stmts = body.slice(1);
+    else if (Array.isArray(body[0])) stmts = body;
+    else stmts = [body];
+
+    let loopStmts = ['for-in', 'for-of', 'for-as', 'while', 'loop'];
+    let hasCtrl = (node) => {
+      if (typeof node === 'string' && (node === 'break' || node === 'continue')) return true;
+      if (!Array.isArray(node)) return false;
+      if (['break', 'continue', 'return', 'throw'].includes(node[0])) return true;
+      if (node[0] === 'if') return node.slice(1).some(hasCtrl);
+      return node.some(hasCtrl);
+    };
+
+    for (let i = 0; i < stmts.length; i++) {
+      let s = stmts[i], isLast = i === stmts.length - 1;
+      if (!isLast || hasCtrl(s) || (Array.isArray(s) && loopStmts.includes(s[0]))) {
+        code += this.indent() + this.addSemicolon(s, this.emit(s, 'statement')) + '\n';
+      } else {
+        code += this.indent() + `result.push(${this.emit(s, 'value')});\n`;
+      }
+    }
+
+    this.indentLevel--;
+    code += this.indent() + '}\n';
+    code += this.indent() + 'return result;\n';
+    this.indentLevel--;
+    code += this.indent() + '})()';
+    return code;
   }
 
   emitAwait(head, rest) { return `await ${this.emit(rest[0], 'value')}`; }
@@ -1777,10 +1982,11 @@ export class CodeEmitter {
     return code;
   }
 
-  emitWhile(head, rest) {
+  emitWhile(head, rest, context) {
     let cond = rest[0], guard = rest.length === 3 ? rest[1] : null, body = rest[rest.length - 1];
-    let code = `while (${this.unwrap(this.emit(cond, 'value'))}) `;
-    return code + (guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body));
+    let header = `while (${this.unwrap(this.emit(cond, 'value'))})`;
+    if (context === 'value') return this.emitLoopAsValue(header, body, guard);
+    return header + ' ' + (guard ? this.emitLoopBodyWithGuard(body, guard) : this.emitLoopBody(body));
   }
 
   emitRange(head, rest) {
@@ -1896,7 +2102,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 +2215,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 +2796,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 +2805,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 +2814,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 +2890,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 +2909,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 +2923,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 +3060,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 +3129,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 +3180,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 +4030,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 +4489,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) {
@@ -4308,7 +4637,7 @@ export class Compiler {
     // If only terminators remain (type-only source), emit types and return early
     if (tokens.every(t => t[0] === 'TERMINATOR')) {
       if (typeTokens && _typesEmitter) dts = _typesEmitter(typeTokens, ['program'], source);
-      return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {} };
+      return { tokens, sexpr: ['program'], code: '', dts, data: dataSection, reactiveVars: {}, gates: [] };
     }
 
     // Step 3: Parse — shim adapter wraps token values with metadata
@@ -4377,11 +4706,18 @@ 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
       // bundle build script overrides to 'browser' for size reduction.
       schemaMode: this.options.schemaMode,
+      // Opt-in: fold derived projection schemas to self-contained literals.
+      foldProjections: this.options.foldProjections,
       sourceMap,
     });
     let code = generator.compile(sexpr);
@@ -4408,12 +4744,14 @@ export class Compiler {
       code += `\n//# sourceMappingURL=${this.options.filename}.js.map`;
     }
 
-    // Step 5: Emit .d.ts from annotated tokens + parsed s-expression
+    // Step 5: Emit .d.ts from annotated tokens + parsed s-expression. The
+    // generator's `_schemaBehavior` buffer (populated during codegen, shadow-TS
+    // mode only) lets the type emitter infer computed/derived return types.
     if (typeTokens && _typesEmitter) {
-      dts = _typesEmitter(typeTokens, sexpr, source);
+      dts = _typesEmitter(typeTokens, sexpr, source, generator._schemaBehavior, generator._schemaAnon);
     }
 
-    return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars };
+    return { tokens, sexpr, code, dts, map, reverseMap, data: dataSection, reactiveVars: generator.reactiveVars, gates: generator._gateDecls || [] };
   }
 
   compileToJS(source) { return this.compile(source).code; }
@@ -4480,6 +4818,126 @@ export function emit(sexpr, options = {}) {
   return new CodeEmitter(options).compile(sexpr);
 }
 
+// =============================================================================
+// Client projection extraction (browser bundle boundary)
+// =============================================================================
+//
+// When a browser-bundled module imports a binding from a server-only file
+// (e.g. `import { UserView } from '../api/models.rip'`), that file can't ship
+// to the browser — it carries the model's ORM/DDL. This lifts ONLY the named
+// bindings, and only when each is a self-contained schema, into a synthetic
+// shared module the browser can compile.
+//
+// The source is compiled with projection folding ON, so a derived schema
+// (`UserView = User.pick(...)`) becomes a source-free `__schema({...})` literal.
+// A binding is shippable iff it's such a literal AND not a :model AND carries
+// no behavior (methods/computed/transforms — which compile to functions that
+// could close over server-only imports). Anything else is refused with a
+// reason, keeping server code out of the browser by construction.
+//
+// Returns { ok: true, source } where `source` is synthetic .rip the browser can
+// compile, or { ok: false, error } listing every binding that can't be shipped.
+
+function skipJsString(code, i, quote) {
+  i++;
+  while (i < code.length && code[i] !== quote) {
+    if (code[i] === '\\') i += 2; else i++;
+  }
+  return i + 1;
+}
+
+// Locate a top-level `NAME = __schema(...)` binding in compiled JS and return
+// { text, isModel, hasBehavior } — or null when NAME isn't bound to a __schema
+// literal (an unfolded `Model.pick(x)` call, a function, a plain value, or
+// absent). Balanced extraction skips nested parens/brackets/braces and strings.
+function findSchemaLiteral(code, name) {
+  // `name` is a schema identifier, but `$` is both a valid identifier char and
+  // a regex metacharacter, so escape before interpolating into the pattern.
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`(?:^|\\n)\\s*(?:export\\s+const\\s+)?${escaped}\\s*=\\s*__schema\\(`, 'g');
+  const m = re.exec(code);
+  if (!m) return null;
+  let i = m.index + m[0].length; // just past the opening '('
+  const start = i;
+  let depth = 1;
+  while (i < code.length && depth > 0) {
+    const c = code[i];
+    if (c === '"' || c === "'" || c === '`') { i = skipJsString(code, i, c); continue; }
+    if (c === '(' || c === '[' || c === '{') depth++;
+    else if (c === ')' || c === ']' || c === '}') depth--;
+    i++;
+  }
+  if (depth !== 0) return null;
+  const argText = code.slice(start, i - 1);
+  // Behavior is detected structurally, not by scanning for the word "function":
+  // a callable entry surfaces as `tag: "computed"|...`, and a field transform as
+  // `transform: (function…)`. A bare `\bfunction\b` would also match a literal
+  // VALUE like `kind! "function" | "class"` and wrongly refuse a plain shape.
+  return {
+    text: `__schema(${argText})`,
+    isModel: /^\s*\{\s*kind:\s*"model"/.test(argText),
+    hasBehavior: /\btransform:/.test(argText) || /tag:\s*"(?:computed|method|hook|ensure|derived)"/.test(argText),
+  };
+}
+
+export function extractClientProjections(source, names, { filename } = {}) {
+  let compiled;
+  try {
+    compiled = new Compiler({
+      filename,
+      foldProjections: true,
+      skipPreamble: true,
+      skipRuntimes: true,
+      skipDataPart: true,
+      skipImports: true,
+    }).compile(source);
+  } catch (e) {
+    return { ok: false, error: `failed to compile ${filename || 'module'}: ${e.message}` };
+  }
+  const code = compiled.code || '';
+  // Every schema bound in this source — lets us tell a nested *schema-typed*
+  // field (`items! OrderItem[]` → `typeName: "OrderItem"`) apart from a
+  // primitive (`typeName: "string"`).
+  const defined = new Set();
+  for (const m of code.matchAll(/(?:^|\n)\s*(?:export\s+const\s+)?(\w+)\s*=\s*__schema\(/g)) defined.add(m[1]);
+
+  const lines = [];
+  const errors = [];
+  const where = filename ? ` from '${filename}'` : '';
+  const requested = new Set(names);
+  const seen = new Set();
+  // Process requested names, then transitively any schema they reference by a
+  // field type — otherwise the shared module ships a shape whose nested type
+  // isn't registered in the browser, and that field's validation is *silently*
+  // skipped. A pulled-in dependency that isn't itself shippable is a hard error.
+  const queue = [...names];
+  while (queue.length) {
+    const name = queue.shift();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const lit = findSchemaLiteral(code, name);
+    const isDep = !requested.has(name);
+    const tag = isDep ? `'${name}'${where} (a nested type of a shipped projection)` : `'${name}'${where}`;
+    if (!lit) {
+      errors.push(isDep
+        ? `${tag} isn't a shippable schema, so the projection referencing it can't cross to the browser`
+        : `${tag} isn't a shippable schema — only a schema or a folded projection (e.g. ${name} = Model.pick(...)) can cross to the browser`);
+    } else if (lit.isModel) {
+      errors.push(`${tag} is a :model — ship a projection like ${name}.pick(...)/.omit(...) instead of the model (which carries ORM/DDL)`);
+    } else if (lit.hasBehavior) {
+      errors.push(`${tag} carries behavior (methods/computed/transforms) that may close over server-only code — project it to plain fields before importing it client-side`);
+    } else {
+      lines.push(`export ${name} = ${lit.text}`);
+      for (const tm of lit.text.matchAll(/typeName:\s*"(\w+)"/g)) {
+        const dep = tm[1];
+        if (defined.has(dep) && !seen.has(dep)) queue.push(dep);
+      }
+    }
+  }
+  if (errors.length) return { ok: false, error: errors.join('; ') };
+  return { ok: true, source: lines.join('\n') + '\n' };
+}
+
 export function getReactiveRuntime() {
   return new CodeEmitter({}).getReactiveRuntime();
 }