rip-lang 3.13.133 → 3.13.135

package/src/typecheck.js

@@ -11,6 +11,7 @@
 //   type errors mapped back to Rip source positions.
 
 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 { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { mapToSourcePos, offsetToLine, getLineText, findNearestWord, lineColToOffset, offsetToLineCol, adjustSwitchDiagnostic, isInjectedOverload } from './sourcemap-utils.js';
@@ -32,7 +33,7 @@ export function hasTypeAnnotations(source) {
     line = line.replace(/#.*$/, '');
     // Strip string literals (single and double quoted)
     line = line.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''");
-    return /::[ \t=]/.test(line);
+    return /::[ \t=]/.test(line) || /(?:^|export\s+)type\s+[A-Z]/.test(line.trimStart());
   });
 }
 
@@ -118,25 +119,29 @@ export function parseComponentDTS(dtsString) {
     const name = cm[1];
     const props = [];
     let hasIntrinsicProps = false;
+    let inheritsTag = null;
     let j = i + 1;
     while (j < lines.length) {
       if (/^\}/.test(lines[j])) break;
       if (/constructor\(props\??/.test(lines[j])) {
         if (lines[j].includes('__RipProps<')) hasIntrinsicProps = true;
+        const tagMatch = lines[j].match(/__RipProps<'(\w+)'>/);
+        if (tagMatch) inheritsTag = tagMatch[1];
         if (!lines[j].includes('{')) { j++; continue; }
         j++;
         while (j < lines.length) {
           if (lines[j].includes('__RipProps<')) hasIntrinsicProps = true;
+          if (!inheritsTag) { const tm = lines[j].match(/__RipProps<'(\w+)'>/); if (tm) inheritsTag = tm[1]; }
           if (/^\s*\}\s*(?:&\s*.+)?\);\s*$/.test(lines[j])) { j++; break; }
           const pm = lines[j].match(/^\s+(\w+)(\?)?\s*:\s*(.+);$/);
-          if (pm) props.push({ name: pm[1], type: pm[3].trim(), required: !pm[2] });
+          if (pm && !pm[1].startsWith('__bind_')) props.push({ name: pm[1], type: pm[3].trim(), required: !pm[2] });
           j++;
         }
         continue;
       }
       j++;
     }
-    if (props.length || hasIntrinsicProps) result.set(name, { props, hasIntrinsicProps });
+    if (props.length || hasIntrinsicProps) result.set(name, { props, hasIntrinsicProps, inheritsTag });
     i = Math.max(i + 1, j);
   }
   return result;
@@ -188,49 +193,186 @@ export function patchUninitializedTypes(ts, service, compiledEntries) {
           }
         }
       }
-      if (ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression) &&
-          stmt.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-          ts.isIdentifier(stmt.expression.left)) {
-        const name = stmt.expression.left.text;
-        const sym = uninitialized.get(name);
-        if (sym) {
-          const rhsType = checker.getTypeAtLocation(stmt.expression.right);
-          sym.flags |= ts.SymbolFlags.Transient;
-          sym.links = { type: rhsType };
-          uninitialized.delete(name);
-        }
-      }
-      // Recurse into function bodies
+      patchAssignment(stmt, uninitialized);
+      // Recurse into function bodies (fresh scope)
       if (ts.isFunctionDeclaration(stmt) && stmt.body) {
         patchStatements(stmt.body.statements);
       }
     }
   }
 
-  for (const [filePath] of compiledEntries) {
+  // Walk a statement (and nested blocks) looking for first assignments
+  // to uninitialized variables. Shares the outer scope's map so that
+  // assignments inside if/for/while/try/switch are discovered.
+  function patchAssignment(stmt, uninitialized) {
+    if (!uninitialized.size) return;
+    // Unwrap parenthesized expressions: ({a, b} = ...) → {a, b} = ...
+    const unwrap = (e) => ts.isParenthesizedExpression(e) ? unwrap(e.expression) : e;
+    if (ts.isExpressionStatement(stmt)) {
+      const expr = unwrap(stmt.expression);
+      if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        if (ts.isIdentifier(expr.left)) {
+          const name = expr.left.text;
+          const sym = uninitialized.get(name);
+          if (sym) {
+            const rhsType = checker.getTypeAtLocation(expr.right);
+            sym.flags |= ts.SymbolFlags.Transient;
+            sym.links = { type: rhsType };
+            uninitialized.delete(name);
+          }
+        } else if (ts.isObjectLiteralExpression(expr.left) || ts.isArrayLiteralExpression(expr.left)) {
+          // Destructuring assignment: ({a, b} = {a: 1, b: "hello"})
+          // Walk the LHS pattern and patch each identifier from the RHS type.
+          const rhsType = checker.getTypeAtLocation(expr.right);
+          const patchDestructured = (pattern, contextType) => {
+            if (ts.isObjectLiteralExpression(pattern)) {
+              for (const prop of pattern.properties) {
+                if (ts.isShorthandPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                  const name = prop.name.text;
+                  const sym = uninitialized.get(name);
+                  if (sym) {
+                    const propSym = contextType.getProperty(name);
+                    if (propSym) {
+                      const propType = checker.getTypeOfSymbol(propSym);
+                      sym.flags |= ts.SymbolFlags.Transient;
+                      sym.links = { type: propType };
+                      uninitialized.delete(name);
+                    }
+                  }
+                } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer)) {
+                  const name = prop.initializer.text;
+                  const sym = uninitialized.get(name);
+                  if (sym) {
+                    const key = ts.isIdentifier(prop.name) ? prop.name.text : undefined;
+                    const propSym = key && contextType.getProperty(key);
+                    if (propSym) {
+                      const propType = checker.getTypeOfSymbol(propSym);
+                      sym.flags |= ts.SymbolFlags.Transient;
+                      sym.links = { type: propType };
+                      uninitialized.delete(name);
+                    }
+                  }
+                }
+              }
+            } else if (ts.isArrayLiteralExpression(pattern)) {
+              const tupleTypes = checker.getTypeArguments(contextType);
+              for (let i = 0; i < pattern.elements.length; i++) {
+                const el = pattern.elements[i];
+                if (ts.isIdentifier(el)) {
+                  const name = el.text;
+                  const sym = uninitialized.get(name);
+                  if (sym && tupleTypes && tupleTypes[i]) {
+                    sym.flags |= ts.SymbolFlags.Transient;
+                    sym.links = { type: tupleTypes[i] };
+                    uninitialized.delete(name);
+                  }
+                }
+              }
+            }
+          };
+          patchDestructured(expr.left, rhsType);
+        }
+      }
+    }
+    // Recurse into block-containing statements (but not functions — those get their own scope)
+    const walkBlock = (node) => { if (node) { if (ts.isBlock(node)) node.statements.forEach(s => patchAssignment(s, uninitialized)); else patchAssignment(node, uninitialized); } };
+    if (ts.isIfStatement(stmt)) { walkBlock(stmt.thenStatement); walkBlock(stmt.elseStatement); }
+    if (ts.isForStatement(stmt) || ts.isForInStatement(stmt) || ts.isForOfStatement(stmt) || ts.isWhileStatement(stmt) || ts.isDoStatement(stmt)) walkBlock(stmt.statement);
+    if (ts.isTryStatement(stmt)) { walkBlock(stmt.tryBlock); if (stmt.catchClause) walkBlock(stmt.catchClause.block); if (stmt.finallyBlock) walkBlock(stmt.finallyBlock); }
+    if (ts.isSwitchStatement(stmt)) { for (const clause of stmt.caseBlock.clauses) clause.statements.forEach(s => patchAssignment(s, uninitialized)); }
+    if (ts.isBlock(stmt)) stmt.statements.forEach(s => patchAssignment(s, uninitialized));
+  }
+
+  for (const [filePath, entry] of compiledEntries) {
+    if (!entry.hasTypes) continue; // @ts-nocheck files skip diagnostics; no need to patch
     const sf = program.getSourceFile(toVirtual(filePath));
     if (!sf) continue;
-    patchStatements(sf.statements);
+    try { patchStatements(sf.statements); } catch (e) {
+      console.warn(`[rip] patchTypes failed for ${filePath}: ${e.message}`);
+    }
   }
 }
 
-// TS error codes to skip — Rip resolves modules differently and
-// treats async return types transparently.
+// TS error codes to skip — structural artifacts of Rip's compilation model
+// (DTS coexisting with compiled bodies, overload patterns, etc.)
 export const SKIP_CODES = new Set([
-  2300, // Duplicate identifier (DTS declarations coexist with compiled class bodies)
-  2307, // Cannot find module
   2389, // Function implementation name must match overload (DTS + compiled body)
   2391, // Function implementation is missing (DTS overload sigs separated from implementations)
   2393, // Duplicate function implementation
   2394, // Overload signature not compatible with implementation (untyped compiled params)
-  2451, // Cannot redeclare block-scoped variable
   2567, // Enum declarations can only merge with namespace or other enum (DTS + compiled body)
   2842, // Unused renaming of destructured property (DTS overload has renamed param unused in declaration)
   1064, // Return type of async function must be Promise
-  2582, // Cannot find name 'test' (test runner globals)
-  2593, // Cannot find name 'describe' (test runner globals)
 ]);
 
+// Codes that need conditional suppression (not blanket).
+// 2300/2451: Suppress only when one endpoint is in the DTS header (structural).
+//            Let through when both endpoints are in the compiled body (real shadowing).
+// 2307:     Suppress only for @rip-lang/* and .rip imports (Rip resolves these).
+//            Let through for genuinely broken npm/JS imports.
+// 2582/2593: Suppress only in test files (test runner globals).
+//            Let through in non-test files so typos like `test(...)` are caught.
+export const CONDITIONAL_CODES = new Set([2300, 2451, 2307, 2582, 2593]);
+
+// Shared conditional suppression logic — used by both CLI (runCheck) and LSP
+// (publishDiagnostics). Returns true if the diagnostic should be suppressed.
+//
+// Parameters:
+//   code       — TS diagnostic code (e.g. 2300, 2451, 2307)
+//   start      — byte offset in the virtual .ts content
+//   length     — byte length of the diagnostic span
+//   tsContent  — the full virtual .ts content
+//   headerLines — number of header lines in the virtual .ts
+//   dts        — the .d.ts content (for identifier checks)
+//   flatMessage — flattened diagnostic message string (only needed for 2307)
+//   filePath   — original .rip file path (only needed for 2582/2593)
+export function shouldSuppressConditional(code, start, length, tsContent, headerLines, dts, flatMessage, filePath) {
+  if (code === 2300 || code === 2451) {
+    // Duplicate identifier: suppress when one endpoint is in the DTS header.
+    const diagLine = offsetToLine(tsContent, start);
+    if (diagLine < headerLines) return true; // diagnostic is on the header declaration
+    // Body-side: check if the identifier also lives in the DTS header
+    const ident = length ? tsContent.substring(start, start + length).trim() : '';
+    if (ident && dts) {
+      const escaped = ident.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      if (new RegExp('\\b' + escaped + '\\b').test(dts)) return true; // structural — DTS vs body
+    }
+    return false; // Identifier not in DTS → real shadowing bug
+  }
+  if (code === 2307) {
+    // Cannot find module: suppress only for @rip-lang/* and .rip imports
+    const modMatch = flatMessage?.match(/Cannot find module '([^']+)'/);
+    if (modMatch) {
+      const mod = modMatch[1];
+      if (mod.startsWith('@rip-lang/') || mod.endsWith('.rip')) return true;
+    }
+    return false; // Genuine broken import
+  }
+  if (code === 2582 || code === 2593) {
+    // test/describe globals: suppress only in test files
+    if (!filePath) return false;
+    const base = filePath.replace(/.*[\/]/, '');
+    if (/test|spec/i.test(base)) return true;
+    if (/[\/](test|tests|spec|specs|__tests__)[\/]/i.test(filePath)) return true;
+    return false;
+  }
+  return false;
+}
+
+// Maximum byte offset to scan for a `# @nocheck` comment at the top of a file.
+// Long shebangs, license headers, or multi-line comments could push the directive
+// further down, but 512 bytes covers typical preambles without scanning entire files.
+export const NOCHECK_SCAN_LIMIT = 512;
+
+// Check whether a diagnostic targets a compiler-generated _render() construction
+// variable (_0, _1, …). These typed constants exist solely for prop type-checking
+// and are never read — unused-variable diagnostics on them are spurious.
+export function isRenderConstructionVar(tsContent, start, length) {
+  if (!length) return false;
+  const span = tsContent.substring(start, start + length);
+  return /^_\d+$/.test(span.trim());
+}
+
 // Clean diagnostic messages to hide Rip compiler internals from users.
 // Strips Signal<T>/Computed<T> wrappers, __bind_X__ property names, and
 // removes __bind_*__ entries from inline type displays.
@@ -253,7 +395,12 @@ export function cleanDiagnosticMessage(msg) {
   // Rewrite verbose __ripEl tag union mismatch into a clean JSX-like message
   msg = msg.replace(
     /Argument of type '"([\w-]+)"' is not assignable to parameter of type '(?:__RipTag|[^']*\bkeyof HTMLElementTagNameMap\b[^']*)'\./,
-    "'$1' is not a known HTML or SVG element."
+    "'$1' is not a known element."
+  );
+  // Rewrite verbose __RipTag constraint error (e.g. component extends unknown element)
+  msg = msg.replace(
+    /Type '"([\w-]+)"' does not satisfy the constraint '(?:__RipTag|[^']*\bkeyof HTMLElementTagNameMap\b[^']*)'\./,
+    "'$1' is not a known element."
   );
   // Deduplicate consecutive identical lines (unwrapping can collapse nested messages)
   msg = msg.split('\n').filter((line, i, arr) => i === 0 || line.trim() !== arr[i - 1].trim()).join('\n');
@@ -325,15 +472,17 @@ function replaceFnParams(line, newParams) {
 // Compile a .rip file for type-checking. Prepends DTS declarations to
 // compiled JS, detects type annotations, and builds bidirectional
 // source maps. Returns everything both the CLI and LSP need.
-export function compileForCheck(filePath, source, compiler) {
+// When opts.strict is true, all non-nocheck files are type-checked.
+export function compileForCheck(filePath, source, compiler, opts = {}) {
   const result = compiler.compile(source, { sourceMap: true, types: 'emit', skipPreamble: true, stubComponents: true });
   let code = result.code || '';
   const dts = result.dts ? result.dts.trimEnd() + '\n' : '';
 
   // Determine if this file should be type-checked.
   // A `# @nocheck` comment near the top of the file opts out entirely.
-  const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, 256));
-  const hasOwnTypes = !nocheck && hasTypeAnnotations(source);
+  // 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);
   let importsTyped = false;
   if (!hasOwnTypes && !nocheck) {
     const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
@@ -414,7 +563,12 @@ export function compileForCheck(filePath, source, compiler) {
         // First pass: copy typed params AND return types from signatures to
         // implementations. Typed params give TS type info inside function bodies;
         // return types let TS verify the body matches the declared return.
-        for (const inj of injections) {
+        // When multiple sigs target the same codeLine (overloads), only apply
+        // from the last one — that's the implementation signature whose types
+        // should annotate the function body.
+        const lastByLine = new Map();
+        for (const inj of injections) lastByLine.set(inj.codeLine, inj);
+        for (const inj of lastByLine.values()) {
           const sig = inj.sig.replace(/^declare /, '');
           const sigParams = extractFnParams(sig);
           if (sigParams !== null) {
@@ -512,6 +666,9 @@ export function compileForCheck(filePath, source, compiler) {
               if (cl[k].match(/^(?:export\s+)?(?:class|const)\s+\w+/) && k > j + 1) break;
               const fm = cl[k].match(/^\s+(?:declare\s+)?(\w+):\s+.+;$/);
               if (fm) existingFields.add(fm[1]);
+              // Also match field assignments (e.g. `name = __computed(...)` in component stubs)
+              const am = cl[k].match(/^\s+(\w+)\s*=\s+/);
+              if (am) existingFields.add(am[1]);
               if (cl[k].match(/^\s+_init\s*\(/)) break;
             }
             const missingFields = info.fields.filter(f => !existingFields.has(f.name));
@@ -692,14 +849,14 @@ export function compileForCheck(filePath, source, compiler) {
     if (needSignal || needComputed || needEffect) {
       const decls = [];
       if (needSignal) {
-        if (!/\binterface Signal\b/.test(headerDts)) decls.push('interface Signal<T> { value: T; read(): T; lock(): Signal<T>; free(): Signal<T>; kill(): T; }');
-        decls.push('declare function __state<T>(value: T | Signal<T>): Signal<T>;');
+        if (!/\binterface Signal\b/.test(headerDts)) decls.push(SIGNAL_INTERFACE);
+        decls.push(SIGNAL_FN);
       }
       if (needComputed) {
-        if (!/\binterface Computed\b/.test(headerDts)) decls.push('interface Computed<T> { readonly value: T; read(): T; lock(): Computed<T>; free(): Computed<T>; kill(): T; }');
-        decls.push('declare function __computed<T>(fn: () => T): Computed<T>;');
+        if (!/\binterface Computed\b/.test(headerDts)) decls.push(COMPUTED_INTERFACE);
+        decls.push(COMPUTED_FN);
       }
-      if (needEffect) decls.push('declare function __effect(fn: () => void | (() => void)): () => void;');
+      if (needEffect) decls.push(EFFECT_FN);
       headerDts = decls.join('\n') + '\n' + headerDts;
     }
   }
@@ -748,42 +905,15 @@ export function compileForCheck(filePath, source, compiler) {
   // Inject intrinsic element type declarations for render block type-checking.
   // Uses TypeScript's built-in DOM types (HTMLElementTagNameMap, etc.) as the
   // source of truth for tag names, attribute types, and event handler types.
+  // Skip type aliases if the DTS already includes them (types.js prepends for component files).
   if (hasTypes && (/\b__ripEl\b/.test(code) || /\b__RipProps\b/.test(headerDts))) {
-    const intrinsicDecls = [
-      'type __RipElementMap = HTMLElementTagNameMap & Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>;',
-      'type __RipTag = keyof __RipElementMap;',
-      "type __RipBrowserElement = Omit<HTMLElement, 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & { hidden: boolean | 'until-found'; setAttribute(qualifiedName: string, value: any): void; querySelector(selectors: string): __RipBrowserElement | null; querySelectorAll(selectors: string): NodeListOf<__RipBrowserElement>; closest(selectors: string): __RipBrowserElement | null; };",
-      "type __RipDomEl<K extends __RipTag> = Omit<__RipElementMap[K], 'querySelector' | 'querySelectorAll' | 'closest' | 'setAttribute' | 'hidden'> & __RipBrowserElement;",
-      "type __RipAttrKeys<T> = { [K in keyof T]-?: K extends 'style' ? never : T[K] extends (...args: any[]) => any ? never : K }[keyof T] & string;",
-      'type __RipEvents = { [K in keyof HTMLElementEventMap as `@${K}`]?: ((event: HTMLElementEventMap[K]) => void) | null };',
-      'type __RipClassValue = string | boolean | null | undefined | Record<string, boolean> | __RipClassValue[];',
-      'type __RipProps<K extends __RipTag> = { [P in __RipAttrKeys<__RipElementMap[K]>]?: __RipElementMap[K][P] } & __RipEvents & { ref?: string; class?: __RipClassValue | __RipClassValue[]; style?: string; [k: `data-${string}`]: any; [k: `aria-${string}`]: any };',
-      'declare function __ripEl<K extends __RipTag>(tag: K, props?: __RipProps<K>): void;',
-    ];
-    headerDts = intrinsicDecls.join('\n') + '\n' + headerDts;
+    const alreadyHasTypes = /\btype __RipElementMap\b/.test(headerDts);
+    const parts = alreadyHasTypes ? [INTRINSIC_FN_DECL] : [...INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL];
+    headerDts = parts.join('\n') + '\n' + headerDts;
   }
 
   if (hasTypes && /\bARIA\./.test(code) && !/\bdeclare const ARIA\b/.test(headerDts)) {
-    const ariaDecls = [
-      'type __RipAriaNavHandlers = { next?: () => void; prev?: () => void; first?: () => void; last?: () => void; select?: () => void; dismiss?: () => void; tab?: () => void; char?: () => void; };',
-      "declare const ARIA: {",
-      "  bindPopover(open: boolean, popover: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, source?: (() => Element | null | undefined) | null): void;",
-      "  bindDialog(open: boolean, dialog: () => Element | null | undefined, setOpen: (isOpen: boolean) => void, dismissable?: boolean): void;",
-      "  popupDismiss(open: boolean, popup: () => Element | null | undefined, close: () => void, els?: Array<() => Element | null | undefined>, repos?: (() => void) | null): void;",
-      "  popupGuard(delay?: number): any;",
-      "  listNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers): void;",
-      "  rovingNav(event: KeyboardEvent, handlers: __RipAriaNavHandlers, orientation?: 'vertical' | 'horizontal' | 'both'): void;",
-      "  positionBelow(trigger: Element | null | undefined, popup: Element | null | undefined, gap?: number, setVisible?: boolean): void;",
-      "  position(trigger: Element | null | undefined, floating: Element | null | undefined, opts?: any): void;",
-      "  trapFocus(panel: Element | null | undefined): void;",
-      "  wireAria(panel: Element, id: string): void;",
-      "  lockScroll(instance: any): void;",
-      "  unlockScroll(instance: any): void;",
-      "  hasAnchor: boolean;",
-      "  [key: string]: any;",
-      "};",
-    ];
-    headerDts = ariaDecls.join('\n') + '\n' + headerDts;
+    headerDts = ARIA_TYPE_DECLS.join('\n') + '\n' + headerDts;
   }
 
   let tsContent = (hasTypes ? headerDts + '\n' : '') + code;
@@ -805,6 +935,20 @@ export function compileForCheck(filePath, source, compiler) {
     for (let i = 0; i < dtsLines.length; i++) {
       const line = dtsLines[i];
 
+      // Map import lines by module path (from "..." or from '...')
+      const importMatch = line.match(/^import\s+.+\s+from\s+['"]([^'"]+)['"]/);
+      if (importMatch) {
+        const modulePath = importMatch[1];
+        for (let s = 0; s < srcLines.length; s++) {
+          if (srcLines[s].includes(modulePath) && /^import\s/.test(srcLines[s].trimStart())) {
+            genToSrc.set(i, s);
+            srcToGen.set(s, i);
+            break;
+          }
+        }
+        continue;
+      }
+
       const m = line.match(/^(?:export\s+)?(?:declare\s+)?(?:let|var|type|interface|enum|class)\s+(\w+)/);
       if (!m) continue;
       const name = m[1];
@@ -935,13 +1079,73 @@ export function mapToSource(entry, offset) {
   return tsLine - entry.headerLines;
 }
 
+// ── Project config ─────────────────────────────────────────────────
+
+// Read project config: rip.json in the given directory, or "rip" key in
+// the nearest ancestor package.json.  Returns { strict, exclude }.
+export function readProjectConfig(dir) {
+  const config = {};
+  try {
+    let d = resolve(dir);
+    while (true) {
+      const ripJsonPath = resolve(d, 'rip.json');
+      if (existsSync(ripJsonPath)) {
+        Object.assign(config, JSON.parse(readFileSync(ripJsonPath, 'utf8')));
+        config._configDir = d;
+        break;
+      }
+      const pkgPath = resolve(d, 'package.json');
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (pkg.rip && typeof pkg.rip === 'object') { Object.assign(config, pkg.rip); config._configDir = d; break; }
+      }
+      const parent = dirname(d);
+      if (parent === d) break;
+      d = parent;
+    }
+  } catch {}
+  return config;
+}
+
 // ── CLI batch type-checker ─────────────────────────────────────────
 
-function findRipFiles(dir, files = []) {
+// Convert a simple glob pattern to a RegExp for matching relative paths.
+// Supports: ** (any path segments), * (any within segment), ? (single char).
+export function globToRegex(pattern) {
+  let re = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '*' && pattern[i + 1] === '*') {
+      re += '.*';
+      i += 2;
+      if (pattern[i] === '/') i++; // skip trailing slash after **
+    } else if (c === '*') {
+      re += '[^/]*';
+      i++;
+    } else if (c === '?') {
+      re += '[^/]';
+      i++;
+    } else if (c === '.') {
+      re += '\\.';
+      i++;
+    } else {
+      re += c;
+      i++;
+    }
+  }
+  return new RegExp('^' + re + '$');
+}
+
+function findRipFiles(dir, files = [], excludePatterns = [], rootDir = dir) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
     const full = resolve(dir, entry.name);
-    if (entry.isDirectory()) findRipFiles(full, files);
+    if (excludePatterns.length > 0) {
+      const rel = relative(rootDir, full);
+      if (excludePatterns.some(p => p.test(rel))) continue;
+    }
+    if (entry.isDirectory()) findRipFiles(full, files, excludePatterns, rootDir);
     else if (entry.name.endsWith('.rip')) files.push(full);
   }
   return files;
@@ -973,23 +1177,31 @@ export async function runCheck(targetDir, opts = {}) {
     return 1;
   }
 
-  const allFiles = findRipFiles(rootPath);
+  const ripConfig = readProjectConfig(rootPath);
+
+  // Merge: CLI flags override config file
+  const strict = opts.strict || ripConfig.strict === true;
+  const excludeGlobs = Array.isArray(ripConfig.exclude) ? ripConfig.exclude : [];
+  const excludePatterns = excludeGlobs.map(globToRegex);
+
+  const allFiles = findRipFiles(rootPath, [], excludePatterns);
   if (allFiles.length === 0) {
     console.error(red(`No .rip files found in ${targetDir}`));
     return 1;
   }
 
   // Pre-scan: only compile files that have type annotations or are imported by typed files.
-  // This avoids compiling hundreds of untyped files that would just get @ts-nocheck.
+  // In strict mode, all non-nocheck files are type-checked.
   const typedFiles = new Set();
   const sourcesByPath = new Map();
   for (const fp of allFiles) {
     const source = readFileSync(fp, 'utf8');
     sourcesByPath.set(fp, source);
-    const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, 256));
-    if (!nocheck && hasTypeAnnotations(source)) typedFiles.add(fp);
+    const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, NOCHECK_SCAN_LIMIT));
+    if (!nocheck && (hasTypeAnnotations(source) || strict)) typedFiles.add(fp);
   }
-  // Include imports of typed files
+
+  // Include imports of typed files (files imported BY typed files)
   for (const fp of typedFiles) {
     const source = sourcesByPath.get(fp);
     const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
@@ -1003,6 +1215,17 @@ export async function runCheck(targetDir, opts = {}) {
       }
     }
   }
+  // Include files that import FROM typed files (consumers of typed modules)
+  for (const [fp, source] of sourcesByPath) {
+    if (typedFiles.has(fp)) continue;
+    const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, NOCHECK_SCAN_LIMIT));
+    if (nocheck) continue;
+    const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
+    for (const m of ripImports) {
+      const imported = resolve(dirname(fp), m[1]);
+      if (typedFiles.has(imported)) { typedFiles.add(fp); break; }
+    }
+  }
 
   // Compile only typed files (and their imports)
   const compiled = new Map();
@@ -1011,7 +1234,7 @@ export async function runCheck(targetDir, opts = {}) {
   for (const fp of typedFiles) {
     try {
       const source = sourcesByPath.get(fp);
-      compiled.set(fp, compileForCheck(fp, source, new Compiler()));
+      compiled.set(fp, compileForCheck(fp, source, new Compiler(), { strict }));
     } catch (e) {
       compileErrors++;
       const rel = relative(rootPath, fp);
@@ -1120,12 +1343,15 @@ export async function runCheck(targetDir, opts = {}) {
       if (d.start === undefined) continue;
       if (SKIP_CODES.has(d.code)) continue;
 
-      // Skip 6133 on compiler-generated _render() construction variables (_0, _1, …)
-      if ((d.code === 6133 || d.code === 6196) && d.length > 0) {
-        const span = entry.tsContent.substring(d.start, d.start + d.length);
-        if (/^_\d+$/.test(span.trim())) continue;
+      // Conditional suppression — narrowed instead of blanket
+      if (CONDITIONAL_CODES.has(d.code)) {
+        const flatMsg = d.code === 2307 ? ts.flattenDiagnosticMessageText(d.messageText, '\n') : null;
+        if (shouldSuppressConditional(d.code, d.start, d.length, entry.tsContent, entry.headerLines, entry.dts, flatMsg, fp)) continue;
       }
 
+      // Skip 6133 on compiler-generated _render() construction variables (_0, _1, …)
+      if ((d.code === 6133 || d.code === 6196) && isRenderConstructionVar(entry.tsContent, d.start, d.length)) continue;
+
       // Skip diagnostics on injected overload signatures — the real function
       // definition already carries the same diagnostic.
       if (isInjectedOverload(entry, d.start)) continue;
@@ -1133,6 +1359,10 @@ export async function runCheck(targetDir, opts = {}) {
       const pos = mapToSourcePos(entry, d.start);
       if (!pos) continue;
 
+      // Drop diagnostics that map beyond the source file (e.g. from component
+      // stubs where the compiled line has no real source counterpart).
+      if (pos.line >= srcLines.length) continue;
+
       // Remap IIFE-switch diagnostics to the enclosing function declaration
       const adj = adjustSwitchDiagnostic(entry.source, pos, d.code);
       if (adj) { pos.line = adj.line; pos.col = adj.col; }
@@ -1285,7 +1515,9 @@ export async function runCheck(targetDir, opts = {}) {
         console.log('');
         const lineNum = String(e.line);
         console.log(`${lineNum} ${e.srcLine}`);
-        console.log(`${' '.repeat(lineNum.length)} ${' '.repeat(e.col - 1)}${red('~'.repeat(e.len))}`);
+        const pad = Math.max(0, e.col - 1);
+        const underline = Math.max(1, e.len);
+        console.log(`${' '.repeat(lineNum.length)} ${' '.repeat(pad)}${red('~'.repeat(underline))}`);
       }
 
       if (e.related) {