rip-lang 3.15.4 → 3.16.1

package/src/typecheck.js

@@ -11,14 +11,250 @@
 //   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-emit.js';
-import { hasSchemas } from './schema/schema.js';
+import { STDLIB_TYPE_DECLS } from './stdlib.js';
+import { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, ARIA_TYPE_DECLS, SIGNAL_INTERFACE, SIGNAL_FN, COMPUTED_INTERFACE, COMPUTED_FN, EFFECT_FN, ripDestructuredNames } from './dts.js';
 import './schema/loader-server.js';   // registers full schema runtime provider
 import { createRequire } from 'module';
 import { readFileSync, existsSync, readdirSync } from 'fs';
-import { resolve, relative, dirname } from 'path';
+import { resolve, relative, dirname, basename, sep as pathSep } from 'path';
 import { buildLineMap } from './sourcemaps.js';
 
+// ── Typed stash: project entry discovery ───────────────────────────
+//
+// The stash type is inferred, not declared. The user's project has a
+// dedicated `<root>/app/stash.rip` file (in the client bundle) that
+// contains a top-level `stash:: <Type> = ...` declaration. The type
+// checker exposes that variable's type as `__RipStash` on the stash
+// file's virtual module. Components splice
+// `import('<rel-to-stash>').__RipStash` into their `app.data` declaration.
+//
+// Discovery: walk up from each file to the nearest dir that contains an
+// `index.rip` AND a `package.json` (the project anchor), then look for
+// `<root>/app/stash.rip`. Cached per-directory for the process lifetime.
+const entryFileCache = new Map(); // dir → entryFile|null
+const stashFileCache = new Map(); // root dir → stashFile|null
+
+// ── Robust import extraction ───────────────────────────────────────
+//
+// Walk a file's `import ...` / dynamic `import(...)` specifiers via Bun's
+// real parser instead of regex-scanning. This is immune to false matches
+// from comments, string literals, regex bodies, and any other place a
+// `from "@rip-lang/..."`-shaped sequence might appear in source.
+//
+// `scanText` is the compiled TS-virtual content (entry.tsContent) when
+// available; we fall back to the raw .rip source for entries that
+// haven't been compiled yet (the only such call site reads a freshly-
+// read package file).
+const _ripImportTranspiler = new Bun.Transpiler({ loader: 'ts' });
+function scanRipPkgImports(scanText) {
+  if (!scanText) return [];
+  let imports;
+  try { imports = _ripImportTranspiler.scanImports(scanText); }
+  catch { return []; }
+  const out = [];
+  for (const imp of imports) {
+    const p = imp.path;
+    if (typeof p === 'string' && p.startsWith('@rip-lang/')) out.push(p);
+  }
+  return out;
+}
+// Type-position `import('@rip-lang/...')` import-types are erased by
+// `scanImports` (they live in type space), so the parser-based scan above
+// never sees them. The DTS pipeline injects exactly these — e.g.
+// `declare router: import('@rip-lang/app').Router` and the `NavOpts` alias
+// — so the referenced package must still be pulled into the TS
+// program or its types silently resolve to `any` (e.g. `push`'s `opts`
+// going unchecked). Used ONLY for package seeding, never the
+// undeclared-import check: these are synthesized references, not source
+// dependencies the user must declare in package.json.
+const _ripImportTypeRe = /\bimport\(\s*(["'])(@rip-lang\/[^"']+)\1\s*\)/g;
+function scanRipPkgImportTypes(scanText) {
+  if (!scanText) return [];
+  const out = [];
+  _ripImportTypeRe.lastIndex = 0;
+  let m;
+  while ((m = _ripImportTypeRe.exec(scanText))) out.push(m[2]);
+  return out;
+}
+// Extract the bare package name (`@rip-lang/foo`) from a specifier
+// that may include a subpath (`@rip-lang/foo/sub/path`).
+function ripPkgRoot(spec) {
+  const i = spec.indexOf('/', '@rip-lang/'.length);
+  return i === -1 ? spec : spec.slice(0, i);
+}
+
+export function findEntryFile(filePath) {
+  let dir = dirname(filePath);
+  const visited = [];
+  while (true) {
+    if (entryFileCache.has(dir)) {
+      const cached = entryFileCache.get(dir);
+      for (const v of visited) entryFileCache.set(v, cached);
+      return cached;
+    }
+    visited.push(dir);
+    const hasAnchor = existsSync(resolve(dir, 'package.json'));
+    if (hasAnchor) {
+      const entry = resolve(dir, 'index.rip');
+      const result = existsSync(entry) ? entry : null;
+      for (const v of visited) entryFileCache.set(v, result);
+      return result;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      for (const v of visited) entryFileCache.set(v, null);
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// Build the relative import specifier from a file to its entry. Always uses
+// posix forward slashes (TS module specifiers are not platform-dependent) and
+// is guaranteed to start with './' or '../'.
+function entryImportSpec(filePath, entryFile) {
+  let rel = relative(dirname(filePath), entryFile);
+  if (pathSep !== '/') rel = rel.split(pathSep).join('/');
+  if (!rel.startsWith('.')) rel = './' + rel;
+  return rel;
+}
+
+// Locate the project's stash file (`<root>/app/stash.rip`). Returns the
+// absolute path or null. Cached per project root.
+export function findStashFile(filePath) {
+  const entryFile = findEntryFile(filePath);
+  if (!entryFile) return null;
+  const root = dirname(entryFile);
+  if (stashFileCache.has(root)) return stashFileCache.get(root);
+  const stash = resolve(root, 'app', 'stash.rip');
+  const result = existsSync(stash) ? stash : null;
+  stashFileCache.set(root, result);
+  return result;
+}
+
+// ── Route tree discovery ───────────────────────────────────────────
+//
+// The project's routes live under `<projectRoot>/app/routes/` — a fixed
+// convention (not configurable) that matches `@rip-lang/server`'s
+// `serve dir: "<root>/app"`, which mounts route files under `app/routes/`.
+// Each `.rip` file there contributes one entry to a
+// generated `__RipRoutes` template-literal union, used for typed
+// `<a href: "...">`, typed `router.push`, and per-route `@params`
+// tightening. Mirrors the runtime rules in `buildRoutes`
+// (packages/app/index.rip): skip `_-prefixed` files, skip files
+// inside `_-prefixed` directories, treat `index.rip` as `/`,
+// `[id]` as a dynamic segment, `[...rest]` as catch-all.
+const routesDirCache  = new Map(); // entryDir → absoluteRoutesDir|null
+const routesTreeCache = new Map(); // routesDir → { entries, union }
+
+// Invalidate the route-tree cache for the project containing `filePath`,
+// or all projects when no path is given. Called by the LSP whenever a
+// `.rip` file is added/removed/renamed so completions, hover, and
+// diagnostics see the new route shape without a process restart.
+export function invalidateRoutesCache(filePath) {
+  if (!filePath) {
+    routesDirCache.clear();
+    routesTreeCache.clear();
+    return;
+  }
+  // Cheap and correct: drop both caches. Reads are O(routes-dir scan),
+  // and the caches refill on the next access. Pin-pointing the exact
+  // entryDir would require re-running findEntryFile, which itself
+  // caches; clearing wholesale avoids the dependency.
+  routesDirCache.clear();
+  routesTreeCache.clear();
+}
+
+export function findRoutesDir(filePath) {
+  const entryFile = findEntryFile(filePath);
+  if (!entryFile) return null;
+  const root = dirname(entryFile);
+  if (routesDirCache.has(root)) return routesDirCache.get(root);
+  // Convention: `app/routes/`. Matches `@rip-lang/server`'s `serve dir:
+  // "<root>/app"` pattern, which resolves routes under `app/routes/`.
+  const dir = resolve(root, 'app/routes');
+  const result = existsSync(dir) ? dir : null;
+  routesDirCache.set(root, result);
+  return result;
+}
+
+// Build per-route metadata and the `__RipRoutes` template-literal union.
+// Each entry: { rel, file, pattern (TS expression), dynamic: [{name, catchAll}] }
+export function walkRoutesDir(routesDir) {
+  if (!routesDir) return { entries: [], union: 'never' };
+  if (routesTreeCache.has(routesDir)) return routesTreeCache.get(routesDir);
+  const entries = [];
+  function walk(dir, segs) {
+    let dirents;
+    try { dirents = readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    for (const e of dirents) {
+      // Skip _-prefixed files (_layout.rip etc.) and dirs (shared
+      // helpers, not pages). Same rule as runtime buildRoutes.
+      if (e.name.startsWith('_')) continue;
+      if (e.isDirectory()) walk(resolve(dir, e.name), [...segs, e.name]);
+      else if (e.isFile() && e.name.endsWith('.rip')) {
+        const base = e.name.slice(0, -'.rip'.length);
+        const fileSegs = base === 'index' ? segs : [...segs, base];
+        const dynamic = [];
+        const displaySegs = [];
+        const tsSegs = fileSegs.map(s => {
+          let m = s.match(/^\[\.\.\.(\w+)\]$/);
+          if (m) { dynamic.push({ name: m[1], catchAll: true }); displaySegs.push('$' + m[1]); return '${string}'; }
+          m = s.match(/^\[(\w+)\]$/);
+          if (m) { dynamic.push({ name: m[1], catchAll: false }); displaySegs.push('$' + m[1]); return '${string}'; }
+          displaySegs.push(s);
+          return s;
+        });
+        const path = '/' + tsSegs.join('/');
+        const displayPath = '/' + displaySegs.join('/');
+        const pattern = dynamic.length === 0
+          ? JSON.stringify(path === '//' ? '/' : path)
+          : '`' + (path === '//' ? '/' : path) + '`';
+        const display = dynamic.length === 0
+          ? null
+          : '`' + (displayPath === '//' ? '/' : displayPath) + '`';
+        entries.push({
+          rel: relative(routesDir, resolve(dir, e.name)),
+          file: resolve(dir, e.name),
+          pattern,
+          display,
+          displayPath,
+          dynamic,
+        });
+      }
+    }
+  }
+  walk(routesDir, []);
+  // Canonical order: index route ("/") first, then the rest by display
+  // path, lexicographically. Filesystem walk order is undefined across
+  // platforms — sorting here gives stable union order and a consistent
+  // member sequence in completions, hovers, and error messages.
+  entries.sort((a, b) => {
+    if (a.displayPath === '/') return -1;
+    if (b.displayPath === '/') return 1;
+    return a.displayPath < b.displayPath ? -1 : a.displayPath > b.displayPath ? 1 : 0;
+  });
+  // Build union, deduping static patterns (template-literal patterns
+  // are inherently distinct by structure). Catch-all routes
+  // (`[...rest].rip`) are excluded — they're runtime 404 fallbacks,
+  // not navigation targets, and including them as `/${string}` would
+  // make the union accept any slash-prefixed string and defeat
+  // typo-catching for every other route.
+  const seen = new Set();
+  const parts = [];
+  for (const e of entries) {
+    if (e.dynamic.some(d => d.catchAll)) continue;
+    if (seen.has(e.pattern)) continue;
+    seen.add(e.pattern);
+    parts.push(e.pattern);
+  }
+  const union = parts.length ? parts.join(' | ') : 'never';
+  const result = { entries, union };
+  routesTreeCache.set(routesDir, result);
+  return result;
+}
+
 // ── Shared helpers ─────────────────────────────────────────────────
 
 // Detect type annotations (:: followed by space or =) ignoring comments,
@@ -154,12 +390,12 @@ export function checkComponentDefs(compProps, srcLines, startLine = 0) {
   const errors = [];
   for (const prop of compProps) {
     for (let s = startLine; s < srcLines.length; s++) {
-      const m = new RegExp('(@' + prop.name + ')\\s*(::|([:!]?=))').exec(srcLines[s]);
+      const m = new RegExp('(@' + prop.name + ')\\??\\s*(::|([:!]?=))').exec(srcLines[s]);
       if (!m) continue;
       if (m[1 + 1] !== '::') {
         errors.push({ line: s, col: m.index, len: m[1].length, propName: prop.name, message: `Prop '${prop.name}' has no type annotation` });
       } else {
-        const dm = srcLines[s].match(new RegExp('@' + prop.name + '\\s*::\\s*(.+?)\\s*:=\\s*(.+)'));
+        const dm = srcLines[s].match(new RegExp('@' + prop.name + '\\??\\s*::\\s*(.+?)\\s*:=\\s*(.+)'));
         if (dm) {
           const defVal = dm[2].replace(/#.*$/, '').trim();
           const err = validatePropDefault(dm[1].trim(), defVal);
@@ -354,6 +590,37 @@ export const SKIP_CODES = new Set([
   1064, // Return type of async function must be Promise
 ]);
 
+// Dedup diagnostics by (start line/col, code).
+// The same TS error can fire twice when the dts header and compiled body
+// both contain the offending construct (e.g. an `import { X }` line that
+// maps to the same source position from both copies), or when a diagnostic
+// hits both an injected function overload signature and its implementation.
+//
+// The key intentionally excludes end position and message: the duplicates we
+// want to collapse routinely differ in span length (overload sig vs impl
+// token widths) and occasionally in message text (TS referencing different
+// candidate signatures). Same start position + same code is the right
+// invariant — distinct logical errors at the exact same (line, col, code)
+// would be vanishingly rare and folding them is preferable to leaking
+// structural duplicates.
+//
+// `getRange(d)` must return `{ startLine, startCol, endLine, endCol }`.
+// Returns a new array; does not mutate the input. Preserves input object
+// identity so callers can use Set membership to find which entries were
+// dropped.
+export function dedupDiagnostics(diags, getRange) {
+  const seen = new Set();
+  const out = [];
+  for (const d of diags) {
+    const r = getRange(d);
+    const key = `${r.startLine}:${r.startCol}:${d.code}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(d);
+  }
+  return out;
+}
+
 // 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).
@@ -375,12 +642,60 @@ export const CONDITIONAL_CODES = new Set([2300, 2451, 2307, 2582, 2593]);
 //   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) {
+export function shouldSuppressConditional(code, start, length, tsContent, headerLines, dts, flatMessage, filePath, relatedInformation) {
   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
+
+    // Body-side: if TS attached relatedInformation pointing at the other
+    // declaration, trust it. When the *other* endpoint is also in the body
+    // (same file), this is a real shadowing collision and must surface.
+    if (Array.isArray(relatedInformation) && relatedInformation.length) {
+      for (const r of relatedInformation) {
+        if (r.start === undefined) continue;
+        // Only consider related info in the same virtual file.
+        if (r.file && r.file.text !== tsContent) continue;
+        const rLine = offsetToLine(tsContent, r.start);
+        if (rLine >= headerLines) return false; // body ↔ body collision — real bug
+      }
+      return true; // every related endpoint sits in the DTS header → structural
+    }
+
+    // Skip the dts-heuristic for import specifiers — TS doesn't double-emit
+    // imports the way it does `def`/`class`, so a body-side 2300 on an import
+    // name is real iff the same name is imported by 2+ body import statements.
+    // (When only one body import has the name, the duplicate is the dts copy
+    // that the typecheck virtual file injects, which is structural noise.)
+    const lineStart = tsContent.lastIndexOf('\n', start - 1) + 1;
+    const lineSoFar = tsContent.substring(lineStart, start);
+    if (/^\s*import\b/.test(lineSoFar)) {
+      const ident = length ? tsContent.substring(start, start + length).trim() : '';
+      if (ident) {
+        // Walk only body lines (past the dts header) and tally imports of `ident`.
+        const bodyStart = (() => {
+          let pos = 0, line = 0;
+          while (line < headerLines && pos < tsContent.length) {
+            const nl = tsContent.indexOf('\n', pos);
+            if (nl < 0) return tsContent.length;
+            pos = nl + 1; line++;
+          }
+          return pos;
+        })();
+        const body = tsContent.slice(bodyStart);
+        const importRe = /^[ \t]*import\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{([^}]*)\}\s+from\b/gm;
+        let im, hits = 0;
+        const wordRe = new RegExp('\\b' + ident.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+        while ((im = importRe.exec(body))) {
+          if (wordRe.test(im[1])) hits++;
+          if (hits > 1) break;
+        }
+        return hits < 2; // suppress only when there's no real body↔body collision
+      }
+      return false;
+    }
+
+    // Fallback when no relatedInformation: use the dts identifier heuristic.
     const ident = length ? tsContent.substring(start, start + length).trim() : '';
     if (ident && dts) {
       const escaped = ident.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -472,21 +787,169 @@ export function cleanDiagnosticMessage(msg) {
   return msg;
 }
 
+// Classify a route-related diagnostic so the message rewrite and the
+// squiggle-snap use one consistent detection. Returns:
+//   'el'    — anchor href mismatch (static __ripEl or dynamic __ripRoute)
+//   'route' — programmatic router.push/replace mismatch
+//   null    — unrelated diagnostic
+//
+// Detection is position-aware: a single source line can host both an anchor
+// and an inline event handler (e.g. `a @click: () -> @router.push(...)`),
+// so substring-checking the whole TS line is ambiguous. Instead we look at
+// the call site immediately preceding the diagnostic's TS offset.
+function classifyRouteDiagnostic(entry, start) {
+  if (!entry?.tsContent || start == null) return null;
+  const before = entry.tsContent.slice(Math.max(0, start - 64), start);
+  if (/(?:__ripEl|__ripRoute)\([^()]*$/.test(before)) return 'el';
+  if (/\.(?:push|replace)\([^()]*$/.test(before)) return 'route';
+  return null;
+}
+
+// Unify route diagnostics with the static __ripEl form so users see one
+// consistent message shape regardless of which call site (anchor href,
+// router.push, etc.) produced the error. Rewrites TS2345 "Argument of
+// type 'X' is not assignable to parameter of type 'Y'." into TS2322
+// "Type 'X' is not assignable to type 'Y | undefined'." Then prettifies
+// `${string}` placeholders in route patterns to their source-form
+// `$paramName` (from `[id].rip` → `$id`). Used by both the CLI
+// (runCheck) and the LSP diagnostic publisher.
+export function unifyRouteDiagnostic(code, message, entry, start, filePath) {
+  const kind = classifyRouteDiagnostic(entry, start);
+  const routesDir = filePath ? findRoutesDir(filePath) : null;
+  const tree = routesDir ? walkRoutesDir(routesDir) : null;
+
+  if ((kind === 'route' || kind === 'el') && code === 2345) {
+    const m = message.match(/^Argument of type '([^']*(?:''[^']*)*)' is not assignable to parameter of type '([^']*(?:''[^']*)*)'\.$/);
+    if (m) {
+      code = 2322;
+      message = `Type '${m[1]}' is not assignable to type '${m[2]} | undefined'.`;
+    }
+  }
+
+  // Prettify ${string} placeholders in known route patterns.
+  if (tree && message.includes('${string}')) {
+    message = prettifyRoutePatterns(message, tree);
+  }
+  // Canonicalize route-union member order (TS normalizes unions, so the
+  // order shifts between error contexts — pin to walkRoutesDir order).
+  if (tree) message = canonicalizeRouteUnion(message, tree);
+  return { code, message };
+}
+
+// Rewrite `${string}` placeholders in route patterns to their source-form
+// `$paramName` (from `[id].rip` → `$id`). Used by diagnostics and hover.
+export function prettifyRoutePatterns(text, tree) {
+  if (!tree || !text || !text.includes('${string}')) return text;
+  for (const e of tree.entries) {
+    if (!e.display) continue;
+    if (e.pattern !== e.display) text = text.split(e.pattern).join(e.display);
+  }
+  return text;
+}
+
+// Reorder route-union members to match walkRoutesDir order. TS normalizes
+// unions internally, so the same set can render in different orders across
+// hover and error contexts. Scans for runs of unioned string/template/
+// undefined members, and if the run exactly covers the known route set
+// (plus optional `undefined`), rewrites it in canonical order. Leaves
+// unrelated unions untouched.
+export function canonicalizeRouteUnion(text, tree) {
+  if (!tree || !text || !text.includes(' | ')) return text;
+  const canonical = [];
+  const seen = new Set();
+  for (const e of tree.entries) {
+    if (e.dynamic.some(d => d.catchAll)) continue;
+    const member = e.display || e.pattern;
+    if (seen.has(member)) continue;
+    seen.add(member);
+    canonical.push(member);
+  }
+  if (canonical.length === 0) return text;
+  const canonicalSet = new Set(canonical);
+  const memberRe = /(?:"[^"]*"|`[^`]*`|undefined)/.source;
+  const unionRe = new RegExp(`${memberRe}(?:\\s*\\|\\s*${memberRe})+`, 'g');
+  return text.replace(unionRe, run => {
+    const parts = run.split(/\s*\|\s*/);
+    const hasUndefined = parts.includes('undefined');
+    const nonUndef = parts.filter(p => p !== 'undefined');
+    if (nonUndef.length !== canonical.length) return run;
+    if (!nonUndef.every(p => canonicalSet.has(p))) return run;
+    const ordered = hasUndefined ? [...canonical, 'undefined'] : canonical;
+    return ordered.join(' | ');
+  });
+}
+
+// Locate the best span for a route diagnostic in the source line. TS
+// reports the span on the generated `__ripEl`/`__ripRoute` call, which
+// source-maps back to imprecise positions. We snap to the meaningful
+// token in the source:
+//   - 'el'    → the `href` attribute name
+//   - 'route' → the method name `push`/`replace`
+export function locateRouteDiagnosticSpan(entry, start, srcLine) {
+  const kind = classifyRouteDiagnostic(entry, start);
+  if (kind === 'el') {
+    const m = srcLine.match(/\bhref\b/);
+    if (m) return { col: m.index, len: 4 };
+  } else if (kind === 'route') {
+    const m = srcLine.match(/\.(push|replace)\b/);
+    if (m) return { col: m.index + 1, len: m[1].length };
+  }
+  return null;
+}
+
 // Base TypeScript compiler settings for type-checking. Callers can
-// pass overrides (e.g. { noImplicitAny: true } for the CLI).
+// pass overrides (e.g. { strict: true } when a project opts in).
+//
+// Default `strict: false` aligns with Rip's stated philosophy
+// ("optional, design scaffolding, not safety rails") and matches the
+// gradual-typing default of comparable systems (Sorbet's `# typed: false`,
+// mypy's permissive default, Hack's `partial`, TypeScript's own pre-strict
+// default). Projects opt UP to strict via package.json's `rip.strict: true`,
+// which implies noImplicitAny, strictNullChecks, and the rest of TS's strict
+// family. Do NOT pin those flags to `false` here — that would shadow the
+// strict-family inference when an opt-in caller passes `{ strict: true }`.
 export function createTypeCheckSettings(ts, overrides = {}) {
   return {
     target: ts.ScriptTarget.ESNext,
     module: ts.ModuleKind.ESNext,
     moduleResolution: ts.ModuleResolutionKind.Bundler,
     allowJs: true,
-    strict: true,
+    strict: false,
     noEmit: true,
     skipLibCheck: true,
     ...overrides,
   };
 }
 
+// Collect ambient type packages (e.g. `@types/bun`, `@types/node`) by
+// walking up from rootPath gathering every `node_modules/@types` dir.
+// TS's default typeRoots only checks `<cwd>/node_modules/@types`, so a
+// sub-package check would miss workspace-root ambients. Accepts symlinks
+// because bun's nested-package layout symlinks `@types/bun` to
+// `.bun/@types+bun@.../node_modules/@types/bun`.
+export function collectAmbientTypes(rootPath) {
+  const typeRoots = [];
+  const types = [];
+  let dir = rootPath;
+  while (true) {
+    const cand = resolve(dir, 'node_modules/@types');
+    if (existsSync(cand)) {
+      typeRoots.push(cand);
+      try {
+        for (const entry of readdirSync(cand, { withFileTypes: true })) {
+          if ((entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith('.') && !types.includes(entry.name)) {
+            types.push(entry.name);
+          }
+        }
+      } catch {}
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { typeRoots, types };
+}
+
 // ── Param helpers ──────────────────────────────────────────────────
 
 // Extract the text between the first balanced ( ) — handles nested parens
@@ -516,14 +979,175 @@ function replaceFnParams(line, newParams) {
   return depth === 0 ? line.slice(0, idx + 1) + newParams + line.slice(i - 1) : line;
 }
 
+// Depth-aware split of a parameter list on top-level commas. Respects
+// nested parens, brackets, braces, and angle brackets so callback types
+// like `(fn: (x: number) => void)` and generic types like `Map<K, V>`
+// don't get split mid-argument.
+//
+// Angle brackets are tracked separately because `>` is ambiguous: it
+// appears in `=>` (function-type arrow), `>=`/`>>`/`>=`, and as a
+// generic-close. We only treat `<` as opening a generic when it
+// follows an identifier-ending character (or another `<` for nested
+// `Map<K, Set<V>>`); arrow `=>` is recognized and skipped before any
+// angle handling. String/template/regex literals are skipped wholesale
+// so commas inside them don't terminate a part.
+function splitTopLevelParams(paramsStr) {
+  const parts = [];
+  let depth = 0;     // counts (), [], {}
+  let angle = 0;     // counts <> when used as generics
+  let start = 0;
+  const isWordEnd = (i) => i > 0 && /[A-Za-z_$0-9>\]]/.test(paramsStr[i - 1]);
+  const skipString = (i, quote) => {
+    let k = i + 1;
+    while (k < paramsStr.length && paramsStr[k] !== quote) {
+      if (paramsStr[k] === '\\') k += 2; else k++;
+    }
+    return k;
+  };
+  for (let i = 0; i < paramsStr.length; i++) {
+    const c = paramsStr[i];
+    // Skip strings to avoid commas / brackets inside string defaults.
+    if (c === '"' || c === "'" || c === '`') {
+      i = skipString(i, c);
+      continue;
+    }
+    if (c === '(' || c === '[' || c === '{') { depth++; continue; }
+    if (c === ')' || c === ']' || c === '}') { depth--; continue; }
+    // Arrow `=>` — ignore the `>` so it doesn't decrement angle/depth.
+    if (c === '=' && paramsStr[i + 1] === '>') { i++; continue; }
+    if (c === '<' && isWordEnd(i)) { angle++; continue; }
+    if (c === '>' && angle > 0) { angle--; continue; }
+    if (c === ',' && depth === 0 && angle === 0) {
+      parts.push(paramsStr.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  const last = paramsStr.slice(start).trim();
+  if (last.length > 0) parts.push(last);
+  return parts;
+}
+
+// Find the top-level `= default` separator in a single parameter slot,
+// skipping `=` inside destructured patterns (`{a = 1, b = 2}`) and inside
+// type expressions. Returns the index of the `=` or -1 if none.
+//
+// A param shape is one of:
+//   simple        — `name`, `name: T`, `name?: T`
+//   rest          — `...rest`, `...rest: T[]`
+//   destructured  — `{a, b}`, `{a, b}: {a: T, b: U}`, `[x, y]: [T, U]`
+//
+// The default arrives at the OUTERMOST level only, after the optional
+// type annotation. Inside the destructured pattern's braces/brackets,
+// `=` denotes per-property defaults (a JS pattern feature) and is not
+// the slot's outer default — those belong to the destructured shape and
+// don't survive the merge. Only the top-level `=` matters.
+//
+// Skips strings/templates and uses the same identifier-aware angle
+// tracking as `splitTopLevelParams` so default expressions containing
+// `=>`, `<`, `>`, comparisons, or generic types don't confuse depth.
+function findOuterDefault(paramPart) {
+  let depth = 0;
+  let angle = 0;
+  const isWordEnd = (i) => i > 0 && /[A-Za-z_$0-9>\]]/.test(paramPart[i - 1]);
+  const skipString = (i, quote) => {
+    let k = i + 1;
+    while (k < paramPart.length && paramPart[k] !== quote) {
+      if (paramPart[k] === '\\') k += 2; else k++;
+    }
+    return k;
+  };
+  for (let i = 0; i < paramPart.length; i++) {
+    const c = paramPart[i];
+    if (c === '"' || c === "'" || c === '`') { i = skipString(i, c); continue; }
+    if (c === '(' || c === '[' || c === '{') { depth++; continue; }
+    if (c === ')' || c === ']' || c === '}') { depth--; continue; }
+    if (c === '<' && isWordEnd(i)) { angle++; continue; }
+    if (c === '>' && angle > 0) { angle--; continue; }
+    if (c === '=' && depth === 0 && angle === 0) {
+      // `==`, `===`, `!=`, `!==`, `>=`, `<=`, `=>` are operators, not
+      // the default `=` separator.
+      const prev = paramPart[i - 1];
+      const next = paramPart[i + 1];
+      if (next === '=' || next === '>') { i++; continue; }
+      if (prev === '=' || prev === '!' || prev === '<' || prev === '>') continue;
+      return i;
+    }
+  }
+  return -1;
+}
+
+// Merge a DTS-emitted sig's params into the impl line's params, preserving
+// the impl's default values. The DTS emits `name?: T` for parameters with
+// JS defaults (because callers may omit them — that's the overload view),
+// but inside the body the default ensures `name` is always defined, so the
+// body should see `name: T = default`, not `name?: T`. This merge keeps the
+// caller-facing overload `name?: T` and produces a body-facing impl where
+// each defaulted slot becomes `name: T = default`. Non-defaulted impl
+// params keep whatever the sig provided (`name?: T` for `?:: T` params,
+// `name: T` for required typed params, bare `name` for untyped).
+//
+// Returns the merged param string, or `sigParams` unchanged if the impl
+// has no top-level defaults to preserve.
+function mergeSigWithImplDefaults(sigParams, implParams) {
+  if (!implParams) return sigParams;
+  const sigList = splitTopLevelParams(sigParams);
+  const implList = splitTopLevelParams(implParams);
+  if (sigList.length !== implList.length) return sigParams; // shape mismatch — bail
+  let anyDefault = false;
+  for (const p of implList) { if (findOuterDefault(p) >= 0) { anyDefault = true; break; } }
+  if (!anyDefault) return sigParams;
+  const merged = [];
+  for (let i = 0; i < sigList.length; i++) {
+    const sigPart = sigList[i];
+    const implPart = implList[i];
+    const eqIdx = findOuterDefault(implPart);
+    if (eqIdx < 0) {
+      // No top-level default in impl — use the sig form unchanged.
+      merged.push(sigPart);
+      continue;
+    }
+    const defaultExpr = implPart.slice(eqIdx + 1).trim();
+    // Drop `?` from the sig param's name binding and append `= default`.
+    // Pattern: NAME, NAME?: T, NAME: T, ...REST: T[], {a, b}: {...}, [x, y]: [...]
+    const colonMatch = sigPart.match(/^(\s*(?:\.\.\.|))([A-Za-z_$][\w$]*|\{[\s\S]*?\}|\[[\s\S]*?\])(\?)?(\s*:\s*[\s\S]+)?$/);
+    if (!colonMatch) {
+      // Couldn't parse — keep sig form, append default conservatively.
+      merged.push(`${sigPart} = ${defaultExpr}`);
+      continue;
+    }
+    const prefix = colonMatch[1] || '';
+    const name   = colonMatch[2];
+    const tail   = colonMatch[4] || '';
+    merged.push(`${prefix}${name}${tail} = ${defaultExpr}`);
+  }
+  return merged.join(', ');
+}
+
+// Extract the type parameter list (e.g. "<K extends string>") between the
+// function name and the first `(`. Returns "" when none is present.
+function extractTypeParams(sig) {
+  const m = sig.match(/^(?:export\s+)?(?:async\s+)?function\s+\w+\s*(<[^(]*>)\s*\(/);
+  return m ? m[1] : '';
+}
+
+// Inject `typeParams` between the function name and its `(` on an
+// implementation line. No-op when `typeParams` is empty or the line
+// already has type parameters.
+function injectTypeParams(line, typeParams) {
+  if (!typeParams) return line;
+  const m = line.match(/^(\s*(?:export\s+)?(?:async\s+)?function\s+\w+)(\s*)([(<])/);
+  if (!m || m[3] === '<') return line;
+  return m[1] + typeParams + line.slice(m[0].length - 1);
+}
+
 // ── Shared compilation pipeline ────────────────────────────────────
 
 // 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.
-// When opts.strict is true, all non-nocheck files are type-checked.
+// When opts.checkAll 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 });
+  const result = compiler.compile(source, { sourceMap: true, types: 'emit', skipPreamble: true, stubComponents: true, inlineTypes: true });
   let code = result.code || '';
   const dts = result.dts ? result.dts.trimEnd() + '\n' : '';
 
@@ -531,7 +1155,11 @@ 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) || hasSchemas(source) || !!opts.strict);
+  // Must match the CLI predicate in runCheck. Don't add `hasSchemas(source)`:
+  // that probe is a raw-source regex that fires on `schema :input` inside
+  // heredoc string literals (e.g. test files), flooding the LSP with TS2304
+  // false positives. Schema files still get their DTS via the schema pass.
+  const hasOwnTypes = !nocheck && (hasTypeAnnotations(source) || !!opts.checkAll);
   let importsTyped = false;
   if (!hasOwnTypes && !nocheck) {
     const ripImports = [...source.matchAll(/from\s+['"]([^'"]*\.rip)['"]/g)];
@@ -559,6 +1187,134 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   if (hasTypes && dts && code) {
     const dl = dts.split('\n');
     const cl = code.split('\n');
+
+    // Hoist locally-scoped typed declarations into the function body's
+    // hoisted `let` line. dts.js emits `let name: T;` at the DTS header
+    // for any typed assignment, including locals declared inside function
+    // bodies (`def f() ... res:: Response | null = null`). Those land at
+    // module scope where TypeScript treats them as separate bindings —
+    // the function-local `let res;` (emitted untyped by the compiler's
+    // function-top hoist) shadows them, and TS infers `res` purely from
+    // the first assignment. Pulling the type back into the local `let`
+    // makes the typed declaration cover the actual binding the body uses.
+    // Typed-local hoist — pull `let X: T;` declarations out of the DTS
+    // header and merge them into the body's matching function-local
+    // `let X` line.
+    //
+    // The hoist is name-based: it doesn't carry source-scope identity
+    // through the DTS → body merge, so we can only act when the name
+    // is unambiguous on BOTH sides:
+    //
+    //   1. DTS-side: exactly one `let X: T;` candidate. Multiple
+    //      typed declarations of the same name (one per function
+    //      scope, e.g. `def a() … x:: number; def b() … x:: string`)
+    //      are ambiguous — we don't know which body site each one
+    //      came from.
+    //   2. Body-side: exactly one indented `let X` site. Multiple
+    //      same-named locals across functions would all receive the
+    //      same type otherwise, which is wrong even when DTS itself
+    //      is unambiguous.
+    //   3. No module-scope binding for the name. A top-level typed
+    //      declaration (`x:: string = "..."` at module scope) would
+    //      otherwise be hoisted into an unrelated function-local
+    //      `let x;` — different bindings, same name.
+    //
+    // When any check fails, we leave the local untyped and let
+    // TypeScript infer per-binding from the first assignment.
+    const dtsCandidatesByName = new Map(); // name -> [{dtsIdx, typeSuffix}]
+    for (let i = 0; i < dl.length; i++) {
+      const m = dl[i].match(/^let\s+(\w+)\s*:\s*(.+)\s*;\s*$/);
+      if (!m) continue;
+      const name = m[1];
+      const typeBody = m[2];
+      // Disqualify lines that are really initialized declarations
+      // (`let x: T = init;`). Walk the string honoring brackets,
+      // generics, and `=>` so we don't mistake an arrow's `=>` or a
+      // comparison's `>=` for an assignment `=`.
+      let isAssignment = false;
+      {
+        let d = 0, ang = 0;
+        for (let p = 0; p < typeBody.length; p++) {
+          const c = typeBody[p];
+          if (c === '(' || c === '[' || c === '{') d++;
+          else if (c === ')' || c === ']' || c === '}') d--;
+          else if (c === '<') ang++;
+          else if (c === '>') ang = Math.max(0, ang - 1);
+          else if (c === '=' && d === 0 && ang === 0 &&
+                   typeBody[p + 1] !== '>' && typeBody[p - 1] !== '=' &&
+                   typeBody[p - 1] !== '!' && typeBody[p - 1] !== '<' &&
+                   typeBody[p - 1] !== '>') {
+            isAssignment = true;
+            break;
+          }
+        }
+      }
+      if (isAssignment) continue;
+      const typeSuffix = ': ' + typeBody.trim();
+      if (!dtsCandidatesByName.has(name)) dtsCandidatesByName.set(name, []);
+      dtsCandidatesByName.get(name).push({ dtsIdx: i, typeSuffix });
+    }
+
+    const localTypedLetIdxs = new Set();
+    for (const [name, candidates] of dtsCandidatesByName) {
+      const { dtsIdx, typeSuffix } = candidates[0];
+      // DTS-side collision: same name typed in two function scopes.
+      // We can't tell which body site each DTS line came from, so
+      // strip both — the locals fall back to per-binding inference.
+      if (candidates.length !== 1) {
+        for (const c of candidates) localTypedLetIdxs.add(c.dtsIdx);
+        continue;
+      }
+      const localPat = new RegExp(`^\\s+let\\s+(?:[^;=]*?\\b)?${name}\\b(?!\\s*:)([^;=]*?)?;`);
+      // Module-scope binding probe: a non-indented `let`/`const`/`var`/
+      // export of the same name, or a bare `name = ...` at the start
+      // of a line. If any exist, this DTS declaration belongs to that
+      // module-scope binding, not to a function-local — leave the DTS
+      // declaration alone (it IS the typed declaration for that
+      // top-level binding).
+      const moduleScopePat = new RegExp(
+        `^(?:export\\s+(?:default\\s+)?)?(?:const|let|var)\\s+(?:[^;=]*?\\b)?${name}\\b|^${name}\\s*=`,
+      );
+      let hasModuleScope = false;
+      let localLine = -1;
+      let multipleLocals = false;
+      for (let j = 0; j < cl.length; j++) {
+        if (moduleScopePat.test(cl[j])) { hasModuleScope = true; break; }
+        if (!localPat.test(cl[j])) continue;
+        if (localLine >= 0) { multipleLocals = true; break; }
+        localLine = j;
+      }
+      if (hasModuleScope) continue;
+      // Body-side collision: multiple function-local `let X` sites
+      // for one DTS declaration. We don't know which one was the
+      // intended source. Strip the DTS line so it doesn't bleed into
+      // the wrong scope; the locals fall back to per-binding inference.
+      if (multipleLocals) { localTypedLetIdxs.add(dtsIdx); continue; }
+      // No untyped local site found. Before assuming this is a
+      // module-scope decl, check for an *already-typed* function-local
+      // `let X: T` — the compiler emits the type inline on the body's
+      // hoisted `let` for typed locals, which makes `localPat`'s
+      // `(?!\s*:)` look-ahead skip the line. In that case the DTS
+      // header decl is redundant and would otherwise show up as a
+      // bogus "declared but never read" hint at the top of the file.
+      if (localLine < 0) {
+        const typedLocalPat = new RegExp(`^\\s+let\\s+[^;]*\\b${name}\\b\\s*:`);
+        for (let j = 0; j < cl.length; j++) {
+          if (typedLocalPat.test(cl[j])) { localTypedLetIdxs.add(dtsIdx); break; }
+        }
+        continue;
+      }
+      // Single unambiguous match — perform the hoist.
+      cl[localLine] = cl[localLine].replace(
+        new RegExp(`(\\blet\\s[^;]*?\\b${name}\\b)(?!\\s*:)`),
+        `$1${typeSuffix}`,
+      );
+      localTypedLetIdxs.add(dtsIdx);
+    }
+    if (localTypedLetIdxs.size > 0) {
+      for (const i of localTypedLetIdxs) dl[i] = '';
+    }
+
     const fnSigs = [];
     for (let i = 0; i < dl.length; i++) {
       const m = dl[i].match(/^(?:export\s+)?(?:declare\s+)?function\s+(\w+)/);
@@ -568,9 +1324,22 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       const injections = [];
       const moved = new Set();
       for (const fn of fnSigs) {
-        const pat = new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${fn.name}\\s*[(<]`);
+        // Match the impl in either of two shapes:
+        //   1. top-level: `function NAME(`, `function NAME<`,
+        //      `async function NAME(`, `export function NAME(`
+        //   2. bare-name arrow assignment: `NAME = function(`,
+        //      `NAME = async function(`, `NAME = function*(`
+        // Pattern (2) is how Rip emits arrow assignments at module
+        // scope: `name = (...) -> ...` becomes `name = function(...) {…}`.
+        // We deliberately do NOT match `obj.NAME = function(`: the DTS
+        // emits `declare function NAME(...)` only for module-scope,
+        // bare-name arrow assignments. A property-style match would
+        // pick up an unrelated `obj.NAME = ...` line that happens to
+        // share the function name and apply the wrong signature there.
+        const topLevelPat = new RegExp(`^(?:export\\s+)?(?:async\\s+)?function\\s+${fn.name}\\s*[(<]`);
+        const arrowAssignPat = new RegExp(`^\\s*${fn.name}\\s*=\\s*(?:async\\s+)?function\\s*\\*?\\s*\\(`);
         for (let j = 0; j < cl.length; j++) {
-          if (pat.test(cl[j])) {
+          if (topLevelPat.test(cl[j]) || arrowAssignPat.test(cl[j])) {
             injections.push({ codeLine: j, sig: fn.sig });
             moved.add(fn.idx);
             break;
@@ -593,6 +1362,47 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
           return depth === 0 && sig.slice(i).includes(':');
         }
 
+        // Check if any parameter in a DTS signature lacks a type annotation.
+        // Used to suppress overload-sig injection: if a param is untyped, TS
+        // will fire TS7006 on both the injected sig and the impl (same source
+        // position, same code) — let it fire on the impl only.
+        //
+        // Each top-level param part is "typed" iff it contains a top-level `:`
+        // outside of any nested (), [], {}, or <> groups. Destructured-rename
+        // colons inside `{a: aliased}` don't count because they're nested.
+        // Empty param lists are trivially "all typed".
+        function hasUntypedParam(sig) {
+          const params = extractFnParams(sig);
+          if (params === null || params.trim() === '') return false;
+          const parts = splitTopLevelParams(params);
+          for (const part of parts) {
+            if (!part) continue;
+            // Skip TS `this: T` pseudo-param if it appears.
+            if (/^this\s*:/.test(part)) continue;
+            let depth = 0, angle = 0, hasColon = false;
+            for (let i = 0; i < part.length; i++) {
+              const c = part[i];
+              if (c === '"' || c === "'" || c === '`') {
+                // skip string literal
+                const q = c; i++;
+                while (i < part.length && part[i] !== q) {
+                  if (part[i] === '\\') i++;
+                  i++;
+                }
+                continue;
+              }
+              if (c === '(' || c === '[' || c === '{') { depth++; continue; }
+              if (c === ')' || c === ']' || c === '}') { depth--; continue; }
+              if (c === '=' && part[i + 1] === '>') { i++; continue; }
+              if (c === '<' && i > 0 && /[A-Za-z_$0-9>\]]/.test(part[i - 1])) { angle++; continue; }
+              if (c === '>' && angle > 0) { angle--; continue; }
+              if (c === ':' && depth === 0 && angle === 0) { hasColon = true; break; }
+            }
+            if (!hasColon) return true;
+          }
+          return false;
+        }
+
         // Extract the return type from a DTS signature (e.g. ": number" from
         // "function add(a: number, b: number): number;").
         function extractReturnType(sig) {
@@ -621,7 +1431,17 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
           const sig = inj.sig.replace(/^declare /, '');
           const sigParams = extractFnParams(sig);
           if (sigParams !== null) {
-            cl[inj.codeLine] = replaceFnParams(cl[inj.codeLine], sigParams);
+            // Merge in the impl's default values BEFORE replacing — keeps
+            // `name?: T` on the overload (caller view) but writes
+            // `name: T = default` into the impl signature (body view) so
+            // TypeScript sees the body's `opts` as `T`, not `T | undefined`.
+            const implParams = extractFnParams(cl[inj.codeLine]);
+            const merged = mergeSigWithImplDefaults(sigParams, implParams);
+            cl[inj.codeLine] = replaceFnParams(cl[inj.codeLine], merged);
+          }
+          const typeParams = extractTypeParams(sig);
+          if (typeParams) {
+            cl[inj.codeLine] = injectTypeParams(cl[inj.codeLine], typeParams);
           }
           const retType = extractReturnType(sig);
           if (retType) {
@@ -632,10 +1452,13 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
           }
         }
 
-        // Only inject overload signatures for functions with explicit return types.
-        // Functions without a return type annotation let TS infer the return from
-        // the implementation body — injecting an overload would force it to `any`.
-        const overloads = injections.filter(inj => hasExplicitReturn(inj.sig));
+        // Only inject overload signatures for functions with explicit return types
+        // AND fully-typed params. Functions without a return type annotation let
+        // TS infer the return from the implementation body — injecting an overload
+        // would force it to `any`. Functions with any untyped param would fire
+        // TS7006 twice (once on the injected sig, once on the impl) at the same
+        // source position — skip the injection so the user sees a single error.
+        const overloads = injections.filter(inj => hasExplicitReturn(inj.sig) && !hasUntypedParam(inj.sig));
 
         // Adjust reverseMap: each overload injection shifts subsequent code lines down by 1.
         // Compare against the original genLine (not genLine + offset) because bottom-up
@@ -713,7 +1536,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
             const existingFields = new Set();
             for (let k = j + 1; k < cl.length; k++) {
               if (cl[k].match(/^(?:export\s+)?(?:class|const)\s+\w+/) && k > j + 1) break;
-              const fm = cl[k].match(/^\s+(?:declare\s+)?(\w+):\s+.+;$/);
+              const fm = cl[k].match(/^\s+(?:declare\s+)?(\w+):\s+.+;(?:\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+/);
@@ -887,7 +1710,16 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
 
     for (let i = 0; i < dl.length; i++) {
       const m = dl[i].match(/^(?:export\s+)?declare\s+const\s+(\w+):\s+(.+);$/);
-      if (m) constTypes.set(m[1], { type: m[2], idx: i });
+      if (m) { constTypes.set(m[1], { type: m[2], idx: i }); continue; }
+      // Also merge `(export )?let X: T;` forward-decls from the DTS header
+      // into matching body `(export )?const X = expr` declarations. dts.js
+      // emits the `let` form for typed module-scope value bindings declared
+      // via `name:: T = expr`. Without this merge, TS sees two separate
+      // declarations (header `let` + body `const`) and loses the typed
+      // identity on property access — e.g. `getStore()` returns `unknown`
+      // instead of the declared `AsyncLocalStorage<T>`'s element type.
+      const lm = dl[i].match(/^(?:export\s+)?let\s+(\w+):\s+(.+);$/);
+      if (lm) constTypes.set(lm[1], { type: lm[2], idx: i });
     }
 
     if (constTypes.size > 0) {
@@ -914,9 +1746,10 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   // but files that import from typed modules may have untyped reactive vars whose
   // compiled code still references __state/__computed/__effect.
   if (hasTypes) {
-    const needSignal = /\b__state\(/.test(code) && !/\bdeclare function __state\b/.test(headerDts);
-    const needComputed = /\b__computed\(/.test(code) && !/\bdeclare function __computed\b/.test(headerDts);
-    const needEffect = /\b__effect\(/.test(code) && !/\bdeclare function __effect\b/.test(headerDts);
+    const bound = ripDestructuredNames(source);
+    const needSignal = /\b__state\(/.test(code) && !/\bdeclare function __state\b/.test(headerDts) && !bound.has('__state');
+    const needComputed = /\b__computed\(/.test(code) && !/\bdeclare function __computed\b/.test(headerDts) && !bound.has('__computed');
+    const needEffect = /\b__effect\(/.test(code) && !/\bdeclare function __effect\b/.test(headerDts) && !bound.has('__effect');
     if (needSignal || needComputed || needEffect) {
       const decls = [];
       if (needSignal) {
@@ -941,24 +1774,14 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
   // automatically. Precise type overrides are provided where the generic
   // fallback (...args: any[]) => any would lose useful type information.
   if (hasTypes) {
-    const preciseTypes = {
-      abort:  'declare function abort(msg?: string): never;',
-      assert: 'declare function assert(v: any, msg?: string): asserts v;',
-      exit:   'declare function exit(code?: number): never;',
-      kind:   'declare function kind(v: any): string;',
-      noop:   'declare function noop(): void;',
-      p:      'declare function p(...args: any[]): void;',
-      pp:     'declare function pp(v: any): any;',
-      raise:  'declare function raise(a: any, b?: any): never;',
-      rand:   'declare function rand(a?: number, b?: number): number;',
-      sleep:  'declare function sleep(ms: number): Promise<void>;',
-      todo:   'declare function todo(msg?: string): never;',
-      warn:   'declare function warn(...args: any[]): void;',
-      zip:    'declare function zip(...arrays: any[][]): any[][];',
-    };
+    // Helper names auto-derived from getStdlibCode() so adding a stdlib
+    // helper in stdlib.js automatically picks up a type declaration here.
+    // The precise signatures live alongside the runtime bodies in
+    // stdlib.js as STDLIB_TYPE_DECLS; helpers without an entry fall back
+    // to a generic `(...args: any[]) => any` declaration.
     const names = [...getStdlibCode().matchAll(/globalThis\.(\w+)\s*\?\?=/g)].map(m => m[1]);
     const stdlibDecls = names.map(name =>
-      preciseTypes[name] || `declare function ${name}(...args: any[]): any;`
+      STDLIB_TYPE_DECLS[name] || `declare function ${name}(...args: any[]): any;`
     );
     headerDts = stdlibDecls.join('\n') + '\n' + headerDts;
 
@@ -1006,16 +1829,37 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     const cl = code.split('\n');
     const reEsc = s => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
-    // Build DTS header type map for merging
+    // Build DTS header type map for merging. The map is name-based,
+    // and the inline-let pass below uses it to inject types into
+    // function-top hoist `let X;` declarations.
+    //
+    // DTS-side collision: when the same name appears in multiple
+    // `let X: T;` lines with different types (one per independent
+    // function scope), `letTypes.set` would otherwise let the last
+    // one win and silently apply the wrong type. Detect the conflict
+    // and remove the name from the map so the inline-let pass leaves
+    // those locals untyped (TS infers per-binding from the first
+    // assignment, which is the correct fallback). The typed-local
+    // hoist above also handles body-side ambiguity for the cases
+    // where the inline-let pass doesn't fire.
     const letTypes = new Map();
+    const ambiguousLetNames = new Set();
     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 });
+        if (!m) continue;
+        const [, name, type] = m;
+        const prev = letTypes.get(name);
+        if (prev) {
+          if (prev.type !== type) ambiguousLetNames.add(name);
+          continue;
+        }
+        letTypes.set(name, { type, idx: i });
       }
+      for (const name of ambiguousLetNames) letTypes.delete(name);
     }
 
     // Helper: inline a variable at the given line
@@ -1032,22 +1876,37 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     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;
-      // Only process hoist-position lets (first non-blank line after `{` or start of file)
+      // Only process hoist-position lets (first non-blank line after `{`, start
+      // of file, or the module's import block — the compiler emits the
+      // module-scope hoist right after the imports).
       let prev = null;
       for (let k = i - 1; k >= 0; k--) { if (cl[k].trim() !== '') { prev = cl[k]; break; } }
-      if (prev !== null && !/\{\s*$/.test(prev)) continue;
+      if (prev !== null && !/\{\s*$/.test(prev) && !/^\s*import\b/.test(prev)) continue;
 
       const baseIndent = m[1];
       const vars = m[2].split(/\s*,\s*/);
       const inlined = new Set();
       const bailed = new Set();
-      const scopeEndRe = new RegExp('^' + reEsc(baseIndent) + '}');
+      // Scope-end detection by indent: the enclosing block ends at the first
+      // non-empty line whose indent is strictly less than baseIndent. This is
+      // correct for compiler-generated JS where indentation reliably reflects
+      // nesting. Regex-matching `}` at baseIndent was wrong because inner
+      // block-closing braces (e.g. `  }` ending a nested `if`) sit at exactly
+      // baseIndent and would terminate the scan prematurely. For top-level
+      // hoists (baseIndent === ''), the scope is the whole file — never end.
+      const baseIndentLen = baseIndent.length;
+      const isScopeEnd = (line) => {
+        if (baseIndentLen === 0) return false;
+        if (line.trim() === '') return false;
+        const li = line.match(/^(\s*)/)[1].length;
+        return li < baseIndentLen;
+      };
 
       // 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;
-        if (scopeEndRe.test(line)) break;
+        if (isScopeEnd(line)) break;
         // Skip deeper-indented lines
         if (line.startsWith(baseIndent + '  ')) continue;
         // Stop at structural statements (if/for/while/switch/try/do/function/class)
@@ -1079,7 +1938,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
         for (let j = i + 1; j < cl.length; j++) {
           const line = cl[j];
           if (line.trim() === '') continue;
-          if (scopeEndRe.test(line)) break;
+          if (isScopeEnd(line)) break;
           if (!vRe.test(line)) continue;
           if (firstRefLine < 0) firstRefLine = j;
           if (!foundAssign) {
@@ -1100,7 +1959,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
         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; }
+          if (isScopeEnd(line)) { blockEndLine = j; break; }
           const li = line.match(/^(\s*)/)[1];
           if (li.length < foundAssign.indent.length) { blockEndLine = j; break; }
         }
@@ -1111,7 +1970,7 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
           for (let j = blockEndLine + 1; j < cl.length; j++) {
             const line = cl[j];
             if (line.trim() === '') continue;
-            if (scopeEndRe.test(line)) break;
+            if (isScopeEnd(line)) break;
             if (vRe.test(line)) { hasRefAfterBlock = true; break; }
           }
         }
@@ -1123,8 +1982,23 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
       }
 
       const remaining = vars.filter(v => !inlined.has(v));
-      if (remaining.length) cl[i] = `${baseIndent}let ${remaining.join(', ')};`;
-      else cl[i] = '';
+      // Module-scope only: drop any var that still has a DTS-header decl
+      // (`let name: T;`) from this untyped hoist. These are chiefly module-level
+      // function bindings, whose assignment spans multiple lines
+      // (`proxy = function(c) {` … `};`) and so never folds into a single
+      // `let name: T = value;` line. The header decl is the single,
+      // correctly-typed declaration and the body's later `name = …` assigns it;
+      // leaving name in this hoist too would duplicate the module-scope binding,
+      // and TS resolves to the untyped copy — dropping contextual typing for the
+      // function's params and `this` (the redeclare is auto-suppressed, so the
+      // symptom surfaces elsewhere). We deliberately keep the type on the header
+      // decl rather than re-emitting it onto this synthetic hoist line: the
+      // compiler source-maps the header's type name back to the real `name:: T`
+      // annotation, so diagnostics/quick-fixes land on it — re-emitting here
+      // would map them to the hoist's position instead. Function-body hoists are
+      // left alone: their locals get types from the compiler's inline hoist.
+      const kept = baseIndent === '' ? remaining.filter(v => !letTypes.has(v)) : remaining;
+      cl[i] = kept.length ? `${baseIndent}let ${kept.join(', ')};` : '';
     }
     code = cl.join('\n');
 
@@ -1134,6 +2008,190 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     }
   }
 
+  // Typed stash: the project's `<root>/app/stash.rip` declares
+  // `stash:: <Type> = ...`. We expose its inferred type as `__RipStash`
+  // on the stash file's virtual module, then rewrite the per-component
+  // `declare app: any` stub to point at it. Components get `app.data`
+  // typed without writing anything ceremonial — just put the stash in
+  // `app/stash.rip`.
+  //
+  // Two splices, both same-line so source maps are unaffected:
+  //   1. Stash file — append `export type __RipStash = typeof stash;`
+  //   2. Component files — replace `declare app: any` with the typed shape
+  const stashFile = findStashFile(filePath);
+  const isStash = stashFile && stashFile === filePath;
+
+  if (isStash) {
+    // The DTS header hoists `export let stash: <Type>;` so the type is
+    // visible everywhere. The body emits either `let stash; ... stash = {...}`
+    // (no export) or `export const stash = {...}` (with export). Both
+    // conflict with the typed hoist — TS sees a redeclaration and the
+    // un-annotated body wins, collapsing the inferred type to `{ items:
+    // never[], ... }`. Rewrite both forms into a bare assignment to the
+    // already-declared `stash`, preserving the contextual type.
+    const letRe = /^(\s*let\s+)([^;=]+);/m;
+    code = code.replace(letRe, (full, prefix, names) => {
+      const remaining = names.split(',').map(s => s.trim()).filter(n => n !== 'stash');
+      return remaining.length ? `${prefix}${remaining.join(', ')};` : '';
+    });
+    code = code.replace(/^(\s*)export\s+const\s+stash\s*=/m, '$1stash =');
+    code += `\nexport type __RipStash = typeof stash;\n`;
+  }
+
+  if (code.includes('declare app: any')) {
+    let typedApp = null;
+    if (stashFile && !isStash) {
+      const spec = entryImportSpec(filePath, stashFile);
+      typedApp = `declare app: { data: import('${spec}').__RipStash; components: any; routes: any; params: any; query: any; router: any }`;
+    }
+    if (typedApp) code = code.replace(/declare app: any/g, typedApp);
+  }
+
+  // `declare router: any` in the component stub is rewritten to the Router
+  // type exported by @rip-lang/app. Always available — the package ships its
+  // own DTS. Gated on a typed project (same `findEntryFile` check the stash
+  // splice uses) to avoid touching untyped sources.
+  if (code.includes('declare router: any') && findEntryFile(filePath)) {
+    code = code.replace(
+      /declare router: any/g,
+      `declare router: import('@rip-lang/app').Router`,
+    );
+  }
+
+  // ── Typed routes ─────────────────────────────────────────────────
+  //
+  // Three splices, all keyed off the project's `<routesDir>/` tree:
+  //   1. Entry file — append `export type __RipRoutes = ...;` so every
+  //      file in the project can reach it via
+  //      `import('<entry>').__RipRoutes`.
+  //   2. Per-route file (anything under <routesDir>/) — tighten the
+  //      `params: any` slot in the typed `declare app:` line so
+  //      `routes/users/[id].rip` sees `params: { id: string }`.
+  //   3. Any typed file that uses `<a>` elements — override the
+  //      INTRINSIC `__ripEl` declaration so anchor `href` is typed via
+  //      a `const H extends string` conditional: if H is a literal
+  //      starting with `/`, it must satisfy `__RipRoutes`; otherwise
+  //      (external URLs `https:`/`mailto:`, fragments `#x`, dynamic
+  //      `string`) it falls through to plain H. Also narrow
+  //      `router.push` to `__RipRoutes` for typo-catching.
+  const entryFile = findEntryFile(filePath);
+  const routesDir = findRoutesDir(filePath);
+  const isEntry   = entryFile && entryFile === filePath;
+  const isRoute   = routesDir && filePath.startsWith(routesDir + pathSep);
+
+  if (isEntry && routesDir) {
+    const { union } = walkRoutesDir(routesDir);
+    code += `\nexport type __RipRoutes = ${union};\n`;
+  }
+
+  // Per-route @params tightening: the component stub declares
+  // `declare params: Record<string, string>`. For route files whose
+  // filename carries dynamic segments (`[id].rip`, `[...rest].rip`),
+  // replace that with a precise shape so typos like `@params.bogu`
+  // are caught and `@params.id` narrows to `string` (the literal).
+  if (isRoute && entryFile) {
+    const { entries } = walkRoutesDir(routesDir);
+    const me = entries.find(e => e.file === filePath);
+    if (me && me.dynamic.length > 0) {
+      const paramFields = me.dynamic
+        .map(d => `${d.name}: string`)
+        .join('; ');
+      code = code.replace(
+        /declare params: Record<string, string>/g,
+        `declare params: { ${paramFields} }`,
+      );
+    }
+  }
+
+  // Anchor href + typed router.push/replace overrides. Spliced into the
+  // DTS header (where `__RipProps` is defined) and the `declare router`
+  // line (already rewritten above). Gated on the project having a
+  // routes dir at all — without routes there's no `__RipRoutes` to
+  // intersect with, so the default `string` href is what users get.
+  if (routesDir && entryFile && findStashFile(filePath)) {
+    // Reach __RipRoutes via the entry file's virtual module.
+    const entrySpec = entryImportSpec(filePath, entryFile);
+    const anchorRouteType = `import('${entrySpec}').__RipRoutes`;
+    // Inline the routes union for diagnostics on __ripRoute (dynamic
+    // interpolated hrefs). The static __ripEl path resolves the alias
+    // already; for the helper-call path we inline so error messages
+    // read "Argument of type '`/x/${number}`' is not assignable to
+    // parameter of type '<actual route union>'" instead of '__RipRoutes'.
+    const { union: inlineRoutesUnion } = walkRoutesDir(routesDir);
+
+    // Declare a clean local alias for NavOpts so hover shows `NavOpts`
+    // instead of `import("@rip-lang/app").NavOpts`. We *don't* alias
+    // __RipRoutes — inlining the union directly into the push signature
+    // makes hover and errors both show the actual list of routes,
+    // avoiding the leak of an implementation-detail name.
+    if (headerDts) {
+      headerDts = `type NavOpts = import('@rip-lang/app').NavOpts;\n` + headerDts;
+    }
+
+    // (a) Constrain <a href>: replace the INTRINSIC __ripEl declaration
+    // with a const-H-generic version whose href slot conditionally
+    // narrows to __RipRoutes for slash-prefixed literals. External
+    // URLs (https:, mailto:, #frag) and dynamic `string` values fall
+    // through to H. Error reads:
+    //   Type '"/foo"' is not assignable to type '__RipRoutes | undefined'.
+    if (headerDts) {
+      const newFnDecl = `declare function __ripEl<K extends __RipTag, const H extends string = string>(tag: K, props?: __RipProps<K> & (K extends 'a' ? { href?: H extends \`/\${string}\` ? ${inlineRoutesUnion} : H } : {})): void;`;
+      headerDts = headerDts.replace(
+        /declare function __ripEl<K extends __RipTag>\(tag: K, props\?: __RipProps<K>\): void;/,
+        newFnDecl,
+      );
+      // Strengthen __ripRoute: compiler wraps interpolated /-prefixed
+      // anchor href values in __ripRoute(...) so TS checks the dynamic
+      // template against __RipRoutes. Without this strengthening the
+      // baseline passthrough lets every string through.
+      headerDts = headerDts.replace(
+        /declare function __ripRoute<const T extends string>\(s: T\): T;/,
+        `declare function __ripRoute<const T extends ${inlineRoutesUnion}>(s: T): T;`,
+      );
+    }
+
+    // (b) Narrow router.push argument to __RipRoutes for typo-catching
+    // on programmatic navigation. Leave `router.replace` accepting plain
+    // `string` (the base Router signature) — it's commonly used to
+    // mutate the current URL with query strings, where the result is
+    // built dynamically and can't satisfy a literal-route union. Use
+    // Omit + re-add instead of intersection because intersecting
+    // overloaded methods makes the parameter type a union
+    // (contravariance), which loses the narrowing.
+    if (code.includes(`declare router: import('@rip-lang/app').Router`)) {
+      const typedRouter = `declare router: Omit<import('@rip-lang/app').Router, 'push'> & { push(url: ${inlineRoutesUnion}, opts?: NavOpts): void; }`;
+      code = code.replace(
+        /declare router: import\('@rip-lang\/app'\)\.Router(?![ &])/g,
+        typedRouter,
+      );
+    }
+  }
+
+  // Dedupe imports: when the DTS header and the body import from the same
+  // module specifier, TypeScript reports TS2300 (Duplicate identifier) for
+  // every shared binding, which cascades and corrupts type resolution
+  // elsewhere (e.g. `typeof <stateIdent>` collapses to `any`).
+  //
+  // We prefer to drop the *DTS-header* duplicate and keep the body's import:
+  // the body import carries per-specifier source-map mappings (needed for
+  // hover and go-to-definition on each imported name), while the DTS header
+  // import has none. Dropping the body import would leave the source-map
+  // entries pointing at a blanked line, breaking hover for type-only
+  // imports like `import { RetryConfig } from '@rip-lang/http'`.
+  //
+  // Preserve line count on both sides so source maps stay aligned.
+  if (hasTypes && headerDts && code) {
+    const bodySpecs = new Set();
+    for (const m of code.matchAll(/^\s*import\s+[^;]*?from\s+['"]([^'"]+)['"]\s*;?\s*$/gm)) {
+      bodySpecs.add(m[1]);
+    }
+    if (bodySpecs.size > 0) {
+      headerDts = headerDts.replace(/^(\s*)import\s+[^;]*?from\s+(['"])([^'"]+)\2\s*;?\s*$/gm, (full, _ws, _q, spec) => {
+        return bodySpecs.has(spec) ? '' : full;
+      });
+    }
+  }
+
   let tsContent = (hasTypes ? headerDts + '\n' : '') + code;
   const headerLines = hasTypes ? countLines(headerDts + '\n') : 1;
 
@@ -1215,10 +2273,16 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     const genGap = genB - genA;
     if (srcGap > 1 && genGap > 1 && srcGap <= genGap + 2) {
       for (let d = 1; d < srcGap; d++) {
-        if (!srcToGen.has(srcA + d) && genA + d < genB) {
-          srcToGen.set(srcA + d, genA + d);
-          if (!genToSrc.has(genA + d)) {
-            genToSrc.set(genA + d, srcA + d);
+        const gen = genA + d;
+        if (!srcToGen.has(srcA + d) && gen < genB) {
+          // Don't interpolate INTO the DTS header. Header lines must only
+          // carry explicit DTS-back-mappings (or none); fabricating a mapping
+          // here causes go-to-def to land on whatever source line happens to
+          // fall in the gap (typically a doc comment).
+          if (gen < headerLines) continue;
+          srcToGen.set(srcA + d, gen);
+          if (!genToSrc.has(gen)) {
+            genToSrc.set(gen, srcA + d);
           }
         }
       }
@@ -1373,13 +2437,27 @@ export function findNearestWord(text, word, approx) {
 
 // Check whether an offset falls on an injected function overload signature line
 // (generated by compileForCheck, not from user code).  These are body lines that
-// match `function NAME(...): TYPE;` and have no genToSrc entry.
+// match `[export ][async ]function NAME(...): TYPE;` and are immediately followed
+// by the matching implementation `[export ][async ]function NAME(...) ... {`.
+//
+// Note: we can't rely on `!genToSrc.has(line)` as a discriminator — the gap-fill
+// interpolation in buildLineMap will fabricate a mapping for the injected line.
 export function isInjectedOverload(entry, offset) {
   const tsLine = offsetToLine(entry.tsContent, offset);
   if (tsLine < entry.headerLines) return false;
-  if (entry.genToSrc.get(tsLine) !== undefined) return false;
   const lineText = getLineText(entry.tsContent, tsLine);
-  return /^(?:async\s+)?function\s+\w+\s*\(/.test(lineText) && lineText.trimEnd().endsWith(';');
+  const m = lineText.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/);
+  if (!m) return false;
+  if (!lineText.trimEnd().endsWith(';')) return false;
+  // Confirm the next non-empty line is the implementation of the same function.
+  const allLines = entry.tsContent.split('\n');
+  for (let i = tsLine + 1; i < allLines.length; i++) {
+    const next = allLines[i];
+    if (next.trim() === '') continue;
+    const nm = next.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/);
+    return !!nm && nm[1] === m[1] && !next.trimEnd().endsWith(';');
+  }
+  return false;
 }
 
 export function offsetToLine(text, offset) {
@@ -1399,6 +2477,54 @@ export function lineColToOffset(text, line, col) {
   return text.length;
 }
 
+// Detect whether `col` on a single generated line falls inside a string
+// literal or a `//` line comment.  Used to penalize identifier matches
+// that land inside non-code regions during source-map lookup.
+function isInsideStringOrComment(text, col) {
+  let inStr = false, q = '';
+  for (let i = 0; i < col && i < text.length; i++) {
+    const ch = text[i];
+    if (inStr) {
+      if (ch === '\\') { i++; continue; }
+      if (ch === '`' && q === '`') { inStr = false; continue; }
+      if (ch === q) inStr = false;
+    } else if (ch === '/' && text[i + 1] === '/') {
+      return true; // rest of line is a comment
+    } else if (ch === '"' || ch === "'" || ch === '`') {
+      inStr = true; q = ch;
+    }
+  }
+  return inStr;
+}
+
+// Detect whether `col` on a Rip source line falls inside a `#` comment.
+// Walks the line tracking string state (', ", """, ''') so a `#` inside a
+// string literal isn't mistaken for the start of a comment. Used by the
+// diagnostic remapper to reject false-positive identifier matches inside
+// comments.
+function isInsideRipComment(text, col) {
+  let inStr = false, q = '', triple = false;
+  for (let i = 0; i < col && i < text.length; i++) {
+    const ch = text[i];
+    if (inStr) {
+      if (ch === '\\') { i++; continue; }
+      if (triple && ch === q && text[i + 1] === q && text[i + 2] === q) {
+        inStr = false; triple = false; i += 2; continue;
+      }
+      if (!triple && ch === q) inStr = false;
+    } else if (ch === '#') {
+      return true;
+    } else if (ch === '"' || ch === "'") {
+      if (text[i + 1] === ch && text[i + 2] === ch) {
+        inStr = true; q = ch; triple = true; i += 2;
+      } else {
+        inStr = true; q = ch;
+      }
+    }
+  }
+  return false;
+}
+
 export function offsetToLineCol(text, offset) {
   let line = 0, ls = 0;
   for (let i = 0; i < offset && i < text.length; i++) {
@@ -1597,6 +2723,39 @@ export function mapToSourcePos(entry, offset) {
     }
   }
   const srcText = entry.source ? getLineText(entry.source, srcLine) : '';
+  // Synthetic anchor: `__ripRoute(...)` wraps an anchor href value for
+  // dynamic route type-checking. The TS diagnostic span starts at the
+  // call argument (a template literal), which has no clean source token
+  // to land on — landing instead on the source `href:` keyword keeps
+  // dynamic anchor diagnostics visually consistent with the static
+  // `__ripEl` `href` case (TS2820 lands on the property identifier).
+  // Map both the start and end offsets that fall anywhere inside a
+  // `__ripRoute(...)` call to the bounds of the `href` keyword so the
+  // squiggle length matches the static case (4 chars) instead of
+  // spanning the whole compiled call expression.
+  if (srcText) {
+    const callStart = genText.lastIndexOf('__ripRoute(', genCol);
+    if (callStart >= 0) {
+      // Find matching `)` after the call
+      let depth = 0, callEnd = -1;
+      for (let i = callStart + '__ripRoute('.length - 1; i < genText.length; i++) {
+        const ch = genText[i];
+        if (ch === '(') depth++;
+        else if (ch === ')') { depth--; if (depth === 0) { callEnd = i; break; } }
+      }
+      if (callEnd >= 0 && genCol <= callEnd + 1) {
+        const m = srcText.match(/\bhref\b/);
+        if (m) {
+          // Heuristic for end offset: anchor at end of `href` (start + 4)
+          // when the gen offset is inside the call body (past the opening
+          // paren). For the start offset (at the opening paren or first
+          // arg char), anchor at the start of `href`.
+          const atOrBeforeArg = genCol <= callStart + '__ripRoute('.length;
+          return { line: srcLine, col: atOrBeforeArg ? m.index : m.index + 4 };
+        }
+      }
+    }
+  }
   // Text-match: find the word at genCol in the gen line, then locate it in the source line
   if (srcText) {
     let wordAt = genText.slice(genCol).match(/^\w+/);
@@ -1606,6 +2765,18 @@ export function mapToSourcePos(entry, offset) {
     }
     if (wordAt) {
       let word = wordAt[0];
+      // Compiler-injected `this.foo` / `ctx.foo` (component bodies, server
+      // handlers): the diagnostic offset typically lands on `this`/`ctx`,
+      // which doesn't exist in the Rip source. Peek past it and use the
+      // member name instead so the squiggle anchors on the user-visible
+      // identifier rather than falling through to a fuzzy fallback.
+      if (word === 'this' || word === 'ctx') {
+        const memberMatch = genText.slice(genCol).match(/^(?:this|ctx)\.([A-Za-z_$][\w$]*)\b/);
+        if (memberMatch) {
+          const idx = findNearestWord(srcText, memberMatch[1], approx);
+          if (idx >= 0) return { line: srcLine, col: idx };
+        }
+      }
       let idx = findNearestWord(srcText, word, approx);
       // __bind_xxx__ → xxx: two-way binding props use mangled names in gen
       if (idx < 0 && word.startsWith('__bind_') && word.endsWith('__')) {
@@ -1652,13 +2823,28 @@ export function mapToSourcePos(entry, offset) {
     if (wordFallback) {
       let word = wordFallback[0];
       if (word.startsWith('__bind_') && word.endsWith('__')) word = word.slice(7, -2);
-      const srcLines = entry.source.split('\n');
-      const re = new RegExp('\\b' + word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
-      for (let delta = 0; delta <= 10; delta++) {
-        for (const d of delta === 0 ? [srcLine] : [srcLine + delta, srcLine - delta]) {
-          if (d >= 0 && d < srcLines.length) {
-            const m = re.exec(srcLines[d]);
-            if (m) return { line: d, col: m.index };
+      // Skip identifiers that exist only in generated TypeScript, never in
+      // the Rip source: `this` (component bodies), `ctx` (server handlers),
+      // and any `__`-prefixed runtime helper (`__state`, `__effect`,
+      // `__ripEl`, ...). Searching for them across source lines reliably
+      // finds false positives — most commonly the word `this` inside a `#`
+      // comment. `value` is intentionally NOT skipped (it's a valid user
+      // identifier; the `.value` signal-accessor case is handled by the
+      // member-extraction fix in the primary word-match path above).
+      // `__bind_xxx__` was already stripped to its user name above.
+      if (word !== 'this' && word !== 'ctx' && !word.startsWith('__')) {
+        const srcLines = entry.source.split('\n');
+        const re = new RegExp('\\b' + word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b');
+        for (let delta = 0; delta <= 10; delta++) {
+          for (const d of delta === 0 ? [srcLine] : [srcLine + delta, srcLine - delta]) {
+            if (d >= 0 && d < srcLines.length) {
+              const m = re.exec(srcLines[d]);
+              // Reject matches that fall inside a Rip `#` comment — they're
+              // never the source of a type error.
+              if (m && !isInsideRipComment(srcLines[d], m.index)) {
+                return { line: d, col: m.index };
+              }
+            }
           }
         }
       }
@@ -1678,6 +2864,90 @@ export function mapToSourcePos(entry, offset) {
   return { line: srcLine, col: srcCol };
 }
 
+// Count top-level commas in `s` (depth 0 w.r.t. ()/[]/{}). Used to map a
+// cursor onto the Nth argument / Nth property when retargeting completion
+// offsets into object-literal call arguments.
+function countTopLevelCommas(s) {
+  let depth = 0, n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '(' || ch === '[' || ch === '{') depth++;
+    else if (ch === ')' || ch === ']' || ch === '}') depth--;
+    else if (ch === ',' && depth === 0) n++;
+  }
+  return n;
+}
+
+// Completion-offset fixup for inline object-literal call arguments, e.g.
+// `@router.push('/', { ▮ })`. At a non-identifier cursor (empty slot, after
+// a comma) the word-anchored `srcToOffset` has nothing to grab and lands on
+// the call name, so TS returns the receiver's *members* (push, replace, …)
+// instead of the object's contextually-typed *properties* (noScroll, …).
+//
+// Given the gen offset `srcToOffset` produced (which sits at/near the call
+// name on the gen line), this walks the gen call to the same argument index
+// and property slot the source cursor occupies and returns the corrected
+// absolute offset. Returns the original offset unchanged when the cursor
+// isn't in this situation, so callers can apply it unconditionally.
+export function retargetObjectArgOffset(entry, srcLine, srcCol, genOffset) {
+  if (!entry || genOffset == null || !srcLine) return genOffset;
+  const before = srcLine.slice(0, srcCol);
+  // On an identifier? Word-anchoring already mapped it precisely — leave it.
+  if (/\w$/.test(before) || /^\w/.test(srcLine.slice(srcCol))) return genOffset;
+
+  // Walk back to the enclosing object-literal `{`, tracking bracket depth.
+  let depth = 0, objOpen = -1;
+  for (let i = srcCol - 1; i >= 0; i--) {
+    const ch = before[i];
+    if (ch === '}' || ch === ')' || ch === ']') depth++;
+    else if (ch === '{') { if (depth === 0) { objOpen = i; break; } depth--; }
+    else if (ch === '(' || ch === '[') { if (depth === 0) return genOffset; depth--; }
+  }
+  if (objOpen < 0) return genOffset;
+  // The object must be a call argument: a `name(` must precede it with only
+  // argument text (no nested braces) between the `(` and this `{`.
+  const head = before.slice(0, objOpen);
+  const callM = head.match(/\.\s*\w+\s*\(([^(){}]*)$/);
+  if (!callM) return genOffset;
+  const argIndex = countTopLevelCommas(callM[1]);                 // object is this call-arg
+  const propSlot = countTopLevelCommas(before.slice(objOpen + 1)); // commas before cursor in object
+
+  // Gen side: locate the call paren near the mapped offset, then walk to the
+  // same argument and the same property slot inside its object literal.
+  const tsText = entry.tsContent;
+  const lc = offsetToLineCol(tsText, genOffset);
+  const genLine = tsText.split('\n')[lc.line];
+  if (genLine == null) return genOffset;
+  const callRe = /\.\s*\w+\s*\(/g;
+  callRe.lastIndex = Math.max(0, lc.col - 4);
+  const gm = callRe.exec(genLine);
+  if (!gm) return genOffset;
+  let i = gm.index + gm[0].length;  // just inside the call's `(`
+  let d = 1, args = 0;
+  // Advance to the start of argument `argIndex`.
+  while (i < genLine.length && args < argIndex) {
+    const ch = genLine[i];
+    if (ch === '(' || ch === '[' || ch === '{') d++;
+    else if (ch === ')' || ch === ']' || ch === '}') { d--; if (d === 0) return genOffset; }
+    else if (ch === ',' && d === 1) args++;
+    i++;
+  }
+  while (i < genLine.length && /\s/.test(genLine[i])) i++;
+  if (genLine[i] !== '{') return genOffset;                       // arg isn't an object literal
+  i++;                                                            // step inside the object
+  // Skip `propSlot` top-level properties within the object.
+  let pd = 1, props = 0;
+  while (i < genLine.length && props < propSlot) {
+    const ch = genLine[i];
+    if (ch === '(' || ch === '[' || ch === '{') pd++;
+    else if (ch === ')' || ch === ']' || ch === '}') { pd--; if (pd === 0) break; }
+    else if (ch === ',' && pd === 1) props++;
+    i++;
+  }
+  while (i < genLine.length && /\s/.test(genLine[i])) i++;
+  return genOffset - lc.col + i;
+}
+
 // Map a Rip source (line, col) to a TypeScript virtual file byte offset.
 // This is the forward direction: source → generated (used for hover, definition, etc.)
 //
@@ -1693,18 +2963,40 @@ export function srcToOffset(entry, line, col) {
   if (entry.srcColToGen) {
     const colEntries = entry.srcColToGen.get(line);
     if (colEntries && colEntries.length > 0) {
-      let best = colEntries[0];
-      for (const e of colEntries) {
+      // Exact-column match wins regardless of genLine.  Sub-mapping anchors
+      // for identifiers in arrow bodies, spreads, etc. legitimately land on
+      // a different genLine than the statement's primary anchor; preferring
+      // them when they line up exactly with the queried column avoids the
+      // line-anchor filter (below) from discarding a precise mapping.
+      const exact = colEntries.find(e => e.srcCol === col);
+      if (exact) {
+        genLine = exact.genLine;
+        genColHint = exact.genCol;
+        bestSrcCol = exact.srcCol;
+      } else {
+      // When srcToGen anchors this source line to a specific genLine, only
+      // consider colEntries on that same genLine.  Stray entries on other
+      // genLines (caused by upstream sub-mapping contamination across
+      // adjacent statements) can otherwise yank the lookup into an unrelated
+      // gen-line context.
+      const anchoredGen = entry.srcToGen.get(line);
+      const filtered = anchoredGen != null
+        ? colEntries.filter(e => e.genLine === anchoredGen)
+        : colEntries;
+      const pool = filtered.length > 0 ? filtered : colEntries;
+      let best = pool[0];
+      for (const e of pool) {
         if (e.srcCol <= col && (best.srcCol > col || e.srcCol > best.srcCol)) best = e;
       }
       if (best.srcCol > col) {
-        for (const e of colEntries) {
+        for (const e of pool) {
           if (Math.abs(e.srcCol - col) < Math.abs(best.srcCol - col)) best = e;
         }
       }
       genLine = best.genLine;
       genColHint = best.genCol;
       bestSrcCol = best.srcCol;
+      }
     }
   }
 
@@ -1755,18 +3047,35 @@ export function srcToOffset(entry, line, col) {
       // closer to the raw source column.
       const expectedGenCol = useHint ? genColHint
         : genColHint >= 0 ? genColHint + (col - bestSrcCol) : col;
+      // Penalize matches that fall inside string literals or line comments
+      // so an identifier appearing both as a value reference and as quoted
+      // text (e.g. `console.log "clicks:", clicks`) doesn't resolve into
+      // the string portion — TS returns no hover for offsets inside strings.
+      const STRING_PENALTY = 1e6;
       while ((m = re.exec(targetText)) !== null) {
-        const dist = Math.abs(m.index - expectedGenCol);
+        const inStr = isInsideStringOrComment(targetText, m.index);
+        const dist = Math.abs(m.index - expectedGenCol) + (inStr ? STRING_PENALTY : 0);
         if (dist < bestDist) { bestDist = dist; bestCol = m.index; }
       }
-      if (bestCol >= 0) return lineColToOffset(entry.tsContent, targetLine, bestCol);
+      if (bestCol >= 0) {
+        // If every match for `word` in the target line is inside a string
+        // literal (so hover would return nothing) but we have a precise
+        // mapping hint for this source position, prefer the hint. This is
+        // what makes hover on `:foo` (which compiles to `Symbol.for("foo")`)
+        // resolve to the `Symbol` identifier instead of the dead string.
+        if (useHint && bestDist >= STRING_PENALTY) {
+          return lineColToOffset(entry.tsContent, targetLine, genColHint);
+        }
+        return lineColToOffset(entry.tsContent, targetLine, bestCol);
+      }
 
       // Fall back to original genLine if overload didn't match
       if (targetLine !== genLine) {
         const re1b = new RegExp('\\b' + escaped + '\\b', 'g');
         let m1b, bestCol1b = -1, bestDist1b = Infinity;
         while ((m1b = re1b.exec(genText)) !== null) {
-          const dist = Math.abs(m1b.index - expectedGenCol);
+          const inStr = isInsideStringOrComment(genText, m1b.index);
+          const dist = Math.abs(m1b.index - expectedGenCol) + (inStr ? STRING_PENALTY : 0);
           if (dist < bestDist1b) { bestDist1b = dist; bestCol1b = m1b.index; }
         }
         if (bestCol1b >= 0) return lineColToOffset(entry.tsContent, genLine, bestCol1b);
@@ -1780,7 +3089,8 @@ export function srcToOffset(entry, line, col) {
           const re2 = new RegExp('\\b' + escaped + '\\b', 'g');
           let m2, best2 = -1, bestDist2 = Infinity;
           while ((m2 = re2.exec(tryText)) !== null) {
-            const dist2 = Math.abs(m2.index - col);
+            const inStr = isInsideStringOrComment(tryText, m2.index);
+            const dist2 = Math.abs(m2.index - col) + (inStr ? STRING_PENALTY : 0);
             if (dist2 < bestDist2) { bestDist2 = dist2; best2 = m2.index; }
           }
           if (best2 >= 0) return lineColToOffset(entry.tsContent, tryLine, best2);
@@ -1848,23 +3158,32 @@ export function mapToSource(entry, offset) {
 
 // ── Project config ─────────────────────────────────────────────────
 
-// Read project config: rip.json in the given directory, or "rip" key in
-// the nearest ancestor package.json.  Returns { strict, exclude }.
+// Read project config from the "rip" key in the nearest ancestor
+// package.json. Returns { strict, checkAll, exclude, ... } merged from
+// `package.json#rip`, plus `_configDir` marking where it was found.
+//
+// `strict`   — TS strictness family (noImplicitAny, strictNullChecks, …)
+// `checkAll` — coverage policy: check every non-@nocheck file, not just
+//              annotated ones. Independent of `strict`.
 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)) {
+        // The first package.json walking up is the project boundary — matching
+        // the LSP's findProjectRoot and TypeScript's nearest-config resolution.
+        // Apply its `rip` config if present, otherwise fall back to defaults;
+        // either way stop here. We deliberately do NOT walk past it into
+        // ancestors: a parent repo's config must not silently leak across a
+        // project boundary (e.g. a standalone app nested inside a larger git
+        // repo inheriting that repo's `strict`). Inheritance, if ever wanted,
+        // should be opt-in and explicit rather than positional.
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-        if (pkg.rip && typeof pkg.rip === 'object') { Object.assign(config, pkg.rip); config._configDir = d; break; }
+        if (pkg.rip && typeof pkg.rip === 'object') Object.assign(config, pkg.rip);
+        config._configDir = d;
+        break;
       }
       const parent = dirname(d);
       if (parent === d) break;
@@ -1922,6 +3241,7 @@ function findRipFiles(dir, files = [], excludePatterns = [], rootDir = dir) {
 
 const isColor = process.stdout.isTTY !== false;
 const red     = (s) => isColor ? `\x1b[31m${s}\x1b[0m` : s;
+const green   = (s) => isColor ? `\x1b[32m${s}\x1b[0m` : s;
 const yellow  = (s) => isColor ? `\x1b[33m${s}\x1b[0m` : s;
 const cyan    = (s) => isColor ? `\x1b[36m${s}\x1b[0m` : s;
 const dim     = (s) => isColor ? `\x1b[2m${s}\x1b[0m`  : s;
@@ -1947,9 +3267,8 @@ export async function runCheck(targetDir, opts = {}) {
   }
 
   const ripConfig = readProjectConfig(rootPath);
-
-  // Merge: CLI flags override config file
-  const strict = opts.strict || ripConfig.strict === true;
+  const strict   = ripConfig.strict   === true;
+  const checkAll = ripConfig.checkAll === true;
   const excludeGlobs = Array.isArray(ripConfig.exclude) ? ripConfig.exclude : [];
   const excludePatterns = excludeGlobs.map(globToRegex);
 
@@ -1967,7 +3286,7 @@ export async function runCheck(targetDir, opts = {}) {
     const source = readFileSync(fp, 'utf8');
     sourcesByPath.set(fp, source);
     const nocheck = /^#\s*@nocheck\b/m.test(source.slice(0, NOCHECK_SCAN_LIMIT));
-    if (!nocheck && (hasTypeAnnotations(source) || strict)) typedFiles.add(fp);
+    if (!nocheck && (hasTypeAnnotations(source) || checkAll)) typedFiles.add(fp);
   }
 
   // Include imports of typed files (files imported BY typed files)
@@ -2003,7 +3322,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(), { strict }));
+      compiled.set(fp, compileForCheck(fp, source, new Compiler(), { checkAll }));
     } catch (e) {
       compileErrors++;
       const rel = relative(rootPath, fp);
@@ -2011,6 +3330,50 @@ export async function runCheck(targetDir, opts = {}) {
     }
   }
 
+  // Always compile the project's stash file (even when excluded), so its
+  // `__RipStash` export is resolvable from typed components that consume it.
+  // Diagnostics from the stash file are still suppressed via exclude when
+  // emitting results — this only ensures cross-module type info is available.
+  const seenStash = new Set();
+  for (const fp of typedFiles) {
+    const stashFile = findStashFile(fp);
+    if (!stashFile || seenStash.has(stashFile)) continue;
+    seenStash.add(stashFile);
+    if (compiled.has(stashFile) || !existsSync(stashFile)) continue;
+    try {
+      const src = sourcesByPath.get(stashFile) ?? readFileSync(stashFile, 'utf8');
+      const compiledStash = compileForCheck(stashFile, src, new Compiler(), { checkAll });
+      compiledStash._typeOnly = true; // skip diagnostics — only here for cross-module types
+      compiled.set(stashFile, compiledStash);
+    } catch (e) {
+      console.warn(`[rip] stash compile failed for ${stashFile}: ${e.message}`);
+    }
+  }
+
+  // Always compile the project's entry file when routes exist, so its
+  // `__RipRoutes` export is resolvable from typed route/layout files. The
+  // entry file (server bin) is typically untyped — it just calls `start()` —
+  // so it wouldn't otherwise be pulled into the typed set, and
+  // `import('<entry>').__RipRoutes` would silently resolve to `any`,
+  // disabling the route-typo check. Diagnostics from the entry are
+  // suppressed via `_typeOnly` — only here as a cross-module type carrier.
+  const seenEntry = new Set();
+  for (const fp of typedFiles) {
+    const entryFile = findEntryFile(fp);
+    if (!entryFile || seenEntry.has(entryFile)) continue;
+    seenEntry.add(entryFile);
+    if (!findRoutesDir(fp)) continue;
+    if (compiled.has(entryFile) || !existsSync(entryFile)) continue;
+    try {
+      const src = sourcesByPath.get(entryFile) ?? readFileSync(entryFile, 'utf8');
+      const compiledEntry = compileForCheck(entryFile, src, new Compiler(), { checkAll });
+      compiledEntry._typeOnly = true;
+      compiled.set(entryFile, compiledEntry);
+    } catch (e) {
+      console.warn(`[rip] entry compile failed for ${entryFile}: ${e.message}`);
+    }
+  }
+
   // Also compile any .rip files imported from typed files that aren't yet compiled
   for (const [fp, entry] of [...compiled.entries()]) {
     if (!entry.hasTypes) continue;
@@ -2028,6 +3391,92 @@ export async function runCheck(targetDir, opts = {}) {
     }
   }
 
+  // ── @rip-lang/* package resolution ─────────────────────────────────
+  //
+  // When a typed file imports from `@rip-lang/foo` (or `@rip-lang/foo/sub`),
+  // resolve the specifier via Node module resolution rooted at the project,
+  // and if it lands on a `.rip` entry, compile that entry with
+  // compileForCheck so its exported annotations become visible to TS as
+  // a virtual `.rip.ts` module. Diagnostics from the package itself are
+  // suppressed (`_typeOnly = true`) — package internals are checked when
+  // the package is checked, not when its consumers are.
+  const pkgRequire = createRequire(resolve(rootPath, 'package.json'));
+  const pkgSpecCache = new Map(); // spec → resolved abs path | null
+  function resolvePkgSpec(spec) {
+    if (pkgSpecCache.has(spec)) return pkgSpecCache.get(spec);
+    let resolved = null;
+    try {
+      const r = pkgRequire.resolve(spec);
+      if (typeof r === 'string' && r.endsWith('.rip') && existsSync(r)) resolved = r;
+    } catch {}
+    pkgSpecCache.set(spec, resolved);
+    return resolved;
+  }
+
+  // ── Undeclared-import diagnostic (`rip check` surface) ──
+  // Same check as the loader and bundler — surfaced earlier when typing is on.
+  // The project's own `package.json#name` is treated as a self-import (covers
+  // in-package fixtures/tests like `packages/server/bench/index.rip`).
+  let undeclaredCount = 0;
+  try {
+    const projPkgPath = resolve(rootPath, 'package.json');
+    if (existsSync(projPkgPath)) {
+      const projPkg = JSON.parse(readFileSync(projPkgPath, 'utf8'));
+      const declared = new Set([
+        ...Object.keys(projPkg.dependencies         || {}),
+        ...Object.keys(projPkg.devDependencies      || {}),
+        ...Object.keys(projPkg.peerDependencies     || {}),
+        ...Object.keys(projPkg.optionalDependencies || {}),
+      ]);
+      const selfName = projPkg.name || null;
+      const reported = new Set();
+      for (const [fp, entry] of compiled) {
+        if (entry._typeOnly) continue;
+        for (const spec of scanRipPkgImports(entry.tsContent || entry.source)) {
+          const pkgKey = ripPkgRoot(spec);
+          if (pkgKey === selfName) continue;
+          if (declared.has(pkgKey)) continue;
+          const key = `${fp}::${pkgKey}`;
+          if (reported.has(key)) continue;
+          reported.add(key);
+          const rel = relative(rootPath, fp);
+          console.error(`${red('error')} ${cyan(rel)}: import of '${pkgKey}' is not declared in package.json. Run \`bun add ${pkgKey}\` (or use \`workspace:*\` inside this monorepo).`);
+          undeclaredCount++;
+        }
+      }
+    }
+  } catch (e) {
+    console.warn(`[rip] undeclared-import check failed: ${e.message}`);
+  }
+  const pendingPkgFiles = new Set();
+  for (const [, entry] of compiled) {
+    const text = entry.tsContent || entry.source;
+    for (const spec of [...scanRipPkgImports(text), ...scanRipPkgImportTypes(text)]) {
+      const r = resolvePkgSpec(spec);
+      if (r && !compiled.has(r)) pendingPkgFiles.add(r);
+    }
+  }
+  // Iterate transitively: package files may themselves import other
+  // @rip-lang/* entries. Bounded by the number of unique resolved paths.
+  while (pendingPkgFiles.size) {
+    const next = pendingPkgFiles.values().next().value;
+    pendingPkgFiles.delete(next);
+    if (compiled.has(next)) continue;
+    try {
+      const pkgSrc = readFileSync(next, 'utf8');
+      const compiledPkg = compileForCheck(next, pkgSrc, new Compiler());
+      compiledPkg._typeOnly = true;
+      compiled.set(next, compiledPkg);
+      const pkgText = compiledPkg.tsContent || pkgSrc;
+      for (const spec of [...scanRipPkgImports(pkgText), ...scanRipPkgImportTypes(pkgText)]) {
+        const r = resolvePkgSpec(spec);
+        if (r && !compiled.has(r)) pendingPkgFiles.add(r);
+      }
+    } catch (e) {
+      console.warn(`[rip] @rip-lang package compile failed for ${next}: ${e.message}`);
+    }
+  }
+
   // Check for unresolved relative imports in all files (not just typed ones)
   const fileResults = [];
   let totalErrors = 0, totalWarnings = 0;
@@ -2049,7 +3498,26 @@ export async function runCheck(targetDir, opts = {}) {
   }
 
   // Create TypeScript language service
-  const settings = createTypeCheckSettings(ts);
+  //
+  // Project-scope `strict` (package.json `rip.strict: true`)
+  // opts the project UP to TypeScript's `strict` family, which implies
+  // noImplicitAny, strictNullChecks, strictFunctionTypes, and friends.
+  // With strict on: `T` excludes null/undefined, untyped params error,
+  // etc. Without strict: lenient gradual-typing defaults — annotations
+  // are accepted as documentation but not enforced as contracts. The
+  // default is lenient to match Rip's "scaffolding, not safety rails"
+  // philosophy; projects opt up when they want the contract enforced.
+  // Collect `node_modules/@types` directories walking up from rootPath so
+  // ambient type packages (e.g. `@types/bun`) installed at the workspace
+  // root are picked up even when `rip check` runs in a sub-package. TS's
+  // default `typeRoots` only looks at `<cwd>/node_modules/@types`.
+  const { typeRoots, types: ambientTypes } = collectAmbientTypes(rootPath);
+
+  const settings = createTypeCheckSettings(ts, {
+    ...(strict ? { strict: true } : {}),
+    ...(typeRoots.length ? { typeRoots } : {}),
+    ...(ambientTypes.length ? { types: ambientTypes } : {}),
+  });
 
   const host = {
     getScriptFileNames: () => [...compiled.keys()].map(toVirtual),
@@ -2068,6 +3536,14 @@ export async function runCheck(targetDir, opts = {}) {
     getDirectories: (...a) => ts.sys.getDirectories(...a),
     directoryExists: (...a) => ts.sys.directoryExists(...a),
 
+    resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, options) {
+      return typeDirectiveNames.map((name) => {
+        const n = typeof name === 'string' ? name : name.name;
+        const r = ts.resolveTypeReferenceDirective(n, containingFile, options || settings, ts.sys, redirectedReference);
+        return r.resolvedTypeReferenceDirective;
+      });
+    },
+
     resolveModuleNames(names, containingFile) {
       return names.map((name) => {
         if (name.endsWith('.rip')) {
@@ -2076,6 +3552,12 @@ export async function runCheck(targetDir, opts = {}) {
             return { resolvedFileName: toVirtual(resolved), extension: '.ts', isExternalLibraryImport: false };
           }
         }
+        if (name.startsWith('@rip-lang/')) {
+          const r = resolvePkgSpec(name);
+          if (r && compiled.has(r)) {
+            return { resolvedFileName: toVirtual(r), extension: '.ts', isExternalLibraryImport: false };
+          }
+        }
         const r = ts.resolveModuleName(name, containingFile, settings, {
           fileExists: host.fileExists,
           readFile: host.readFile,
@@ -2097,6 +3579,7 @@ export async function runCheck(targetDir, opts = {}) {
 
   for (const [fp, entry] of compiled) {
     if (!entry.hasTypes) continue;
+    if (entry._typeOnly) continue;
 
     const vf = toVirtual(fp);
     let diags;
@@ -2120,7 +3603,7 @@ export async function runCheck(targetDir, opts = {}) {
       // 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;
+        if (shouldSuppressConditional(d.code, d.start, d.length, entry.tsContent, entry.headerLines, entry.dts, flatMsg, fp, d.relatedInformation)) continue;
       }
 
       // Skip 6133 on compiler-generated _render() construction variables (_0, _1, …)
@@ -2142,12 +3625,18 @@ export async function runCheck(targetDir, opts = {}) {
       if (adj) { pos.line = adj.line; pos.col = adj.col; }
 
       const endPos = adj ? { line: adj.line, col: adj.col + adj.len } : (d.length ? mapToSourcePos(entry, d.start + d.length) : null);
-      const len = endPos && endPos.line === pos.line ? endPos.col - pos.col : 1;
+      let len = endPos && endPos.line === pos.line ? endPos.col - pos.col : 1;
 
       const message = cleanDiagnosticMessage(ts.flattenDiagnosticMessageText(d.messageText, '\n'));
       const severity = d.category === 1 ? 'error' : d.category === 0 ? 'warning' : 'info';
       const srcLine = srcLines[pos.line] || '';
 
+      const { code: finalCode, message: finalMessage } = unifyRouteDiagnostic(d.code, message, entry, d.start, fp);
+
+      // Snap route diagnostics to the meaningful token (`href` / `push`).
+      const routeSpan = locateRouteDiagnosticSpan(entry, d.start, srcLine);
+      if (routeSpan) { pos.col = routeSpan.col; len = routeSpan.len; }
+
       // Collect related information
       const related = [];
       if (d.relatedInformation) {
@@ -2194,11 +3683,30 @@ export async function runCheck(targetDir, opts = {}) {
         }
       }
 
-      errors.push({ line: pos.line + 1, col: pos.col + 1, len: Math.max(1, len), message, severity, code: d.code, srcLine, related });
+      errors.push({ line: pos.line + 1, col: pos.col + 1, len: Math.max(1, len), message: finalMessage, severity, code: finalCode, srcLine, related });
       if (severity === 'error') totalErrors++;
       else if (severity === 'warning') totalWarnings++;
     }
 
+    // Dedup: same diagnostic can map twice when the dts header and compiled
+    // body both contain the offending construct (e.g. an `import { X }` line).
+    {
+      const deduped = dedupDiagnostics(errors, e => ({
+        startLine: e.line, startCol: e.col,
+        endLine: e.line, endCol: e.col + e.len,
+      }));
+      if (deduped.length < errors.length) {
+        const kept = new Set(deduped);
+        for (const e of errors) {
+          if (kept.has(e)) continue;
+          if (e.severity === 'error') totalErrors--;
+          else if (e.severity === 'warning') totalWarnings--;
+        }
+        errors.length = 0;
+        errors.push(...deduped);
+      }
+    }
+
     // Untyped component prop checking — flag props without :: annotation
     if (entry.dts) {
       for (const [compName, compInfo] of parseComponentDTS(entry.dts)) {
@@ -2233,6 +3741,7 @@ export async function runCheck(targetDir, opts = {}) {
     if (globalDefs.size > 0) {
       for (const [fp, entry] of compiled) {
         if (!entry.hasTypes) continue;
+        if (entry._typeOnly) continue;
         const srcLines = entry.source.split('\n');
         const errors = fileResults.find(r => r.file === fp)?.errors || [];
         const hadEntry = errors.length > 0;
@@ -2281,6 +3790,12 @@ export async function runCheck(targetDir, opts = {}) {
   // 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.
+  //
+  // Opt-in via `rip check --sourcemap`.  This is a compiler-development
+  // diagnostic — gaps usually mean the audit's skip list is incomplete or
+  // that codegen lost a binding, both compiler-side concerns rather than
+  // anything a package author can fix.  Not run as part of `--audit` (which
+  // is the package-author-facing public-API check).
 
   const AUDIT_SKIP = new Set([
     'if', 'else', 'then', 'unless', 'switch', 'when', 'for', 'while', 'until',
@@ -2348,8 +3863,9 @@ export async function runCheck(targetDir, opts = {}) {
   let auditGaps = 0;
   const auditResults = [];
 
-  for (const [fp, entry] of compiled) {
+  if (opts.sourceMapAudit) for (const [fp, entry] of compiled) {
     if (!entry.hasTypes) continue;
+    if (entry._typeOnly) continue;
     const srcLines = entry.source.split('\n');
     const vf = toVirtual(fp);
     const gaps = [];
@@ -2444,19 +3960,6 @@ export async function runCheck(targetDir, opts = {}) {
     }
   }
 
-  // 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);
@@ -2496,7 +3999,8 @@ export async function runCheck(targetDir, opts = {}) {
   // Summary — tsc format
   const totalFound = totalErrors + totalWarnings;
   if (totalFound === 0) {
-    return compileErrors > 0 ? 1 : 0;
+    printSourceMapAudit();
+    return compileErrors > 0 || undeclaredCount > 0 ? 1 : 0;
   }
 
   const s = totalFound === 1 ? '' : 's';
@@ -2518,5 +4022,418 @@ export async function runCheck(targetDir, opts = {}) {
     console.log('');
   }
 
-  return totalErrors > 0 ? 1 : 0;
+  printSourceMapAudit();
+  return totalErrors > 0 || undeclaredCount > 0 ? 1 : 0;
+
+  function printSourceMapAudit() {
+    if (!opts.sourceMapAudit || auditResults.length === 0) return;
+    console.log(bold('── 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`);
+  }
+}
+
+// ── Public-surface `any` audit ─────────────────────────────────────
+//
+// `rip check --audit [pkgDir]` walks a package's public exports and
+// flags any export whose type contains `any` (in parameters, return
+// types, or own properties of types declared in the package).
+// External types (e.g. lib.es5, @types/*) are treated as opaque —
+// we don't dive into `Promise<Response>` looking for `any` inside
+// `Response`. The package can only control its own surface; this
+// audit measures exactly that.
+//
+// Exit code: 0 if every export is `any`-free, 1 otherwise.
+
+// Resolve a package's public entries from its package.json. Handles
+// `main`, `module`, string `exports`, and the subpath/conditional
+// `exports` map. Returns [{ subpath, file }] with absolute paths.
+function collectPackageEntries(pkg, pkgDir) {
+  const entries = new Map(); // subpath → abs file
+  const add = (subpath, p) => {
+    if (typeof p !== 'string') return;
+    if (entries.has(subpath)) return;
+    entries.set(subpath, resolve(pkgDir, p));
+  };
+  const walkConditional = (subpath, v) => {
+    if (typeof v === 'string') { add(subpath, v); return; }
+    if (!v || typeof v !== 'object') return;
+    // Prefer `import` then `default`, fall back to any string value.
+    if (typeof v.import === 'string') { add(subpath, v.import); return; }
+    if (typeof v.default === 'string') { add(subpath, v.default); return; }
+    for (const k of Object.keys(v)) walkConditional(subpath, v[k]);
+  };
+
+  if (typeof pkg.exports === 'string') {
+    add('.', pkg.exports);
+  } else if (pkg.exports && typeof pkg.exports === 'object') {
+    const keys = Object.keys(pkg.exports);
+    const isSubpathMap = keys.some(k => k.startsWith('.'));
+    if (isSubpathMap) {
+      for (const sp of keys) walkConditional(sp, pkg.exports[sp]);
+    } else {
+      walkConditional('.', pkg.exports);
+    }
+  }
+  if (!entries.has('.') && typeof pkg.module === 'string') add('.', pkg.module);
+  if (!entries.has('.') && typeof pkg.main   === 'string') add('.', pkg.main);
+  return [...entries.entries()].map(([subpath, file]) => ({ subpath, file }));
+}
+
+// True if `type`'s declarations all live outside the package's
+// compiled set (i.e. it's a lib/`@types`/external type). Anonymous
+// types (no symbol or no declarations) are treated as local — they
+// are inline shapes from the package's own annotations.
+function isExternalType(type, compiled) {
+  const sym = type.aliasSymbol || type.symbol;
+  if (!sym || !sym.declarations || sym.declarations.length === 0) return false;
+  for (const d of sym.declarations) {
+    const sf = d.getSourceFile?.();
+    if (!sf) continue;
+    if (compiled.has(fromVirtual(sf.fileName))) return false;
+  }
+  return true;
+}
+
+// Walk a TS type looking for `any`. Returns null if no leak, or a
+// breadcrumb string describing where the `any` lives.
+//
+// Scoping rule: EXTERNAL types are fully opaque. We don't walk into
+// their unions, type arguments, signatures, or properties. The
+// package is only accountable for shapes it directly wrote. If a
+// package's export references another local exported type, that
+// referenced type gets audited on its own export — not transitively
+// through every place it's referenced.
+//
+// Why so strict: lib.dom types like `BodyInit` resolve to unions
+// including `ReadableStream<R = any>`. Walking into the expansion
+// blames the package for `any` it never wrote. Same for `Promise<T>`,
+// `Array<T>`, `Record<K, V>`, etc. — diving into them surfaces
+// internals the package doesn't control.
+//
+// Trade-off: `Promise<any>` written literally in package source is
+// also opaque under this rule, so we miss it. Acceptable: such a
+// pattern is rare and easy to spot in review.
+function findAnyLeaks(type, ts, checker, compiled, seen = new WeakSet(), depth = 0, exportedSymbols = null, rootSymbol = null) {
+  if (!type || depth > 12) return null;
+  if (type.flags & ts.TypeFlags.Any) return '';
+  if (isExternalType(type, compiled)) return null;
+  // On recursion (depth > 0), stop at any other exported symbol.
+  // Each export is audited on its own line — don't double-count
+  // leaks through cross-references.
+  if (depth > 0 && exportedSymbols) {
+    const sym = type.aliasSymbol || type.symbol;
+    if (sym && sym !== rootSymbol && exportedSymbols.has(sym)) return null;
+  }
+  if (seen.has(type)) return null;
+  seen.add(type);
+
+  const named = (type.aliasSymbol || type.symbol)?.getName?.();
+  const label = named && named !== '__type' && named !== '__object' ? named : null;
+
+  if (type.isUnion?.() || type.isIntersection?.()) {
+    for (let i = 0; i < type.types.length; i++) {
+      const p = findAnyLeaks(type.types[i], ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+      if (p !== null) return joinPath(label, `|${i}`, p);
+    }
+  }
+
+  const args = checker.getTypeArguments?.(type) || type.typeArguments || [];
+  for (let i = 0; i < args.length; i++) {
+    const p = findAnyLeaks(args[i], ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+    if (p !== null) return joinPath(label, `<${i}>`, p);
+  }
+
+  const walkParams = (sig) => {
+    for (const p of sig.parameters) {
+      const decl = p.valueDeclaration || p.declarations?.[0];
+      if (!decl) continue;
+      const pt = checker.getTypeOfSymbolAtLocation(p, decl);
+      const sub = findAnyLeaks(pt, ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+      if (sub !== null) return joinPath(null, `(${p.getName()})`, sub);
+    }
+    return null;
+  };
+
+  for (const sig of type.getCallSignatures?.() || []) {
+    const ps = walkParams(sig);
+    if (ps !== null) return joinPath(label, '', ps);
+    const rs = findAnyLeaks(sig.getReturnType(), ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+    if (rs !== null) return joinPath(label, '=>', rs);
+  }
+  for (const sig of type.getConstructSignatures?.() || []) {
+    const ps = walkParams(sig);
+    if (ps !== null) return joinPath(label, 'new', ps);
+    const rs = findAnyLeaks(sig.getReturnType(), ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+    if (rs !== null) return joinPath(label, 'new=>', rs);
+  }
+
+  if (type.getProperties) {
+    for (const p of type.getProperties()) {
+      const decl = p.valueDeclaration || p.declarations?.[0];
+      if (!decl) continue;
+      const sf = decl.getSourceFile?.();
+      if (!sf) continue;
+      if (!compiled.has(fromVirtual(sf.fileName))) continue;
+      const pt = checker.getTypeOfSymbolAtLocation(p, decl);
+      const sub = findAnyLeaks(pt, ts, checker, compiled, seen, depth + 1, exportedSymbols, rootSymbol);
+      if (sub !== null) return joinPath(label, `.${p.getName()}`, sub);
+    }
+  }
+
+  return null;
+}
+
+function joinPath(label, step, rest) {
+  const head = label ? `${label}${step}` : step;
+  if (!rest) return head || '<any>';
+  if (rest.startsWith('|') || rest.startsWith('<') || rest.startsWith('(') || rest.startsWith('.') || rest.startsWith('=>') || rest.startsWith('new')) {
+    return head + rest;
+  }
+  return head ? `${head}.${rest}` : rest;
+}
+
+export async function runAudit(targetDir) {
+  const rootPath = resolve(targetDir);
+
+  let ts;
+  try {
+    const req = createRequire(resolve(rootPath, 'package.json'));
+    ts = req('typescript');
+  } catch {
+    try { ts = await import('typescript').then(m => m.default || m); } catch {
+      console.error('TypeScript is required for --audit. Install with: bun add -d typescript');
+      return 1;
+    }
+  }
+
+  const pkgJsonPath = resolve(rootPath, 'package.json');
+  if (!existsSync(pkgJsonPath)) {
+    console.error(red(`No package.json found at ${rootPath}`));
+    return 1;
+  }
+  const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+  const pkgName = pkg.name || basename(rootPath);
+
+  const allEntries = collectPackageEntries(pkg, rootPath);
+  const ripEntries = allEntries.filter(e => e.file.endsWith('.rip') && existsSync(e.file));
+  if (ripEntries.length === 0) {
+    console.error(red(`No .rip entry points found in ${pkgName}`));
+    if (allEntries.length > 0) {
+      console.error(dim(`  package.json declares entries, but none point to a .rip file:`));
+      for (const e of allEntries) console.error(dim(`    ${e.subpath} → ${relative(rootPath, e.file)}`));
+    }
+    return 1;
+  }
+
+  // Compile each entry plus its transitive `.rip` imports so the
+  // language service can resolve cross-module types. Only entries
+  // themselves are audited; imported files exist purely so types
+  // referenced from the entry can be expanded.
+  const compiled = new Map();
+  const queue = ripEntries.map(e => e.file);
+  while (queue.length) {
+    const fp = queue.shift();
+    if (compiled.has(fp)) continue;
+    try {
+      const source = readFileSync(fp, 'utf8');
+      // Compile with strict: true so every export's annotations are
+      // emitted into the DTS — without strict, partially-annotated
+      // exports could fall back to inferred types that look cleaner
+      // than they really are.
+      compiled.set(fp, compileForCheck(fp, source, new Compiler(), { checkAll: true }));
+      for (const m of source.matchAll(/from\s+['"]([^'"]+)['"]/g)) {
+        const spec = m[1];
+        if (spec.endsWith('.rip')) {
+          const r = resolve(dirname(fp), spec);
+          if (existsSync(r) && !compiled.has(r)) queue.push(r);
+        }
+      }
+    } catch (e) {
+      console.error(`${red('error')} ${cyan(relative(rootPath, fp))}: compile error — ${e.message}`);
+      return 1;
+    }
+  }
+
+  // Resolve @rip-lang/* package imports (siblings in the workspace)
+  // so cross-package re-exports type correctly.
+  const pkgRequire = createRequire(resolve(rootPath, 'package.json'));
+  const pkgSpecCache = new Map();
+  function resolvePkgSpec(spec) {
+    if (pkgSpecCache.has(spec)) return pkgSpecCache.get(spec);
+    let resolved = null;
+    try {
+      const r = pkgRequire.resolve(spec);
+      if (typeof r === 'string' && r.endsWith('.rip') && existsSync(r)) resolved = r;
+    } catch {}
+    pkgSpecCache.set(spec, resolved);
+    return resolved;
+  }
+  const pkgQueue = new Set();
+  for (const [, entry] of compiled) {
+    for (const spec of scanRipPkgImports(entry.tsContent || entry.source)) {
+      const r = resolvePkgSpec(spec);
+      if (r && !compiled.has(r)) pkgQueue.add(r);
+    }
+  }
+  while (pkgQueue.size) {
+    const next = pkgQueue.values().next().value;
+    pkgQueue.delete(next);
+    if (compiled.has(next)) continue;
+    try {
+      const src = readFileSync(next, 'utf8');
+      const compiledPkg = compileForCheck(next, src, new Compiler());
+      compiled.set(next, compiledPkg);
+      for (const spec of scanRipPkgImports(compiledPkg.tsContent || src)) {
+        const r = resolvePkgSpec(spec);
+        if (r && !compiled.has(r)) pkgQueue.add(r);
+      }
+    } catch (e) {
+      console.warn(`[rip] @rip-lang package compile failed for ${next}: ${e.message}`);
+    }
+  }
+
+  const { typeRoots, types: ambientTypes } = collectAmbientTypes(rootPath);
+  const settings = createTypeCheckSettings(ts, {
+    strict: true,
+    ...(typeRoots.length    ? { typeRoots }              : {}),
+    ...(ambientTypes.length ? { types: ambientTypes }    : {}),
+  });
+
+  const host = {
+    getScriptFileNames: () => [...compiled.keys()].map(toVirtual),
+    getScriptVersion:   () => '1',
+    getScriptSnapshot(f) {
+      const c = compiled.get(fromVirtual(f));
+      if (c) return ts.ScriptSnapshot.fromString(c.tsContent);
+      try { return ts.ScriptSnapshot.fromString(readFileSync(f, 'utf8')); } catch { return undefined; }
+    },
+    getCompilationSettings: () => settings,
+    getDefaultLibFileName:  (o) => ts.getDefaultLibFilePath(o),
+    getCurrentDirectory:    () => rootPath,
+    fileExists(f) { return compiled.has(fromVirtual(f)) || ts.sys.fileExists(f); },
+    readFile(f)   { return compiled.get(fromVirtual(f))?.tsContent || ts.sys.readFile(f); },
+    readDirectory:   (...a) => ts.sys.readDirectory(...a),
+    getDirectories:  (...a) => ts.sys.getDirectories(...a),
+    directoryExists: (...a) => ts.sys.directoryExists(...a),
+    resolveTypeReferenceDirectives(names, containingFile, redirectedReference, options) {
+      return names.map(n => {
+        const name = typeof n === 'string' ? n : n.name;
+        const r = ts.resolveTypeReferenceDirective(name, containingFile, options || settings, ts.sys, redirectedReference);
+        return r.resolvedTypeReferenceDirective;
+      });
+    },
+    resolveModuleNames(names, containingFile) {
+      return names.map(name => {
+        if (name.endsWith('.rip')) {
+          const r = resolve(dirname(fromVirtual(containingFile)), name);
+          if (compiled.has(r)) return { resolvedFileName: toVirtual(r), extension: '.ts', isExternalLibraryImport: false };
+        }
+        if (name.startsWith('@rip-lang/')) {
+          const r = resolvePkgSpec(name);
+          if (r && compiled.has(r)) return { resolvedFileName: toVirtual(r), extension: '.ts', isExternalLibraryImport: false };
+        }
+        const r = ts.resolveModuleName(name, containingFile, settings, {
+          fileExists:          host.fileExists,
+          readFile:            host.readFile,
+          directoryExists:     host.directoryExists,
+          getCurrentDirectory: host.getCurrentDirectory,
+          getDirectories:      host.getDirectories,
+        });
+        return r.resolvedModule;
+      });
+    },
+  };
+
+  const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+  const program = service.getProgram();
+  const checker = program.getTypeChecker();
+  const fmtFlags = ts.TypeFormatFlags.NoTruncation
+    | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+    | ts.TypeFormatFlags.WriteArrayAsGenericType;
+
+  let totalExports = 0, totalLeaks = 0;
+
+  // First pass: collect ALL exported symbols across all entries.
+  // The walker treats these as opaque on recursion — each export is
+  // audited only on its own direct shape. If export A references
+  // export B and B leaks, the leak surfaces on B's audit line, not
+  // by polluting every type that mentions B.
+  const exportedSymbols = new Set();
+  const entryData = [];
+  for (const entry of ripEntries) {
+    const vf = toVirtual(entry.file);
+    const sourceFile = program.getSourceFile(vf);
+    if (!sourceFile) { entryData.push(null); continue; }
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol) { entryData.push({ sourceFile, exports: null }); continue; }
+    const exps = checker.getExportsOfModule(moduleSymbol);
+    for (const s of exps) exportedSymbols.add(s);
+    entryData.push({ sourceFile, exports: exps });
+  }
+
+  for (let idx = 0; idx < ripEntries.length; idx++) {
+    const entry = ripEntries[idx];
+    const data = entryData[idx];
+    const rel = relative(rootPath, entry.file);
+
+    if (!data) {
+      console.log(`  ${red('error')} could not load ${cyan(rel)}`);
+      continue;
+    }
+    const { sourceFile, exports } = data;
+    if (!exports) {
+      console.log(`  ${dim('(no exports)')}`);
+      continue;
+    }
+
+    const header = entry.subpath === '.' ? rel : `${rel}  ${dim('('+entry.subpath+')')}`;
+    console.log(`\n  ${cyan(header)}`);
+
+    // Compute max name width for column alignment.
+    const names = exports.map(s => s.getName());
+    const colW = Math.min(28, names.reduce((m, n) => Math.max(m, n.length), 0));
+
+    for (const sym of exports) {
+      totalExports++;
+      let t;
+      if (sym.flags & ts.SymbolFlags.Value) {
+        t = checker.getTypeOfSymbolAtLocation(sym, sourceFile);
+      } else {
+        t = checker.getDeclaredTypeOfSymbol(sym);
+      }
+      // Pass `sym` as the rootSymbol so recursion into OTHER exported
+      // symbols stops, but recursion into the export's own self-named
+      // type (e.g. typeof Class → the class itself) doesn't immediately
+      // bail out.
+      const leakPath = findAnyLeaks(t, ts, checker, compiled, new WeakSet(), 0, exportedSymbols, sym);
+      const leaks = leakPath !== null;
+      const typeStr = checker.typeToString(t, sourceFile, fmtFlags);
+      const name = sym.getName();
+      const mark = leaks ? red('✗') : green('✓');
+      console.log(`    ${mark} ${name.padEnd(colW)}  ${dim(typeStr)}`);
+      if (leaks) {
+        totalLeaks++;
+        console.log(`      ${dim('└─ any at: ')}${yellow(leakPath || '<root>')}`);
+      }
+    }
+  }
+
+  const typed = totalExports - totalLeaks;
+  const pct = totalExports > 0 ? (100 * typed / totalExports).toFixed(1) : '100.0';
+
+  console.log('');
+  if (totalLeaks === 0) {
+    console.log(`${green('✓')} ${bold(pkgName)}: ${typed}/${totalExports} exports fully typed (${pct}%).`);
+  } else {
+    console.log(`${red('✗')} ${bold(pkgName)}: ${typed}/${totalExports} exports fully typed (${pct}%). ${red(String(totalLeaks))} export${totalLeaks === 1 ? '' : 's'} leak \`any\`.`);
+  }
+
+  return totalLeaks > 0 ? 1 : 0;
 }