rip-lang 3.13.136 → 3.14.0

package/src/typecheck.js

@@ -12,9 +12,10 @@
 
 import { Compiler, getStdlibCode } from './compiler.js';
 import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN } from './types.js';
+import { hasSchemas } from './schema.js';
 import { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
-import { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload } from './sourcemap-utils.js';
+import { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload, srcToOffset } from './sourcemap-utils.js';
 import { resolve, relative, dirname } from 'path';
 import { buildLineMap } from './sourcemaps.js';
 
@@ -198,6 +199,54 @@ export function patchUninitializedTypes(ts, service, compiledEntries) {
       if (ts.isFunctionDeclaration(stmt) && stmt.body) {
         patchStatements(stmt.body.statements);
       }
+      // Recurse into function expressions / arrows in known patterns:
+      // - Variable initializers: const x = __computed(() => { ... })
+      // - Call expression arguments: __effect(() => { ... })
+      // Avoids broad ts.forEachChild to prevent patching unrelated nested scopes.
+      const walkInitializersAndArgs = (node) => {
+        if (!node) return;
+        if ((ts.isFunctionExpression(node) || ts.isArrowFunction(node)) && node.body) {
+          if (ts.isBlock(node.body)) patchStatements(node.body.statements);
+          return;
+        }
+        // Variable declarations: recurse into each initializer
+        if (ts.isVariableStatement(node)) {
+          for (const decl of node.declarationList.declarations) {
+            if (decl.initializer) walkInitializersAndArgs(decl.initializer);
+          }
+          return;
+        }
+        // Expression statements: recurse into the expression
+        if (ts.isExpressionStatement(node)) {
+          walkInitializersAndArgs(node.expression);
+          return;
+        }
+        // Call expressions: recurse into each argument
+        if (ts.isCallExpression(node)) {
+          for (const arg of node.arguments) walkInitializersAndArgs(arg);
+          // Also check the expression being called (e.g., chained calls)
+          if (ts.isCallExpression(node.expression)) walkInitializersAndArgs(node.expression);
+          return;
+        }
+        // Parenthesized: unwrap
+        if (ts.isParenthesizedExpression(node)) {
+          walkInitializersAndArgs(node.expression);
+          return;
+        }
+        // Class declarations/expressions: recurse into property initializers and method bodies
+        if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+          for (const member of node.members) {
+            if (ts.isPropertyDeclaration(member) && member.initializer) {
+              walkInitializersAndArgs(member.initializer);
+            }
+            if ((ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member)) && member.body) {
+              patchStatements(member.body.statements);
+            }
+          }
+          return;
+        }
+      };
+      walkInitializersAndArgs(stmt);
     }
   }
 
@@ -482,7 +531,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   // A `# @nocheck` comment near the top of the file opts out entirely.
   // In strict mode, all non-nocheck files are type-checked.
   const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, NOCHECK_SCAN_LIMIT));
-  const hasOwnTypes = !nocheck && (hasTypeAnnotations(source) || !!opts.strict);
+  const hasOwnTypes = !nocheck && (hasTypeAnnotations(source) || hasSchemas(source) || !!opts.strict);
   let importsTyped = false;
   if (!hasOwnTypes && !nocheck) {
     const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
@@ -716,6 +765,28 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     }
   }
 
+  // Remove non-exported `declare class X` blocks from the DTS header when the
+  // code body has `X = class { ... }` (non-exported component stubs).  TS treats
+  // `declare class X` as a class declaration and reports TS2629 when the body
+  // later reassigns `X = class { ... }`.  The body's class expression already
+  // contains all type info (from stubComponents), so the header block is redundant.
+  if (hasTypes && headerDts && code) {
+    const dl = headerDts.split('\n');
+    const removedLines = new Set();
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^declare\s+class\s+(\w+)/);
+      if (!m) continue;
+      const name = m[1];
+      if (!new RegExp('^' + name + '\\s*=\\s*class\\b', 'm').test(code)) continue;
+      let j = i;
+      while (j < dl.length && !dl[j].match(/^\}/)) j++;
+      for (let k = i; k <= j; k++) removedLines.add(k);
+    }
+    if (removedLines.size > 0) {
+      headerDts = dl.filter((_, i) => !removedLines.has(i)).join('\n').trimEnd() + '\n';
+    }
+  }
+
   // Copy typed constructor props parameter to _init(props) in component classes.
   // Components compile constructor(props: T) and _init(props) separately — TS
   // needs _init to have the same props type to avoid noImplicitAny.
@@ -917,13 +988,47 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   }
 
   // Inline hoisted `let` declarations at their first assignment in the shadow
-  // TS file. Rip always hoists `let` to the top of scope for correct JS
-  // scoping. For TypeScript inference, we move the declaration inline so TS
-  // can infer types from initializers (e.g., `let x; x = 1` → `let x = 1`).
-  // Only rewrites same-scope, straight-line assignments — stops at control
-  // flow to avoid changing binding visibility in the shadow file.
+  // TS file, then merge DTS header types into the inlined declarations.
+  //
+  // Phase 1 — straight-line: scan same-indent lines from the hoisted `let`
+  // downward, stopping at structural statements (if/for/while/etc.). This
+  // handles the common case where assignment immediately follows declaration.
+  //
+  // Phase 2 — block-confined: for variables not resolved in phase 1, check
+  // if the first assignment is inside a deeper block and ALL references to
+  // the variable are confined to that block. If so, inline there. TS still
+  // enforces block scoping in non-executed code, so we must verify the
+  // variable isn't referenced after the block exits.
+  //
+  // DTS header types are merged during inlining: `let x: Type = value;`.
+  // Header lines that were merged are removed afterward to avoid TS2454.
   if (hasTypes && code) {
     const cl = code.split('\n');
+    const reEsc = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    // Build DTS header type map for merging
+    const letTypes = new Map();
+    const movedDts = new Set();
+    let dl;
+    if (headerDts) {
+      dl = headerDts.split('\n');
+      for (let i = 0; i < dl.length; i++) {
+        const m = dl[i].match(/^(?:export\s+)?(?:declare\s+)?let\s+(\w+):\s+(.+);$/);
+        if (m) letTypes.set(m[1], { type: m[2], idx: i });
+      }
+    }
+
+    // Helper: inline a variable at the given line
+    const doInline = (v, lineIdx, indent, rhs) => {
+      const dts = letTypes.get(v);
+      if (dts) {
+        cl[lineIdx] = `${indent}let ${v}: ${dts.type} = ${rhs};`;
+        movedDts.add(dts.idx);
+      } else {
+        cl[lineIdx] = `${indent}let ${v} = ${rhs};`;
+      }
+    };
+
     for (let i = 0; i < cl.length; i++) {
       const m = cl[i].match(/^(\s*)let\s+([A-Za-z_$][\w$]*(?:\s*,\s*[A-Za-z_$][\w$]*)*)\s*;\s*$/);
       if (!m) continue;
@@ -932,29 +1037,29 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       for (let k = i - 1; k >= 0; k--) { if (cl[k].trim() !== '') { prev = cl[k]; break; } }
       if (prev !== null && !/\{\s*$/.test(prev)) continue;
 
-      const indent = m[1];
+      const baseIndent = m[1];
       const vars = m[2].split(/\s*,\s*/);
       const inlined = new Set();
       const bailed = new Set();
-      const reEsc = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const scopeEndRe = new RegExp('^' + reEsc(baseIndent) + '}');
 
+      // Phase 1: straight-line scan at base indent
       for (let j = i + 1; j < cl.length; j++) {
         const line = cl[j];
         if (line.trim() === '') continue;
-        // End of scope
-        if (new RegExp('^' + reEsc(indent) + '}').test(line)) break;
+        if (scopeEndRe.test(line)) break;
         // Skip deeper-indented lines
-        if (line.startsWith(indent + '  ')) continue;
-        // Stop at structural statements
-        if (new RegExp('^' + reEsc(indent) + '(?:if\\b|for\\b|while\\b|switch\\b|try\\b|catch\\b|finally\\b|function\\b|class\\b|do\\b|\\{|\\})').test(line)) break;
-
+        if (line.startsWith(baseIndent + '  ')) continue;
+        // Stop at structural statements (if/for/while/switch/try/do/function/class)
+        if (/^\s*(?:if|for|while|switch|try|do|function|class)\s*[\s({]/.test(line)) break;
+        if (/^\s*\} (?:else|catch|finally)/.test(line)) break;
         for (const v of vars) {
           if (inlined.has(v) || bailed.has(v)) continue;
           const ve = reEsc(v);
-          const assignRe = new RegExp('^' + reEsc(indent) + ve + '\\s*=\\s*(.*);\\s*$');
+          const assignRe = new RegExp('^' + reEsc(baseIndent) + ve + '\\s*=(?!=)\\s*(.*);\\s*$');
           const assign = line.match(assignRe);
           if (assign) {
-            cl[j] = `${indent}let ${v} = ${assign[1]};`;
+            doInline(v, j, baseIndent, assign[1]);
             inlined.add(v);
             continue;
           }
@@ -963,10 +1068,70 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
         if (vars.every(v => inlined.has(v) || bailed.has(v))) break;
       }
 
+      // Phase 2: block-confined scan for remaining variables
+      for (const v of vars) {
+        if (inlined.has(v) || bailed.has(v)) continue;
+        const ve = reEsc(v);
+        const vRe = new RegExp('\\b' + ve + '\\b');
+
+        // Find the first reference and first assignment anywhere in the scope
+        let firstRefLine = -1, foundAssign = null;
+        for (let j = i + 1; j < cl.length; j++) {
+          const line = cl[j];
+          if (line.trim() === '') continue;
+          if (scopeEndRe.test(line)) break;
+          if (!vRe.test(line)) continue;
+          if (firstRefLine < 0) firstRefLine = j;
+          if (!foundAssign) {
+            const lineIndent = line.match(/^(\s*)/)[1];
+            const assignRe = new RegExp('^' + reEsc(lineIndent) + ve + '\\s*=(?!=)\\s*(.*);\\s*$');
+            const am = line.match(assignRe);
+            if (am) foundAssign = { line: j, indent: lineIndent, rhs: am[1] };
+          }
+          if (foundAssign) break;
+        }
+
+        if (!foundAssign) continue;
+        if (foundAssign.indent === baseIndent) continue; // phase 1 territory
+        if (firstRefLine !== foundAssign.line) continue;  // read before write
+
+        // Find where the enclosing block exits (first line at indent < assignment indent)
+        let blockEndLine = -1;
+        for (let j = foundAssign.line + 1; j < cl.length; j++) {
+          const line = cl[j];
+          if (line.trim() === '') continue;
+          if (scopeEndRe.test(line)) { blockEndLine = j; break; }
+          const li = line.match(/^(\s*)/)[1];
+          if (li.length < foundAssign.indent.length) { blockEndLine = j; break; }
+        }
+
+        // Check if the variable is referenced after the block exits
+        let hasRefAfterBlock = false;
+        if (blockEndLine >= 0) {
+          for (let j = blockEndLine + 1; j < cl.length; j++) {
+            const line = cl[j];
+            if (line.trim() === '') continue;
+            if (scopeEndRe.test(line)) break;
+            if (vRe.test(line)) { hasRefAfterBlock = true; break; }
+          }
+        }
+
+        if (hasRefAfterBlock) continue; // used outside the block — leave hoisted
+
+        doInline(v, foundAssign.line, foundAssign.indent, foundAssign.rhs);
+        inlined.add(v);
+      }
+
       const remaining = vars.filter(v => !inlined.has(v));
-      cl[i] = remaining.length ? `${indent}let ${remaining.join(', ')};` : '';
+      if (remaining.length) cl[i] = `${baseIndent}let ${remaining.join(', ')};`;
+      else cl[i] = '';
+    }
+    code = cl.join('\n');
+
+    // Remove DTS header lines that were merged into body declarations
+    if (movedDts.size > 0 && dl) {
+      headerDts = dl.filter((_, i) => !movedDts.has(i)).join('\n').trimEnd() + '\n';
     }
-    code = cl.filter(l => l !== '').join('\n');
   }
 
   let tsContent = (hasTypes ? headerDts + '\n' : '') + code;
@@ -975,6 +1140,25 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   // Build bidirectional line maps
   const { srcToGen, genToSrc, srcColToGen } = buildLineMap(result.reverseMap, result.map, headerLines);
 
+  // Fix srcToGen entries that point to lines emptied by Phase 2 inlining.
+  // When a hoisted `let` is inlined, its original line becomes empty (""), but
+  // buildLineMap still maps source lines to that position.  Redirect to the
+  // nearest non-empty alternative from srcColToGen.
+  const tsLines = tsContent.split('\n');
+  for (const [srcLine, genLine] of srcToGen) {
+    if (genLine >= 0 && genLine < tsLines.length && tsLines[genLine] === '') {
+      const colEntries = srcColToGen.get(srcLine);
+      if (colEntries) {
+        for (const e of colEntries) {
+          if (e.genLine >= 0 && e.genLine < tsLines.length && tsLines[e.genLine] !== '') {
+            srcToGen.set(srcLine, e.genLine);
+            break;
+          }
+        }
+      }
+    }
+  }
+
   // Snapshot code-section mappings before DTS mapping can overwrite them.
   // Needed by @ts-expect-error injection which must target code lines, not DTS.
   const codeSrcToGen = new Map(srcToGen);
@@ -1117,7 +1301,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
 
 // ── Source mapping helpers (delegated to sourcemap-utils.js) ───────
 
-export { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload } from './sourcemap-utils.js';
+export { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload, srcToOffset } from './sourcemap-utils.js';
 
 // Map a TypeScript diagnostic offset back to a Rip source line number.
 // Returns -1 if the offset falls in the DTS header.
@@ -1156,7 +1340,9 @@ export function readProjectConfig(dir) {
       if (parent === d) break;
       d = parent;
     }
-  } catch {}
+  } catch (e) {
+    console.warn(`[rip] readProjectConfig error: ${e.message}`);
+  }
   return config;
 }
 
@@ -1305,7 +1491,9 @@ export async function runCheck(targetDir, opts = {}) {
         try {
           const impSrc = readFileSync(imported, 'utf8');
           compiled.set(imported, compileForCheck(imported, impSrc, new Compiler()));
-        } catch {}
+        } catch (e) {
+          console.warn(`[rip] cross-module compile failed for ${imported}: ${e.message}`);
+        }
       }
     }
   }
@@ -1386,7 +1574,10 @@ export async function runCheck(targetDir, opts = {}) {
       const sem = service.getSemanticDiagnostics(vf);
       const syn = service.getSyntacticDiagnostics(vf);
       diags = [...syn, ...sem];
-    } catch {
+    } catch (e) {
+      const rel = relative(rootPath, fp);
+      console.error(`${red('error')} ${cyan(rel)}: diagnostics failed — ${e.message}`);
+      totalErrors++;
       continue;
     }
 
@@ -1555,6 +1746,187 @@ export async function runCheck(targetDir, opts = {}) {
     }
   }
 
+  // ── Source map audit ─────────────────────────────────────────────
+  // Walk every identifier in each Rip source file and verify the source map
+  // round-trip: srcToOffset must resolve, and getQuickInfoAtPosition must
+  // return hover info for it.  Failures indicate source map gaps that make
+  // hover/definition/completion silently break in the editor.
+
+  const AUDIT_SKIP = new Set([
+    'if', 'else', 'then', 'unless', 'switch', 'when', 'for', 'while', 'until',
+    'loop', 'do', 'try', 'catch', 'finally', 'throw', 'return', 'break',
+    'continue', 'yield', 'await', 'new', 'delete', 'typeof', 'instanceof',
+    'in', 'of', 'as', 'is', 'isnt', 'not', 'and', 'or', 'yes', 'no',
+    'true', 'false', 'null', 'undefined', 'this', 'super', 'class', 'extends',
+    'import', 'export', 'from', 'default', 'def', 'render', 'component',
+    'type', 'interface', 'enum', 'const', 'let', 'var', 'void', 'async',
+    'static', 'get', 'set', 'constructor', 'declare', 'implements', 'readonly',
+    'offer', 'accept', 'it', 'stash',
+    // Type keywords — never have hover info in value position
+    'number', 'string', 'boolean', 'any', 'unknown', 'never', 'object',
+    'symbol', 'bigint',
+  ]);
+  // Standard library: runtime globals injected by Rip (no TS declaration)
+  const STDLIB = new Set([
+    'abort', 'assert', 'exit', 'kind', 'noop', 'p', 'pp', 'raise', 'rand',
+    'sleep', 'todo', 'warn', 'zip',
+  ]);
+  // Build string and comment regions for a source line so the audit can
+  // accurately skip identifiers inside strings/comments without being fooled
+  // by interpolation `#{}`, escaped quotes, or apostrophes in double-quoted
+  // strings.  Returns an array of [start, end] ranges that are "non-code".
+  function nonCodeRegions(line) {
+    const regions = [];
+    let i = 0;
+    while (i < line.length) {
+      const ch = line[i];
+      // Single-line comment — any # outside a string starts a comment
+      // (#{} interpolation only exists inside double-quoted strings)
+      if (ch === '#') {
+        regions.push([i, line.length]);
+        return regions;
+      }
+      // String literal
+      if (ch === '"' || ch === "'") {
+        const quote = ch;
+        const start = i;
+        i++;
+        while (i < line.length) {
+          if (line[i] === '\\') { i += 2; continue; }
+          if (line[i] === '#' && line[i + 1] === '{' && quote === '"') {
+            // Interpolation — skip to matching }
+            let depth = 1;
+            i += 2;
+            while (i < line.length && depth > 0) {
+              if (line[i] === '{') depth++;
+              else if (line[i] === '}') depth--;
+              if (depth > 0) i++;
+            }
+            if (i < line.length) i++; // skip closing }
+            continue;
+          }
+          if (line[i] === quote) { i++; break; }
+          i++;
+        }
+        regions.push([start, i]);
+        continue;
+      }
+      i++;
+    }
+    return regions;
+  }
+  let auditGaps = 0;
+  const auditResults = [];
+
+  for (const [fp, entry] of compiled) {
+    if (!entry.hasTypes) continue;
+    const srcLines = entry.source.split('\n');
+    const vf = toVirtual(fp);
+    const gaps = [];
+
+    // Detect render block line ranges (indented under `render`)
+    const renderLines = new Set();
+    let renderIndent = -1;
+    for (let i = 0; i < srcLines.length; i++) {
+      const line = srcLines[i];
+      const trimmed = line.trimStart();
+      const indent = line.length - trimmed.length;
+      if (/^render\b/.test(trimmed)) {
+        renderIndent = indent;
+        renderLines.add(i);
+        continue;
+      }
+      if (renderIndent >= 0) {
+        if (trimmed === '' || indent > renderIndent) { renderLines.add(i); continue; }
+        renderIndent = -1;
+      }
+    }
+
+    for (let line = 0; line < srcLines.length; line++) {
+      const srcLine = srcLines[line];
+      // Skip comments, blank lines, and render blocks
+      if (/^\s*(#|$)/.test(srcLine)) continue;
+      if (renderLines.has(line)) continue;
+
+      // Build string/comment regions for accurate skipping
+      const skipRegions = nonCodeRegions(srcLine);
+
+      // Detect type-annotation region: everything after :: (but not ::=)
+      // e.g. "x:: number = 42" — skip "number" but not "x"
+      // e.g. "def add(a:: number, b:: number):: number" — skip all type words
+      let typeRegions = [];
+      const typeRe = /::\s*/g;
+      let tm;
+      while ((tm = typeRe.exec(srcLine)) !== null) {
+        // Skip :: inside string/comment regions
+        if (skipRegions.some(([s, e]) => tm.index >= s && tm.index < e)) continue;
+        // Find the end of this type annotation (next = or , or ) or EOL)
+        const start = tm.index + tm[0].length;
+        // Walk forward to find the boundary
+        let depth = 0, end = srcLine.length;
+        for (let i = start; i < srcLine.length; i++) {
+          const ch = srcLine[i];
+          if (ch === '(' || ch === '[' || ch === '{' || ch === '<') depth++;
+          else if (ch === ')' || ch === ']' || ch === '}' || ch === '>') {
+            if (depth > 0) depth--;
+            else { end = i; break; }
+          }
+          else if (depth === 0 && (ch === ',' || (ch === '=' && srcLine[i + 1] !== '>'))) { end = i; break; }
+        }
+        typeRegions.push([start, end]);
+      }
+
+      const re = /\b([a-zA-Z_$]\w*)\b/g;
+      let m;
+      while ((m = re.exec(srcLine)) !== null) {
+        const word = m[1];
+        if (AUDIT_SKIP.has(word)) continue;
+        if (STDLIB.has(word)) continue;
+        // Skip @prop references (start with @)
+        if (m.index > 0 && srcLine[m.index - 1] === '@') continue;
+        // Skip base element name in `component extends <element>`
+        if (/\bextends\s+$/.test(srcLine.slice(0, m.index)) && /\bcomponent\b/.test(srcLine)) continue;
+        // Skip words in type-annotation position
+        if (typeRegions.some(([s, e]) => m.index >= s && m.index < e)) continue;
+        // Skip words inside strings or comments
+        if (skipRegions.some(([s, e]) => m.index >= s && m.index < e)) continue;
+
+        const col = m.index;
+        const offset = srcToOffset(entry, line, col);
+        if (offset === undefined) {
+          gaps.push({ line: line + 1, col: col + 1, word, issue: 'no mapping' });
+          continue;
+        }
+        try {
+          const info = service.getQuickInfoAtPosition(vf, offset);
+          if (!info) {
+            gaps.push({ line: line + 1, col: col + 1, word, issue: 'no hover info' });
+          }
+        } catch {
+          gaps.push({ line: line + 1, col: col + 1, word, issue: 'hover query failed' });
+        }
+      }
+    }
+
+    if (gaps.length > 0) {
+      auditResults.push({ file: fp, gaps });
+      auditGaps += gaps.length;
+    }
+  }
+
+  // Print audit results
+  if (auditResults.length > 0) {
+    console.log(bold('\n── Source Map Audit ──\n'));
+    for (const { file, gaps } of auditResults) {
+      const rel = relative(rootPath, file);
+      for (const g of gaps) {
+        const loc = `${cyan(rel)}${dim(':')}${yellow(String(g.line))}${dim(':')}${yellow(String(g.col))}`;
+        console.log(`${loc} ${dim('-')} ${yellow('warning')} ${dim('audit:')} ${g.issue} for '${g.word}'`);
+      }
+    }
+    console.log(`\n${yellow(String(auditGaps))} source map gap${auditGaps === 1 ? '' : 's'} found\n`);
+  }
+
   // Print results — tsc format with Rip source positions
   for (const { file, errors } of fileResults) {
     const rel = relative(rootPath, file);

package/src/types.js

@@ -1,3 +1,5 @@
+import { SCHEMA_INTRINSIC_DECLS, emitSchemaTypes } from './schema.js';
+
 // Type System — Optional type annotations and .d.ts emission for Rip
 //
 // Architecture:
@@ -1320,6 +1322,7 @@ export function emitTypes(tokens, sexpr = null, source = '') {
 
   // Walk s-expression tree for component declarations
   let componentVars = new Set();
+  let hasSchemaDecls = false;
   if (sexpr) {
     usesRipIntrinsicProps = emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, sourceLines) || usesRipIntrinsicProps;
 
@@ -1330,6 +1333,23 @@ export function emitTypes(tokens, sexpr = null, source = '') {
         if (match && componentVars.has(match[1])) lines.splice(k, 1);
       }
     }
+
+    // Schema declarations — strip any prior auto-emitted `declare let Foo`
+    // for the same bindings (they are re-emitted as typed Schema<T>).
+    let schemaLines = [];
+    hasSchemaDecls = emitSchemaTypes(sexpr, schemaLines);
+    if (hasSchemaDecls) {
+      let bindings = new Set();
+      for (let line of schemaLines) {
+        let m = line.match(/(?:declare |export )*const (\w+)/);
+        if (m) bindings.add(m[1]);
+      }
+      for (let k = lines.length - 1; k >= 0; k--) {
+        let m = lines[k].match(/(?:declare |export )*(?:const|let) (\w+)/);
+        if (m && bindings.has(m[1])) lines.splice(k, 1);
+      }
+      lines.push(...schemaLines);
+    }
   }
 
   if (lines.length === 0) return null;
@@ -1353,6 +1373,9 @@ export function emitTypes(tokens, sexpr = null, source = '') {
   if (usesSignal || usesComputed) {
     preamble.push(EFFECT_FN);
   }
+  if (hasSchemaDecls) {
+    preamble.push(...SCHEMA_INTRINSIC_DECLS);
+  }
   if (preamble.length > 0) {
     preamble.push('');
   }
@@ -1546,6 +1569,8 @@ function emitComponentTypes(sexpr, lines, indent, indentLevel, componentVars, so
       } else {
         lines.push(`  constructor(props${propsOpt}: ${inheritedPropsType});`);
       }
+    } else {
+      lines.push(`  constructor(props?: {});`);
     }
     for (let [refName, refType] of refMembers) {
       bodyMembers.push(`  ${refName}: ${refType};`);