rip-lang 3.17.3 → 3.17.5

package/src/schema/runtime-validate.js

@@ -904,6 +904,13 @@ class __SchemaDef {
     // a non-enumerable accessor so order.user_id and order.userId read
     // the same slot — useful when DB column names leak into user code
     // via raw SQL helpers.
+    //
+    // Temporal values arrive already decoded by the adapter: @rip-lang/db
+    // decodes date/datetime columns to real `Date` at the wire boundary
+    // (naive TIMESTAMP is read as UTC), so hydrate stores them verbatim —
+    // do NOT add a decode here. That keeps a single decode seam and honors
+    // the `date`/`datetime` -> `Date` .d.ts contract. (`_coerceDates` below
+    // is parse-only, for JSON/HTTP input — it never runs on this path.)
     const data = {};
     for (let i = 0; i < columns.length; i++) {
       data[__schemaCamel(columns[i].name)] = row[i];

package/src/schema/runtime.generated.js

@@ -992,6 +992,13 @@ class __SchemaDef {
     // a non-enumerable accessor so order.user_id and order.userId read
     // the same slot — useful when DB column names leak into user code
     // via raw SQL helpers.
+    //
+    // Temporal values arrive already decoded by the adapter: @rip-lang/db
+    // decodes date/datetime columns to real \`Date\` at the wire boundary
+    // (naive TIMESTAMP is read as UTC), so hydrate stores them verbatim —
+    // do NOT add a decode here. That keeps a single decode seam and honors
+    // the \`date\`/\`datetime\` -> \`Date\` .d.ts contract. (\`_coerceDates\` below
+    // is parse-only, for JSON/HTTP input — it never runs on this path.)
     const data = {};
     for (let i = 0; i < columns.length; i++) {
       data[__schemaCamel(columns[i].name)] = row[i];

package/src/typecheck.js

@@ -13,7 +13,7 @@
 import { Compiler, getStdlibCode } from './compiler.js';
 import { Lexer } from './lexer.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 { INTRINSIC_TYPE_DECLS, INTRINSIC_FN_DECL, 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';
@@ -407,25 +407,28 @@ export function validatePropDefault(type, defVal) {
   // A string literal in either quote style: "a" or 'a'.
   const isStrLit = s => /^"[^"]*"$/.test(s) || /^'[^']*'$/.test(s);
   const strInner = s => s.slice(1, -1);
+  // The literal kind of a default, or null when it isn't a recognizable literal
+  // (an identifier, call, or other expression). Only literal defaults can be
+  // judged here; a non-literal carries no statically known type, so it is left
+  // to the type checker and never flagged.
+  const litKind = s =>
+    isStrLit(s) ? 'string' :
+    /^-?\d+(\.\d+)?$/.test(s) ? 'number' :
+    (s === 'true' || s === 'false') ? 'boolean' : null;
   const parts = type.split('|').map(s => s.trim());
-  // String literal union: "a" | "b" | "c" (either quote style)
+  // String literal union: "a" | "b" | "c" (either quote style). Only a literal
+  // default naming no member is wrong; a non-literal default is left alone.
   if (parts.every(p => isStrLit(p))) {
     if (isStrLit(defVal) && !parts.some(p => strInner(p) === strInner(defVal))) {
       return `Type '${defVal}' is not assignable to type '${type}'`;
     }
     return null;
   }
-  // Single type checks
-  if (parts.length === 1) {
-    const t = parts[0];
-    if (t === 'boolean' && defVal !== 'true' && defVal !== 'false') {
-      return `Type '${defVal}' is not assignable to type 'boolean'`;
-    }
-    if (t === 'number' && !/^-?\d+(\.\d+)?$/.test(defVal)) {
-      return `Type '${defVal}' is not assignable to type 'number'`;
-    }
-    if (t === 'string' && !isStrLit(defVal)) {
-      return `Type '${defVal}' is not assignable to type 'string'`;
+  // Single primitive type: flag only a literal default of a different kind.
+  if (parts.length === 1 && (parts[0] === 'boolean' || parts[0] === 'number' || parts[0] === 'string')) {
+    const kind = litKind(defVal);
+    if (kind && kind !== parts[0]) {
+      return `Type '${defVal}' is not assignable to type '${parts[0]}'`;
     }
   }
   return null;
@@ -536,25 +539,28 @@ export function parseComponentDTS(dtsString) {
   return result;
 }
 
-// Check component prop definitions for untyped props and invalid defaults.
+// Check component prop definitions for invalid defaults.
 // Returns array of { line (0-based), col, len, message } error objects.
+//
+// Type annotations use a single ':' (e.g. `@count: number := 0`); `:=`/`=` is
+// an untyped initializer whose type is inferred from the default, and `::` is
+// prototype access — never a type. A typed prop with a `:= default` has its
+// default validated against the annotation; untyped props carry no annotation
+// to check against and are left alone.
 export function checkComponentDefs(compProps, srcLines, startLine = 0) {
   const errors = [];
   for (const prop of compProps) {
+    // `@name` + optional `?`, then a single `:` that is NOT part of `:=`.
+    const re = new RegExp('(@' + prop.name + ')\\b\\??\\s*:(?!=)\\s*(.+)$');
     for (let s = startLine; s < srcLines.length; s++) {
-      const m = new RegExp('(@' + prop.name + ')\\??\\s*(::|([:!]?=))').exec(srcLines[s]);
+      const m = re.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*(.+)'));
-        if (dm) {
-          const defVal = dm[2].replace(/#.*$/, '').trim();
-          const err = validatePropDefault(dm[1].trim(), defVal);
-          if (err) {
-            errors.push({ line: s, col: m.index, len: m[1].length, propName: prop.name, message: err });
-          }
-        }
+      // Validate a `:= default` against the annotation, if one is present.
+      const dm = m[2].match(/^(.+?)\s*:=\s*(.+)$/);
+      if (dm) {
+        const defVal = stripDefaultComment(dm[2]).trim();
+        const err = validatePropDefault(dm[1].trim(), defVal);
+        if (err) errors.push({ line: s, col: m.index, len: m[1].length, message: err });
       }
       break;
     }
@@ -562,6 +568,19 @@ export function checkComponentDefs(compProps, srcLines, startLine = 0) {
   return errors;
 }
 
+// Strip a trailing `# comment` from a default-value expression, ignoring a `#`
+// inside a quoted string literal (e.g. a CSS color `'#fff'`).
+function stripDefaultComment(s) {
+  let quote = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) { if (c === quote) quote = null; }
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === '#') return s.slice(0, i);
+  }
+  return s;
+}
+
 // Patch uninitialized, untyped variables with inferred types from their
 // first assignment. This makes `let total; total = count + ratio;` behave
 // like `let total: number;` — so a later `total = "string"` is caught.
@@ -2078,10 +2097,6 @@ export function compileForCheck(filePath, source, compiler, opts = {}) {
     headerDts = parts.join('\n') + '\n' + headerDts;
   }
 
-  if (hasTypes && /\bARIA\./.test(code) && !/\bdeclare const ARIA\b/.test(headerDts)) {
-    headerDts = ARIA_TYPE_DECLS.join('\n') + '\n' + headerDts;
-  }
-
   // Inline hoisted `let` declarations at their first assignment in the shadow
   // TS file, then merge DTS header types into the inlined declarations.
   //
@@ -3523,6 +3538,113 @@ export function readProjectConfig(dir) {
   return config;
 }
 
+// Resolve a project's ambient `.d.ts` includes — both explicit and automatic —
+// to a deduped list of absolute paths, added as explicit TS program roots
+// (appended to the language-service host's getScriptFileNames). An explicit
+// root-file `.d.ts` contributes its global `declare`s to every other file in the
+// program regardless of the `types` compiler option (like tsconfig `files`), so
+// this is how a project pulls in a shared ambient contract without a per-file
+// `/// <reference>`. Two mechanisms feed it:
+//
+//   ① explicit  — `package.json#rip.types: ["path/to/x.d.ts", ...]`. The escape
+//      hatch for ad-hoc / non-dependency `.d.ts`; paths resolve relative to the
+//      project root.
+//   ② automatic — every declared `@rip-lang/*` dependency that ships ambient
+//      types (its own `package.json#rip.ambient: ["x.d.ts", ...]`) has those
+//      files auto-included, resolved relative to the dependency's installed
+//      location. So depending on `@rip-lang/app` makes its global `ARIA` contract
+//      "just there" with zero config — "you used the framework, so its types are
+//      present."
+//
+// Deduped by absolute path (an explicit `rip.types` pointing at a file a
+// dependency already provides isn't included twice). Missing/unresolvable
+// entries are warned and skipped, never fatal.
+export function resolveTypeIncludes(ripConfig, rootPath) {
+  const out = [];
+  const seen = new Set();
+  const add = (abs) => { if (abs && !seen.has(abs)) { seen.add(abs); out.push(abs); } };
+
+  // ① explicit rip.types
+  const list = Array.isArray(ripConfig?.types) ? ripConfig.types : [];
+  for (const entry of list) {
+    if (typeof entry !== 'string' || !entry) continue;
+    const abs = resolve(rootPath, entry);
+    if (existsSync(abs)) add(abs);
+    else console.warn(`[rip] rip.types include not found, skipping: ${entry}`);
+  }
+
+  // ② auto-include ambient .d.ts from declared @rip-lang/* dependencies
+  for (const abs of collectDependencyAmbients(rootPath)) add(abs);
+
+  return out;
+}
+
+// Walk the project's declared `@rip-lang/*` dependencies (deps + devDeps +
+// peerDeps + optionalDeps) and collect the ambient `.d.ts` files each one
+// advertises via its own `package.json#rip.ambient`. Each file is resolved
+// relative to the dependency's resolved package directory (handles workspace
+// symlinks and real node_modules alike). Returns absolute paths of files that
+// exist; everything else is skipped — a declared-but-missing ambient file warns,
+// while an unresolvable dependency is silent (its absence surfaces through the
+// undeclared-import / module-resolution paths, not here).
+export function collectDependencyAmbients(rootPath) {
+  const out = [];
+  let projPkg;
+  try {
+    const projPkgPath = resolve(rootPath, 'package.json');
+    if (!existsSync(projPkgPath)) return out;
+    projPkg = JSON.parse(readFileSync(projPkgPath, 'utf8'));
+  } catch (e) {
+    console.warn(`[rip] ambient dep scan: cannot read project package.json: ${e.message}`);
+    return out;
+  }
+  const deps = [...new Set([
+    ...Object.keys(projPkg.dependencies         || {}),
+    ...Object.keys(projPkg.devDependencies      || {}),
+    ...Object.keys(projPkg.peerDependencies     || {}),
+    ...Object.keys(projPkg.optionalDependencies || {}),
+  ])].filter(name => name.startsWith('@rip-lang/'));
+  if (deps.length === 0) return out;
+
+  const req = createRequire(resolve(rootPath, 'package.json'));
+  for (const dep of deps) {
+    const depPkgJson = resolveDepPackageJson(dep, rootPath, req);
+    if (!depPkgJson) continue; // not installed/resolvable — not ours to report
+    let depPkg;
+    try { depPkg = JSON.parse(readFileSync(depPkgJson, 'utf8')); } catch { continue; }
+    const ambient = depPkg?.rip?.ambient;
+    if (!Array.isArray(ambient)) continue;
+    const depDir = dirname(depPkgJson);
+    for (const rel of ambient) {
+      if (typeof rel !== 'string' || !rel) continue;
+      const abs = resolve(depDir, rel);
+      if (existsSync(abs)) out.push(abs);
+      else console.warn(`[rip] ${dep} declares ambient '${rel}' but it was not found, skipping`);
+    }
+  }
+  return out;
+}
+
+// Locate a dependency's package.json. Prefer Node/Bun module resolution
+// (`require.resolve('<dep>/package.json')`); fall back to walking node_modules up
+// from the project root — robust against `exports` maps that don't list
+// `./package.json`, and against either runtime (CLI/Bun or the LSP/Node).
+function resolveDepPackageJson(dep, rootPath, req) {
+  try {
+    const r = req.resolve(`${dep}/package.json`);
+    if (typeof r === 'string' && existsSync(r)) return r;
+  } catch {}
+  let dir = resolve(rootPath);
+  while (true) {
+    const cand = resolve(dir, 'node_modules', dep, 'package.json');
+    if (existsSync(cand)) return cand;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
 // ── CLI batch type-checker ─────────────────────────────────────────
 
 // Convert a simple glob pattern to a RegExp for matching relative paths.
@@ -3602,6 +3724,7 @@ export async function runCheck(targetDir, opts = {}) {
   const checkAll = ripConfig.checkAll === true;
   const excludeGlobs = Array.isArray(ripConfig.exclude) ? ripConfig.exclude : [];
   const excludePatterns = excludeGlobs.map(globToRegex);
+  const typeIncludes = resolveTypeIncludes(ripConfig, rootPath);
 
   const allFiles = findRipFiles(rootPath, [], excludePatterns);
   if (allFiles.length === 0) {
@@ -3875,7 +3998,7 @@ export async function runCheck(targetDir, opts = {}) {
   });
 
   const host = {
-    getScriptFileNames: () => [...compiled.keys()].map(toVirtual),
+    getScriptFileNames: () => [...[...compiled.keys()].map(toVirtual), ...typeIncludes],
     getScriptVersion: () => '1',
     getScriptSnapshot(f) {
       const c = compiled.get(fromVirtual(f));
@@ -4071,11 +4194,11 @@ export async function runCheck(targetDir, opts = {}) {
       }
     }
 
-    // Untyped component prop checking — flag props without :: annotation
+    // Component prop checking — validate prop default values against their types
     if (entry.dts) {
-      for (const [compName, compInfo] of parseComponentDTS(entry.dts)) {
+      for (const [, compInfo] of parseComponentDTS(entry.dts)) {
         for (const e of checkComponentDefs(compInfo.props, srcLines)) {
-          errors.push({ line: e.line + 1, col: e.col + 1, len: e.len, message: e.message.includes('type annotation') ? `Prop '${e.propName}' on component ${compName} has no type annotation` : e.message, severity: 'error', code: 'rip', srcLine: srcLines[e.line], related: [] });
+          errors.push({ line: e.line + 1, col: e.col + 1, len: e.len, message: e.message, severity: 'error', code: 'rip', srcLine: srcLines[e.line], related: [] });
           totalErrors++;
         }
       }
@@ -4663,6 +4786,7 @@ export async function runAudit(targetDir) {
   }
 
   const { typeRoots, types: ambientTypes } = collectAmbientTypes(rootPath);
+  const typeIncludes = resolveTypeIncludes(pkg.rip, rootPath);
   const settings = createTypeCheckSettings(ts, {
     strict: true,
     ...(typeRoots.length    ? { typeRoots }              : {}),
@@ -4670,7 +4794,7 @@ export async function runAudit(targetDir) {
   });
 
   const host = {
-    getScriptFileNames: () => [...compiled.keys()].map(toVirtual),
+    getScriptFileNames: () => [...[...compiled.keys()].map(toVirtual), ...typeIncludes],
     getScriptVersion:   () => '1',
     getScriptSnapshot(f) {
       const c = compiled.get(fromVirtual(f));

package/src/types.js

@@ -14,6 +14,44 @@
 
 import { RipError } from './error.js';
 
+// ============================================================================
+// `expr as Type` cast — recognition sets
+// ============================================================================
+//
+// The cast is a contextual postfix operator: a bare `as` (already an
+// IDENTIFIER here — the lexer emits AS / FORAS / FORASAWAIT for the
+// import/export and for-loop cases, so an `as` that survives as an
+// IDENTIFIER is never one of those) glued to a value on its left and a type
+// on its right. We recognize it purely from token shape: the previous token
+// must be able to END an expression, and the next must be able to START a
+// type. Detection runs in rewriteTypes(), BEFORE addImplicitBracesAndParens(),
+// so `x as Foo` is still three bare identifiers (not yet `x(as(Foo))`).
+
+// Tokens whose token can be the tail of the cast's left-hand expression.
+// CAST is included so chains (`x as A as B`) work: the first cast collapses
+// to `<value> CAST`, and the second `as` sees CAST as its left edge.
+const CAST_LHS_ENDERS = new Set([
+  'IDENTIFIER', 'PROPERTY', 'NUMBER', 'STRING', 'STRING_END',
+  'REGEX', 'REGEX_END', 'BOOL', 'NULL', 'UNDEFINED', 'INFINITY', 'NAN', 'JS',
+  ')', 'CALL_END', 'PARAM_END', ']', 'INDEX_END', '}',
+  'THIS', 'SUPER', '?', 'PRESENCE', 'CAST',
+]);
+
+// Tokens that can begin a type expression on the cast's right-hand side.
+const CAST_TYPE_STARTERS = new Set([
+  'IDENTIFIER', '(', 'CALL_START', 'PARAM_START', '{', '[', 'INDEX_START',
+  'STRING', 'STRING_START', 'NUMBER', 'BOOL', 'NULL', 'UNDEFINED', '-', 'UNARY',
+]);
+
+// Does the `as` token at index i look like a cast (vs. a stray identifier)?
+function isCastAs(tokens, i) {
+  let prev = tokens[i - 1];
+  if (!prev || prev[0] === '.' || prev[0] === '?.') return false;
+  if (!CAST_LHS_ENDERS.has(prev[0])) return false;
+  let next = tokens[i + 1];
+  return !!next && CAST_TYPE_STARTERS.has(next[0]);
+}
+
 // ============================================================================
 // installTypeSupport — adds rewriteTypes() to Lexer.prototype
 // ============================================================================
@@ -60,6 +98,45 @@ export function installTypeSupport(Lexer) {
     this.scanTokens((token, i, tokens) => {
       let tag = token[0];
 
+      // ── `expr as Type` cast — postfix type assertion (route A) ──────────
+      // A bare `as` glued to a value on its left and a type on its right. The
+      // Type RHS is collected as a string (the same machinery as `::`
+      // annotations) and the whole `as Type` run COLLAPSES into a single
+      // in-stream CAST marker token carrying that string as its value. The
+      // grammar reduces `Expression CAST` to `['cast', expr, typeStr]` — so
+      // the parser sees a structural postfix node (like `?`/`!`) but never a
+      // type. The compiler erases it at runtime and re-materializes it as a
+      // real TS `(expr as Type)` only in the shadow-TS check path. Because the
+      // marker is a real token, the reduction fires AFTER the full postfix
+      // expression is built, so call/index/paren results narrow too.
+      // Chaining (`x as A as B`) emits one CAST per `as` (`x CAST CAST`); the
+      // grammar's left-associativity nests them: `['cast',['cast',x,'A'],'B']`.
+      if (tag === 'IDENTIFIER' && token[1] === 'as' && !token.data?.bang &&
+          isCastAs(tokens, i)) {
+        let typeTokens = collectTypeExpression(tokens, i + 1, { castContext: true });
+        if (typeTokens.length > 0) {
+          let typeStr = buildTypeString(typeTokens);
+          for (let tt of typeTokens) {
+            if (tt[0] === 'IDENTIFIER') typeRefNames.add(tt[1]);
+          }
+          let castTok = gen('CAST', typeStr, token);
+          tokens.splice(i, 1 + typeTokens.consumed, castTok);
+          // A trailing `>` (or other "unfinished" tail) makes the lexer
+          // suppress the newline after the type, so once the `as Type` run is
+          // collapsed the statement can collide with the next line. If what now
+          // follows the marker sits on a later row and isn't already a
+          // separator, restore the TERMINATOR the lexer ate.
+          let follow = tokens[i + 1];
+          if (follow && follow[0] !== 'TERMINATOR' && follow[0] !== 'INDENT' &&
+              follow[0] !== 'CAST' &&
+              follow.loc?.r != null && castTok.loc?.r != null &&
+              follow.loc.r > castTok.loc.r) {
+            tokens.splice(i + 1, 0, gen('TERMINATOR', '\n', follow));
+          }
+          return 1; // advance past the CAST marker (a chained `as` follows it)
+        }
+      }
+
       // ── Generic type parameters: DEF name<T>(...) or Name<T> = component ──
       // (Generic params on type aliases are handled by the `type` keyword handler below)
       if (tag === 'IDENTIFIER') {
@@ -595,6 +672,38 @@ function reclassifyColonTypes(tokens) {
     return atStatementStart(tokens[i - 2]);
   };
 
+  // Is this top-level `=` the assignment of a `type Name [<generics>] =`
+  // declaration? Its RHS is a whole type expression, so we arm `inType` there —
+  // otherwise a braced type literal RHS (`type X = { f: (e: Event) => void }`,
+  // incl. intersections `… & { … }`) reaches the field colon at bracket-depth
+  // ≥ 1, where none of the `:`-reclassify branches (all `stack.length === 0`)
+  // fire, so `inType` is never armed and the function-type's `(e: Event)` param
+  // is wrongly reclassified — putting a synthetic `::` inside a structural type
+  // literal. Mirrors `isDefParamStart`'s backward generic skip. (The indented
+  // `type T =` ⏎ INDENT form is unaffected: it disarms `inType` at the INDENT
+  // and is collected per-field by `collectStructuralType`.)
+  const isTypeDeclEq = (i) => {
+    let j = i - 1;
+    const g0 = tokens[j]?.[0], v0 = tokens[j]?.[1];
+    if ((g0 === 'COMPARE' && v0 === '>') || (g0 === 'SHIFT' && v0 === '>>')) {
+      let depth = g0 === 'SHIFT' ? 2 : 1;
+      j--;
+      while (j >= 0 && depth > 0) {
+        const g = tokens[j][0], v = tokens[j][1];
+        if (g === 'COMPARE' && v === '>') depth++;
+        else if (g === 'SHIFT' && v === '>>') depth += 2;
+        else if (g === 'COMPARE' && v === '<') depth--;
+        else if (g === 'SHIFT' && v === '<<') depth -= 2;
+        j--;
+      }
+    }
+    // tokens[j] is the type name, preceded by the `type` contextual keyword at
+    // a statement boundary (the same shape the `type Name =` collector matches).
+    if (tokens[j]?.[0] !== 'IDENTIFIER') return false;
+    if (!(tokens[j - 1]?.[0] === 'IDENTIFIER' && tokens[j - 1]?.[1] === 'type')) return false;
+    return atStatementStart(tokens[j - 2]);
+  };
+
   // A type expression (opened by any `::` / TYPE_ANNOTATION, or by a `:` we
   // reclassify) must never have its interior touched: a function type like
   // `{ cb: (r: R) => void }` carries single `:` colons that are TS member/param
@@ -660,6 +769,16 @@ function reclassifyColonTypes(tokens) {
     // Commit per-line key:value state at statement boundaries (depth 0).
     if (tag === 'TERMINATOR' && stack.length === 0) { prevSiblingKV = curLineKV; curLineKV = false; }
 
+    // Type-alias RHS: `type Name [<generics>] = <type>`. The whole RHS is a
+    // type expression — arm `inType` so its interior colons (a braced literal's
+    // field `:`, a function-type param's `:`) are left as TS separators rather
+    // than reclassified. Disarms at the RHS terminator / on exiting its depth,
+    // like every other `enterType`. A value-position `=` (`x = { a: 1 }`) is not
+    // a type decl, so `isTypeDeclEq` rejects it and object literals stay intact.
+    if (tag === '=' && stack.length === 0 && !inType && isTypeDeclEq(i)) {
+      enterType(); continue;
+    }
+
     if (tag === ':') {
       const prev = tokens[i - 1];
       const prevTag = prev?.[0];
@@ -829,6 +948,25 @@ function collectTypeExpression(tokens, j, opts = {}) {
       break;
     }
 
+    // Cast context: a cast's type lives on one logical line, but the lexer
+    // suppresses the newline after a trailing `>` (a COMPARE token is
+    // "unfinished"), so no TERMINATOR separates `x as Map<K, V>` from the next
+    // statement. Stop at a depth-0 row change so the collector can't run past
+    // end-of-line into the following code (the `Map<K, V> nextStmt` footgun).
+    if (opts.castContext && depth === 0 && j > startJ) {
+      let prevRow = tokens[j - 1]?.loc?.r;
+      let curRow = t.loc?.r;
+      if (prevRow != null && curRow != null && curRow > prevRow) break;
+    }
+
+    // Cast context: a chained cast (`x as A as B`) — the type RHS is just `A`;
+    // the second `as` starts a new cast on the result. Stop here so each `as`
+    // becomes its own CAST marker and the grammar nests them left-to-right.
+    // (`as` never appears inside a real type expression, so this is safe.)
+    if (opts.castContext && depth === 0 && tTag === 'IDENTIFIER' && t[1] === 'as') {
+      break;
+    }
+
     // Delimiters that end the type at depth 0
     if (depth === 0) {
       // Arrow-return context: a depth-0 `=>` is the arrow OPERATOR, so it ends
@@ -855,6 +993,21 @@ function collectTypeExpression(tokens, j, opts = {}) {
           tTag === '->' || tTag === ',') {
         break;
       }
+      // Cast context (`expr as Type`): the type RHS lives inside a larger
+      // expression, so it must also end at any depth-0 binary/relational/
+      // ternary operator. `|` and `&` are NOT stops — they're union /
+      // intersection type operators (TS reads everything after `as` as a
+      // type, so `x as A & B` is `x as (A & B)`). COMPARE's `<`/`>` never
+      // reach here (handled as generic brackets above), leaving only
+      // `== != <= >=`, which do stop.
+      if (opts.castContext && (
+          tTag === '+' || tTag === '-' || tTag === 'MATH' || tTag === '**' ||
+          tTag === 'SHIFT' || tTag === 'COMPARE' || tTag === '&&' ||
+          tTag === '||' || tTag === '??' || tTag === '^' ||
+          tTag === 'RELATION' || tTag === 'TERNARY' || tTag === '?' ||
+          tTag === 'PRESENCE' || tTag === ':')) {
+        break;
+      }
     }
 
     // Inside a bracketed type expression, INDENT/OUTDENT/TERMINATOR are