unguard 0.15.0 → 0.15.1

package/dist/{chunk-XCFM224P.js → chunk-VHRD75ET.js}

@@ -4,6 +4,7 @@ var deadOverload = {
   id: "dead-overload",
   severity: "warning",
   message: "Overload signature has no matching call sites in the project",
+  requires: ["files", "callSites", "overloadCallSignatures"],
   analyze(project) {
     const diagnostics = [];
     for (const [file, { sourceFile }] of project.files) {
@@ -173,9 +174,10 @@ function normalizeText(text) {
 function isTSRule(r) {
   return "kind" in r && r.kind === "ts";
 }
-function reportDuplicateGroup(group, ruleId, severity, formatOther, formatMessage, diagnostics) {
+function reportDuplicateGroup(group, ruleId, severity, formatOther, formatMessage, diagnostics, context) {
   const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-  for (const entry of sorted.slice(1)) {
+  const entries = selectDuplicateReportEntries(sorted, context.reportableFiles);
+  for (const entry of entries) {
     const others = sorted.filter((e) => e !== entry).map(formatOther).join(", ");
     diagnostics.push({
       ruleId,
@@ -187,13 +189,28 @@ function reportDuplicateGroup(group, ruleId, severity, formatOther, formatMessag
     });
   }
 }
+function selectReportTarget(group, reportableFiles) {
+  const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  if (reportableFiles === void 0) return sorted[0];
+  return sorted.find((entry) => reportableFiles.has(entry.file));
+}
+function selectDuplicateReportEntries(sorted, reportableFiles) {
+  const defaultEntries = sorted.slice(1);
+  if (reportableFiles === void 0) return defaultEntries;
+  const reportableDefaultEntries = defaultEntries.filter((entry) => reportableFiles.has(entry.file));
+  if (reportableDefaultEntries.length > 0) return reportableDefaultEntries;
+  const first = sorted[0];
+  if (first !== void 0 && sorted.length > 1 && reportableFiles.has(first.file)) return [first];
+  return [];
+}
 
 // src/rules/cross-file/duplicate-constant-declaration.ts
 var duplicateConstantDeclaration = {
   id: "duplicate-constant-declaration",
   severity: "warning",
   message: "Identical constant value declared in multiple files; consolidate to a single definition",
-  analyze(project) {
+  requires: ["constants"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.constants.getDuplicateGroups()) {
       const files = new Set(group.map((e) => e.file));
@@ -205,7 +222,8 @@ var duplicateConstantDeclaration = {
         this.severity,
         (e) => `${e.name} (${e.file}:${e.line})`,
         (e, others) => `Constant "${e.name}" has identical value \`${e.valueText}\` to: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -214,9 +232,13 @@ var duplicateConstantDeclaration = {
 function hasNameOverlap(group) {
   const segmentSets = group.map((e) => nameSegments(e.name));
   for (let i = 0; i < segmentSets.length; i++) {
+    const left = segmentSets[i];
+    if (left === void 0) continue;
     for (let j = i + 1; j < segmentSets.length; j++) {
-      for (const seg of segmentSets[i]) {
-        if (segmentSets[j].has(seg)) return true;
+      const right = segmentSets[j];
+      if (right === void 0) continue;
+      for (const seg of left) {
+        if (right.has(seg)) return true;
       }
     }
   }
@@ -238,22 +260,21 @@ var duplicateFile = {
   id: "duplicate-file",
   severity: "warning",
   message: "File has identical content to another file; one is likely dead code",
-  analyze(project) {
+  requires: ["fileHashes"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const files of project.fileHashes.values()) {
       if (files.length < 2) continue;
-      const sorted = [...files].sort();
-      for (const file of sorted.slice(1)) {
-        const others = sorted.filter((f) => f !== file).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `File is identical to: ${others}`,
-          file,
-          line: 1,
-          column: 1
-        });
-      }
+      const group = files.map((file) => ({ file, line: 1 }));
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (entry) => entry.file,
+        (_entry, others) => `File is identical to: ${others}`,
+        diagnostics,
+        context
+      );
     }
     return diagnostics;
   }
@@ -265,7 +286,8 @@ var duplicateFunctionDeclaration = {
   id: "duplicate-function-declaration",
   severity: "warning",
   message: "Identical function body declared in multiple files; consolidate to a single definition",
-  analyze(project) {
+  requires: ["functions"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.functions.getDuplicateGroups()) {
       const first = group[0];
@@ -278,7 +300,8 @@ var duplicateFunctionDeclaration = {
         this.severity,
         (e) => `${e.name} (${e.file}:${e.line})`,
         (e, others) => `Function "${e.name}" has identical body to: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -310,7 +333,8 @@ var duplicateFunctionName = {
   id: "duplicate-function-name",
   severity: "warning",
   message: "Same function name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
+  requires: ["functions", "imports"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.functions.getNameCollisionGroups()) {
       const hashes = new Set(group.map((e) => e.hash));
@@ -342,7 +366,8 @@ var duplicateFunctionName = {
         this.severity,
         (e) => `${e.file}:${e.line}`,
         (e, others) => `Exported function "${e.name}" also defined in: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -363,7 +388,8 @@ var duplicateInlineTypeInParams = {
   id: "duplicate-inline-type-in-params",
   severity: "warning",
   message: "Same inline param type shape appears in multiple places; extract to a shared named type",
-  analyze(project) {
+  requires: ["inlineParamTypes"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.inlineParamTypes.getDuplicateGroups()) {
       reportDuplicateGroup(
@@ -372,7 +398,8 @@ var duplicateInlineTypeInParams = {
         this.severity,
         (e) => `${e.typeText} (${e.file}:${e.line})`,
         (e, others) => `Inline param type \`${e.typeText}\` also appears at: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -384,7 +411,8 @@ var duplicateStatementSequence = {
   id: "duplicate-statement-sequence",
   severity: "info",
   message: "Repeated statement sequence; consider extracting to a shared helper",
-  analyze(project) {
+  requires: ["statementSequences"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     const MIN_NORMALIZED_BODY = 128;
     for (const group of project.statementSequences.getNormalizedDuplicateGroups()) {
@@ -399,18 +427,15 @@ var duplicateStatementSequence = {
       }
       const deduped = [...byLocation.values()];
       if (deduped.length < 2) continue;
-      const sorted = deduped.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.file}:${e.line}`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Statement sequence (${entry.statementCount} statements) duplicated at: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
-      }
+      reportDuplicateGroup(
+        deduped,
+        this.id,
+        this.severity,
+        (entry) => `${entry.file}:${entry.line}`,
+        (entry, others) => `Statement sequence (${entry.statementCount} statements) duplicated at: ${others}`,
+        diagnostics,
+        context
+      );
     }
     return diagnostics;
   }
@@ -422,7 +447,8 @@ var duplicateTypeDeclaration = {
   id: "duplicate-type-declaration",
   severity: "warning",
   message: "Identical type shape declared in multiple files; consolidate to a single definition",
-  analyze(project) {
+  requires: ["types"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.types.getDuplicateGroups()) {
       const files = new Set(group.map((e) => e.file));
@@ -434,7 +460,8 @@ var duplicateTypeDeclaration = {
         this.severity,
         (e) => `${e.name} (${e.file}:${e.line})`,
         (e, others) => `Type "${e.name}" has identical shape to: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -452,7 +479,8 @@ var duplicateTypeName = {
   id: "duplicate-type-name",
   severity: "warning",
   message: "Same type name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
+  requires: ["types"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.types.getNameCollisionGroups()) {
       const hashes = new Set(group.map((e) => e.hash));
@@ -467,7 +495,8 @@ var duplicateTypeName = {
         this.severity,
         (e) => `${e.file}:${e.line}`,
         (e, others) => `Exported type "${e.name}" also defined in: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -535,6 +564,7 @@ var explicitNullArg = {
   id: "explicit-null-arg",
   severity: "warning",
   message: "Explicit null/undefined passed to a project function; consider redesigning the interface to not accept nullish values",
+  requires: ["functions", "functionSymbols", "callSites", "callSiteSymbols"],
   analyze(project) {
     const diagnostics = [];
     const projectFnNames = /* @__PURE__ */ new Set();
@@ -573,7 +603,8 @@ var nearDuplicateFunction = {
   id: "near-duplicate-function",
   severity: "warning",
   message: "Near-duplicate function bodies across files; consider parameterizing",
-  analyze(project) {
+  requires: ["functions"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     for (const group of project.functions.getNearDuplicateGroups()) {
       const MIN_NORMALIZED_BODY = 32;
@@ -585,7 +616,8 @@ var nearDuplicateFunction = {
         this.severity,
         (e) => `${e.name} (${e.file}:${e.line})`,
         (e, others) => `Function "${e.name}" is near-duplicate of: ${others}`,
-        diagnostics
+        diagnostics,
+        context
       );
     }
     return diagnostics;
@@ -626,6 +658,7 @@ var optionalArgAlwaysUsed = {
   id: "optional-arg-always-used",
   severity: "warning",
   message: "Optional parameter is always provided at every call site; make it required",
+  requires: ["functions", "functionSymbols", "callSites", "callSiteSymbols"],
   analyze(project) {
     const diagnostics = [];
     for (const fn of project.functions.getAll()) {
@@ -659,6 +692,7 @@ var repeatedLiteralProperty = {
   id: "repeated-literal-property",
   severity: "warning",
   message: "Repeated literal value in object properties; consider extracting a constant or factory",
+  requires: ["files"],
   analyze(project) {
     const diagnostics = [];
     for (const [file, { sourceFile }] of project.files) {
@@ -772,7 +806,8 @@ var repeatedReturnShape = {
   id: "repeated-return-shape",
   severity: "warning",
   message: "Multiple functions return the same object shape; consider a shared return type",
-  analyze(project) {
+  requires: ["files", "types"],
+  analyze(project, context = {}) {
     const diagnostics = [];
     const THRESHOLD = 3;
     const shapeMap = /* @__PURE__ */ new Map();
@@ -803,15 +838,15 @@ var repeatedReturnShape = {
       const uniqueFiles = new Set(unique.map((e) => e.file));
       if (uniqueFiles.size < 2) continue;
       const sorted = unique.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      const first = sorted[0];
-      if (first === void 0) continue;
-      const others = sorted.slice(1).map((e) => `${e.functionName} (${e.file}:${e.line})`).join(", ");
+      const target = selectReportTarget(sorted, context.reportableFiles);
+      if (target === void 0) continue;
+      const others = sorted.filter((e) => e !== target).map((e) => `${e.functionName} (${e.file}:${e.line})`).join(", ");
       diagnostics.push({
         ruleId: this.id,
         severity: this.severity,
-        message: `${unique.length} functions return shape {${first.props.join(", ")}}; consider a shared return type (${others})`,
-        file: first.file,
-        line: first.line,
+        message: `${unique.length} functions return shape {${target.props.join(", ")}}; consider a shared return type (${others})`,
+        file: target.file,
+        line: target.line,
         column: 1
       });
     }
@@ -967,6 +1002,7 @@ var trivialWrapper = {
   id: "trivial-wrapper",
   severity: "info",
   message: "Function is a trivial wrapper that delegates without transformation; consider using the target directly",
+  requires: ["functions"],
   analyze(project) {
     const diagnostics = [];
     const knownFunctions = new Set(
@@ -995,6 +1031,7 @@ var unusedExport = {
   id: "unused-export",
   severity: "info",
   message: "Exported function has no usages within the project",
+  requires: ["functions", "functionSymbols", "callSites", "callSiteSymbols", "imports"],
   analyze(project) {
     const diagnostics = [];
     const usedDeclarations = /* @__PURE__ */ new Set();
@@ -1072,6 +1109,8 @@ var noAnyCast = {
   id: "no-any-cast",
   severity: "error",
   message: "Casting to `any` erases type safety; use a specific type or generic instead",
+  syntaxKinds: [ts12.SyntaxKind.AsExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (!ts12.isAsExpression(node)) return;
     if (node.type.kind !== ts12.SyntaxKind.AnyKeyword) return;
@@ -1086,12 +1125,13 @@ var noAwaitCoalesce = {
   id: "no-await-coalesce",
   severity: "warning",
   message: "?? on a value whose nullability comes from a call's return type collapses failure modes; check the result and branch instead of defaulting",
+  syntaxKinds: [ts13.SyntaxKind.BinaryExpression],
   visit(node, ctx) {
     if (!ts13.isBinaryExpression(node)) return;
     if (node.operatorToken.kind !== ts13.SyntaxKind.QuestionQuestionToken) return;
     const walk = walkLeftChain(node.left);
     if (!walk || !walk.call) return;
-    const sig = ctx.checker.getResolvedSignature(walk.call);
+    const sig = ctx.semantics.resolvedSignature(walk.call);
     if (!sig) return;
     const declSourceFile = sig.declaration?.getSourceFile();
     if (declSourceFile && (declSourceFile.isDeclarationFile || declSourceFile.fileName.includes("/node_modules/"))) {
@@ -1099,7 +1139,7 @@ var noAwaitCoalesce = {
     }
     let returnType = sig.getReturnType();
     if (walk.awaited) {
-      const awaitedType = ctx.checker.getAwaitedType(returnType);
+      const awaitedType = ctx.semantics.awaitedType(returnType);
       if (awaitedType) returnType = awaitedType;
     }
     const includesNull = typeIncludes(returnType, ts13.TypeFlags.Null);
@@ -1156,6 +1196,8 @@ var noCoalesceThenGuard = {
   id: "no-coalesce-then-guard",
   severity: "warning",
   message: "?? fallback fuses with subsequent guard; the partition is identical to checking the original value directly",
+  syntaxKinds: [ts14.SyntaxKind.BinaryExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (!ts14.isBinaryExpression(node)) return;
     if (node.operatorToken.kind !== ts14.SyntaxKind.QuestionQuestionToken) return;
@@ -1282,6 +1324,7 @@ var noDefaultedRequiredPortArg = {
   id: "no-defaulted-required-port-arg",
   severity: "warning",
   message: "Default value on a parameter the implemented interface declares required; the implementation widens the contract \u2014 drop the default or change the interface",
+  syntaxKinds: [ts15.SyntaxKind.MethodDeclaration],
   visit(node, ctx) {
     if (!ts15.isMethodDeclaration(node)) return;
     if (!ts15.isIdentifier(node.name)) return;
@@ -1310,6 +1353,7 @@ function isParamRequired(sig, paramIndex) {
 }
 function resolveImplementedSignatures(method, ctx) {
   const signatures = [];
+  if (!ts15.isIdentifier(method.name)) return signatures;
   const methodName = method.name.text;
   const parent = method.parent;
   if (ts15.isClassDeclaration(parent) || ts15.isClassExpression(parent)) {
@@ -1320,7 +1364,7 @@ function resolveImplementedSignatures(method, ctx) {
       }
     }
   } else if (ts15.isObjectLiteralExpression(parent)) {
-    const contextualType = ctx.checker.getContextualType(parent);
+    const contextualType = ctx.semantics.contextualType(parent);
     if (contextualType) {
       collectSignaturesFromType(contextualType, methodName, parent, ctx, signatures);
     }
@@ -1328,13 +1372,13 @@ function resolveImplementedSignatures(method, ctx) {
   return signatures;
 }
 function collectSignatures(typeNode, methodName, ctx, out) {
-  const t = ctx.checker.getTypeAtLocation(typeNode);
+  const t = ctx.semantics.typeAtLocation(typeNode);
   collectSignaturesFromType(t, methodName, typeNode, ctx, out);
 }
 function collectSignaturesFromType(type, methodName, location, ctx, out) {
   const prop = type.getProperty(methodName);
   if (!prop) return;
-  const propType = ctx.checker.getTypeOfSymbolAtLocation(prop, location);
+  const propType = ctx.semantics.typeOfSymbolAtLocation(prop, location);
   for (const sig of propType.getCallSignatures()) {
     out.push(sig);
   }
@@ -1347,6 +1391,7 @@ var noDoubleNegationCoercion = {
   id: "no-double-negation-coercion",
   severity: "info",
   message: "!! coercion hides intent; use an explicit check (!== null, !== undefined, .length > 0) so the condition documents what it tests",
+  syntaxKinds: [ts16.SyntaxKind.PrefixUnaryExpression],
   visit(node, ctx) {
     if (!ts16.isPrefixUnaryExpression(node)) return;
     if (node.operator !== ts16.SyntaxKind.ExclamationToken) return;
@@ -1354,7 +1399,7 @@ var noDoubleNegationCoercion = {
     if (!ts16.isPrefixUnaryExpression(inner)) return;
     if (inner.operator !== ts16.SyntaxKind.ExclamationToken) return;
     const operand = inner.operand;
-    const innerType = ctx.checker.getTypeAtLocation(operand);
+    const innerType = ctx.semantics.typeAtLocation(operand);
     if (includesBooleanType(innerType) && !(innerType.flags & ts16.TypeFlags.Union)) {
       ctx.report(node, "!! on an already-boolean type is a no-op; remove the double negation");
       return;
@@ -1384,6 +1429,8 @@ var noDynamicImport = {
   id: "no-dynamic-import",
   severity: "error",
   message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
+  syntaxKinds: [ts17.SyntaxKind.CallExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (!ts17.isCallExpression(node)) return;
     if (node.expression.kind !== ts17.SyntaxKind.ImportKeyword) return;
@@ -1398,6 +1445,8 @@ var noErrorRewrap = {
   id: "no-error-rewrap",
   severity: "error",
   message: "Re-wrapped error loses the original stack trace and type; use { cause: originalError } to preserve the error chain",
+  syntaxKinds: [ts18.SyntaxKind.CatchClause],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (!ts18.isCatchClause(node)) return;
     if (!node.variableDeclaration) return;
@@ -1450,6 +1499,8 @@ var noExplicitAnyAnnotation = {
   id: "no-explicit-any-annotation",
   severity: "error",
   message: "Explicit `any` annotation erases type safety; use a specific type, `unknown`, or a generic",
+  syntaxKinds: [ts19.SyntaxKind.AnyKeyword],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (node.kind !== ts19.SyntaxKind.AnyKeyword) return;
     if (node.parent && ts19.isAsExpression(node.parent)) return;
@@ -1458,25 +1509,28 @@ var noExplicitAnyAnnotation = {
 };
 
 // src/rules/ts/no-inline-param-type.ts
+import * as ts20 from "typescript";
 var noInlineParamType = {
   kind: "ts",
   id: "no-inline-param-type",
   severity: "warning",
   message: "Inline object type on parameter; extract to a named type",
+  syntaxKinds: [ts20.SyntaxKind.TypeLiteral],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     if (isInlineParamType(node)) ctx.report(node);
   }
 };
 
 // src/rules/ts/no-inline-type-assertion.ts
-import * as ts20 from "typescript";
+import * as ts21 from "typescript";
 function containsTypeLiteral(type) {
-  if (ts20.isTypeLiteralNode(type)) return true;
-  if (ts20.isArrayTypeNode(type)) return containsTypeLiteral(type.elementType);
-  if (ts20.isTypeReferenceNode(type) && type.typeArguments) {
+  if (ts21.isTypeLiteralNode(type)) return true;
+  if (ts21.isArrayTypeNode(type)) return containsTypeLiteral(type.elementType);
+  if (ts21.isTypeReferenceNode(type) && type.typeArguments) {
     return type.typeArguments.some(containsTypeLiteral);
   }
-  if (ts20.isTypeOperatorNode(type)) return containsTypeLiteral(type.type);
+  if (ts21.isTypeOperatorNode(type)) return containsTypeLiteral(type.type);
   return false;
 }
 var noInlineTypeAssertion = {
@@ -1484,127 +1538,134 @@ var noInlineTypeAssertion = {
   id: "no-inline-type-assertion",
   severity: "error",
   message: "Type assertion contains inline object type; extract a named type or fix the upstream type",
+  syntaxKinds: [ts21.SyntaxKind.AsExpression, ts21.SyntaxKind.TypeAssertionExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
-    if (ts20.isAsExpression(node) && containsTypeLiteral(node.type)) {
+    if (ts21.isAsExpression(node) && containsTypeLiteral(node.type)) {
       ctx.report(node);
       return;
     }
-    if (ts20.isTypeAssertionExpression(node) && containsTypeLiteral(node.type)) {
+    if (ts21.isTypeAssertionExpression(node) && containsTypeLiteral(node.type)) {
       ctx.report(node);
     }
   }
 };
 
 // src/rules/ts/no-never-cast.ts
-import * as ts21 from "typescript";
+import * as ts22 from "typescript";
 var noNeverCast = {
   kind: "ts",
   id: "no-never-cast",
   severity: "warning",
   message: "Casting to `never` silences the type checker completely; use a specific type or a type guard",
+  syntaxKinds: [ts22.SyntaxKind.AsExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
-    if (!ts21.isAsExpression(node)) return;
-    if (node.type.kind !== ts21.SyntaxKind.NeverKeyword) return;
+    if (!ts22.isAsExpression(node)) return;
+    if (node.type.kind !== ts22.SyntaxKind.NeverKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/no-redundant-cast.ts
-import * as ts22 from "typescript";
+import * as ts23 from "typescript";
 var noRedundantCast = {
   kind: "ts",
   id: "no-redundant-cast",
   severity: "error",
   message: "Type assertion is redundant; the expression already has this type",
+  syntaxKinds: [ts23.SyntaxKind.AsExpression],
   visit(node, ctx) {
-    if (!ts22.isAsExpression(node)) return;
-    if (ts22.isTypeReferenceNode(node.type) && node.type.getText(ctx.sourceFile).trim() === "const") {
+    if (!ts23.isAsExpression(node)) return;
+    if (ts23.isTypeReferenceNode(node.type) && node.type.getText(ctx.sourceFile).trim() === "const") {
       return;
     }
-    const exprType = ctx.checker.getTypeAtLocation(node.expression);
-    if (exprType.flags & ts22.TypeFlags.Any) return;
-    const targetType = ctx.checker.getTypeFromTypeNode(node.type);
-    if (ctx.checker.isTypeAssignableTo(exprType, targetType) && ctx.checker.isTypeAssignableTo(targetType, exprType)) {
+    const exprType = ctx.semantics.typeAtLocation(node.expression);
+    if (exprType.flags & ts23.TypeFlags.Any) return;
+    const targetType = ctx.semantics.typeFromTypeNode(node.type);
+    if (ctx.semantics.isTypeAssignableTo(exprType, targetType) && ctx.semantics.isTypeAssignableTo(targetType, exprType)) {
       ctx.report(node);
     }
   }
 };
 
 // src/rules/ts/no-unvalidated-cast.ts
-import * as ts23 from "typescript";
+import * as ts24 from "typescript";
 function isUntypedSource(type) {
-  if (type.flags & (ts23.TypeFlags.Any | ts23.TypeFlags.Unknown)) return true;
+  if (type.flags & (ts24.TypeFlags.Any | ts24.TypeFlags.Unknown)) return true;
   if (type.isUnion()) return type.types.some(isUntypedSource);
   if (type.isIntersection()) return type.types.some(isUntypedSource);
   return false;
 }
-function isPrimitiveFamily(type, checker) {
-  if (type.flags & (ts23.TypeFlags.String | ts23.TypeFlags.StringLiteral | ts23.TypeFlags.Number | ts23.TypeFlags.NumberLiteral | ts23.TypeFlags.Boolean | ts23.TypeFlags.BooleanLiteral | ts23.TypeFlags.BigInt | ts23.TypeFlags.BigIntLiteral | ts23.TypeFlags.ESSymbol | ts23.TypeFlags.UniqueESSymbol | ts23.TypeFlags.Void | ts23.TypeFlags.Undefined | ts23.TypeFlags.Null | ts23.TypeFlags.Never)) {
+function isPrimitiveFamily(type) {
+  if (type.flags & (ts24.TypeFlags.String | ts24.TypeFlags.StringLiteral | ts24.TypeFlags.Number | ts24.TypeFlags.NumberLiteral | ts24.TypeFlags.Boolean | ts24.TypeFlags.BooleanLiteral | ts24.TypeFlags.BigInt | ts24.TypeFlags.BigIntLiteral | ts24.TypeFlags.ESSymbol | ts24.TypeFlags.UniqueESSymbol | ts24.TypeFlags.Void | ts24.TypeFlags.Undefined | ts24.TypeFlags.Null | ts24.TypeFlags.Never)) {
     return true;
   }
   if (type.isIntersection()) {
-    return type.types.some((t) => isPrimitiveFamily(t, checker));
+    return type.types.some(isPrimitiveFamily);
   }
   if (type.isUnion()) {
-    return type.types.every((t) => isPrimitiveFamily(t, checker));
+    return type.types.every(isPrimitiveFamily);
   }
   return false;
 }
-function isConcreteTarget(type, checker) {
-  if (type.flags & (ts23.TypeFlags.Any | ts23.TypeFlags.Unknown | ts23.TypeFlags.Never | ts23.TypeFlags.Void | ts23.TypeFlags.Undefined | ts23.TypeFlags.Null | ts23.TypeFlags.TypeParameter | ts23.TypeFlags.NonPrimitive)) {
+function isConcreteTarget(type, semantics) {
+  if (type.flags & (ts24.TypeFlags.Any | ts24.TypeFlags.Unknown | ts24.TypeFlags.Never | ts24.TypeFlags.Void | ts24.TypeFlags.Undefined | ts24.TypeFlags.Null | ts24.TypeFlags.TypeParameter | ts24.TypeFlags.NonPrimitive)) {
     return false;
   }
-  if (isPrimitiveFamily(type, checker)) return false;
-  if (checker.isArrayType(type) || checker.isTupleType(type)) return true;
-  const apparent = checker.getApparentType(type);
+  if (isPrimitiveFamily(type)) return false;
+  if (semantics.isArrayType(type) || semantics.isTupleType(type)) return true;
+  const apparent = semantics.apparentType(type);
   if (apparent.getProperties().length > 0) return true;
   if (apparent.getStringIndexType() !== void 0) return true;
   if (apparent.getNumberIndexType() !== void 0) return true;
   if (type.isUnion()) {
-    return type.types.some((t) => isConcreteTarget(t, checker));
+    return type.types.some((t) => isConcreteTarget(t, semantics));
   }
   return false;
 }
 function isEmptyArrayLiteral(node) {
-  return ts23.isArrayLiteralExpression(node) && node.elements.length === 0;
+  return ts24.isArrayLiteralExpression(node) && node.elements.length === 0;
 }
 var noUnvalidatedCast = {
   kind: "ts",
   id: "no-unvalidated-cast",
   severity: "error",
   message: "Casting `any`/`unknown` to a concrete type without runtime validation fabricates structure; validate first or narrow with a type guard",
+  syntaxKinds: [ts24.SyntaxKind.AsExpression, ts24.SyntaxKind.TypeAssertionExpression],
   visit(node, ctx) {
-    if (!ts23.isAsExpression(node) && !ts23.isTypeAssertionExpression(node))
+    if (!ts24.isAsExpression(node) && !ts24.isTypeAssertionExpression(node))
       return;
-    if (ts23.isTypeReferenceNode(node.type) && node.type.getText(ctx.sourceFile).trim() === "const") {
+    if (ts24.isTypeReferenceNode(node.type) && node.type.getText(ctx.sourceFile).trim() === "const") {
       return;
     }
-    const expr = ts23.isParenthesizedExpression(node.expression) ? node.expression.expression : node.expression;
+    const expr = ts24.isParenthesizedExpression(node.expression) ? node.expression.expression : node.expression;
     if (isEmptyArrayLiteral(expr)) return;
-    const sourceType = ctx.checker.getTypeAtLocation(expr);
+    const sourceType = ctx.semantics.typeAtLocation(expr);
     if (!isUntypedSource(sourceType)) return;
-    const targetType = ctx.checker.getTypeFromTypeNode(node.type);
-    if (!isConcreteTarget(targetType, ctx.checker)) return;
+    const targetType = ctx.semantics.typeFromTypeNode(node.type);
+    if (!isConcreteTarget(targetType, ctx.semantics)) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/no-logical-or-fallback.ts
-import * as ts24 from "typescript";
+import * as ts25 from "typescript";
 var noLogicalOrFallback = {
   kind: "ts",
   id: "no-logical-or-fallback",
   severity: "warning",
   message: '|| fallback on a data-structure lookup swallows valid falsy values (0, ""); use ?? to only catch null/undefined',
+  syntaxKinds: [ts25.SyntaxKind.BinaryExpression],
   visit(node, ctx) {
-    if (!ts24.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts24.SyntaxKind.BarBarToken) return;
+    if (!ts25.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts25.SyntaxKind.BarBarToken) return;
     const right = node.right;
     if (!isLiteral(right)) return;
     const left = node.left;
-    const lhsType = ctx.checker.getTypeAtLocation(left);
+    const lhsType = ctx.semantics.typeAtLocation(left);
     if (isNumericCoercionCall(left)) return;
-    if (isStringNotNullable(lhsType, ctx.checker)) return;
+    if (isStringNotNullable(lhsType, ctx.semantics.checker)) return;
     if (includesNumberType(lhsType) && !isZeroLiteral(right)) {
       ctx.report(node, "|| on a numeric type swallows 0; use ?? to only catch null/undefined");
       return;
@@ -1617,59 +1678,60 @@ var noLogicalOrFallback = {
 function isStringNotNullable(type, checker) {
   if (isNullableType(checker, type)) return false;
   if (type.isUnion()) {
-    return type.types.every((t) => (t.flags & ts24.TypeFlags.StringLike) !== 0);
+    return type.types.every((t) => (t.flags & ts25.TypeFlags.StringLike) !== 0);
   }
-  return (type.flags & ts24.TypeFlags.StringLike) !== 0;
+  return (type.flags & ts25.TypeFlags.StringLike) !== 0;
 }
 function isLiteral(node) {
-  if (ts24.isStringLiteral(node) || ts24.isNumericLiteral(node) || ts24.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts24.isTemplateExpression(node)) return true;
-  if (ts24.isArrayLiteralExpression(node) || ts24.isObjectLiteralExpression(node)) return true;
-  if (ts24.isIdentifier(node) && node.text === "undefined") return true;
-  if (node.kind === ts24.SyntaxKind.NullKeyword) return true;
-  if (node.kind === ts24.SyntaxKind.TrueKeyword || node.kind === ts24.SyntaxKind.FalseKeyword) return true;
+  if (ts25.isStringLiteral(node) || ts25.isNumericLiteral(node) || ts25.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts25.isTemplateExpression(node)) return true;
+  if (ts25.isArrayLiteralExpression(node) || ts25.isObjectLiteralExpression(node)) return true;
+  if (ts25.isIdentifier(node) && node.text === "undefined") return true;
+  if (node.kind === ts25.SyntaxKind.NullKeyword) return true;
+  if (node.kind === ts25.SyntaxKind.TrueKeyword || node.kind === ts25.SyntaxKind.FalseKeyword) return true;
   return false;
 }
 function isNumericCoercionCall(node) {
-  if (!ts24.isCallExpression(node)) return false;
-  if (!ts24.isIdentifier(node.expression)) return false;
+  if (!ts25.isCallExpression(node)) return false;
+  if (!ts25.isIdentifier(node.expression)) return false;
   const name = node.expression.text;
   return name === "Number" || name === "parseInt" || name === "parseFloat";
 }
 function isZeroLiteral(node) {
-  return ts24.isNumericLiteral(node) && node.text === "0";
+  return ts25.isNumericLiteral(node) && node.text === "0";
 }
 function isDataStructureLookup(left) {
-  if (ts24.isCallExpression(left)) {
+  if (ts25.isCallExpression(left)) {
     const callee = left.expression;
-    if (ts24.isPropertyAccessExpression(callee)) {
+    if (ts25.isPropertyAccessExpression(callee)) {
       const methodName = callee.name.text;
       if (methodName === "find" || methodName === "getStore" || methodName === "get") return true;
     }
   }
-  if (ts24.isElementAccessExpression(left)) return true;
+  if (ts25.isElementAccessExpression(left)) return true;
   if (hasOptionalChaining(left)) return true;
   return false;
 }
 function hasOptionalChaining(node) {
-  if (ts24.isPropertyAccessExpression(node) && node.questionDotToken) return true;
-  if (ts24.isElementAccessExpression(node) && node.questionDotToken) return true;
-  if (ts24.isCallExpression(node) && node.questionDotToken) return true;
-  if (ts24.isPropertyAccessExpression(node)) return hasOptionalChaining(node.expression);
-  if (ts24.isCallExpression(node)) return hasOptionalChaining(node.expression);
-  if (ts24.isElementAccessExpression(node)) return hasOptionalChaining(node.expression);
+  if (ts25.isPropertyAccessExpression(node) && node.questionDotToken) return true;
+  if (ts25.isElementAccessExpression(node) && node.questionDotToken) return true;
+  if (ts25.isCallExpression(node) && node.questionDotToken) return true;
+  if (ts25.isPropertyAccessExpression(node)) return hasOptionalChaining(node.expression);
+  if (ts25.isCallExpression(node)) return hasOptionalChaining(node.expression);
+  if (ts25.isElementAccessExpression(node)) return hasOptionalChaining(node.expression);
   return false;
 }
 
 // src/rules/ts/no-non-null-assertion.ts
-import * as ts25 from "typescript";
+import * as ts26 from "typescript";
 var noNonNullAssertion = {
   kind: "ts",
   id: "no-non-null-assertion",
   severity: "warning",
   message: "Non-null assertion (!) overrides the type checker; narrow with a type guard or fix the type so it's not nullable",
+  syntaxKinds: [ts26.SyntaxKind.NonNullExpression],
   visit(node, ctx) {
-    if (!ts25.isNonNullExpression(node)) return;
+    if (!ts26.isNonNullExpression(node)) return;
     const inner = node.expression;
     if (!ctx.isNullable(inner)) return;
     if (ctx.isExternal(inner)) return;
@@ -1680,32 +1742,32 @@ var noNonNullAssertion = {
   }
 };
 function isSplitElementAccess(node) {
-  if (!ts25.isElementAccessExpression(node)) return false;
+  if (!ts26.isElementAccessExpression(node)) return false;
   const obj = node.expression;
-  if (!ts25.isCallExpression(obj)) return false;
+  if (!ts26.isCallExpression(obj)) return false;
   const callee = obj.expression;
-  if (!ts25.isPropertyAccessExpression(callee)) return false;
+  if (!ts26.isPropertyAccessExpression(callee)) return false;
   return callee.name.text === "split";
 }
 function isFilterElementAccess(node) {
-  if (ts25.isElementAccessExpression(node)) {
+  if (ts26.isElementAccessExpression(node)) {
     const obj = node.expression;
-    if (ts25.isCallExpression(obj)) {
+    if (ts26.isCallExpression(obj)) {
       const callee = obj.expression;
-      if (ts25.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+      if (ts26.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
     }
-    if (ts25.isIdentifier(obj)) {
+    if (ts26.isIdentifier(obj)) {
       const init = findVariableInit(obj);
-      if (init && ts25.isCallExpression(init)) {
+      if (init && ts26.isCallExpression(init)) {
         const callee = init.expression;
-        if (ts25.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+        if (ts26.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
       }
     }
   }
   return false;
 }
 function isLengthGuardedAccess(node) {
-  if (!ts25.isElementAccessExpression(node)) return false;
+  if (!ts26.isElementAccessExpression(node)) return false;
   const arr = node.expression;
   const arrName = getIdentifierName(arr);
   if (!arrName) return false;
@@ -1716,25 +1778,25 @@ function isInsideForLoopBoundedBy(node, arrName) {
   let current = node;
   while (current.parent) {
     current = current.parent;
-    if (ts25.isForStatement(current) && current.condition) {
+    if (ts26.isForStatement(current) && current.condition) {
       if (isLengthBoundCondition(current.condition, arrName)) return true;
     }
   }
   return false;
 }
 function isLengthBoundCondition(cond, arrName) {
-  if (!ts25.isBinaryExpression(cond)) return false;
+  if (!ts26.isBinaryExpression(cond)) return false;
   const op = cond.operatorToken.kind;
-  if (op === ts25.SyntaxKind.LessThanToken || op === ts25.SyntaxKind.LessThanEqualsToken) {
+  if (op === ts26.SyntaxKind.LessThanToken || op === ts26.SyntaxKind.LessThanEqualsToken) {
     return isLengthAccess2(cond.right, arrName);
   }
-  if (op === ts25.SyntaxKind.GreaterThanToken || op === ts25.SyntaxKind.GreaterThanEqualsToken) {
+  if (op === ts26.SyntaxKind.GreaterThanToken || op === ts26.SyntaxKind.GreaterThanEqualsToken) {
     return isLengthAccess2(cond.left, arrName);
   }
   return false;
 }
 function isLengthAccess2(node, arrName) {
-  if (!ts25.isPropertyAccessExpression(node)) return false;
+  if (!ts26.isPropertyAccessExpression(node)) return false;
   if (node.name.text !== "length") return false;
   return getIdentifierName(node.expression) === arrName;
 }
@@ -1742,16 +1804,16 @@ function hasPrecedingLengthGuard(node, arrName) {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if (ts25.isBlock(parent)) {
+    if (ts26.isBlock(parent)) {
       for (const stmt of parent.statements) {
         if (stmt === current || stmt.pos >= current.pos) break;
-        if (ts25.isIfStatement(stmt) && isLengthGuardWithEarlyExit(stmt, arrName)) return true;
+        if (ts26.isIfStatement(stmt) && isLengthGuardWithEarlyExit(stmt, arrName)) return true;
       }
     }
-    if (ts25.isIfStatement(parent) && parent.thenStatement === current) {
+    if (ts26.isIfStatement(parent) && parent.thenStatement === current) {
       if (isPositiveLengthCheck(parent.expression, arrName)) return true;
     }
-    if (ts25.isBlock(current) && ts25.isIfStatement(parent) && parent.thenStatement === current) {
+    if (ts26.isBlock(current) && ts26.isIfStatement(parent) && parent.thenStatement === current) {
       if (isPositiveLengthCheck(parent.expression, arrName)) return true;
     }
     current = parent;
@@ -1763,90 +1825,91 @@ function isLengthGuardWithEarlyExit(stmt, arrName) {
   return isZeroLengthCheck(stmt.expression, arrName);
 }
 function isZeroLengthCheck(expr, arrName) {
-  if (!ts25.isBinaryExpression(expr)) return false;
+  if (!ts26.isBinaryExpression(expr)) return false;
   const op = expr.operatorToken.kind;
-  if (op === ts25.SyntaxKind.EqualsEqualsEqualsToken || op === ts25.SyntaxKind.EqualsEqualsToken) {
+  if (op === ts26.SyntaxKind.EqualsEqualsEqualsToken || op === ts26.SyntaxKind.EqualsEqualsToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
     if (isLengthAccess2(expr.right, arrName) && isNumericLiteralValue(expr.left, 0)) return true;
   }
-  if (op === ts25.SyntaxKind.LessThanToken) {
+  if (op === ts26.SyntaxKind.LessThanToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
-  if (op === ts25.SyntaxKind.ExclamationEqualsEqualsToken || op === ts25.SyntaxKind.ExclamationEqualsToken) {
+  if (op === ts26.SyntaxKind.ExclamationEqualsEqualsToken || op === ts26.SyntaxKind.ExclamationEqualsToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
   return false;
 }
 function isPositiveLengthCheck(expr, arrName) {
-  if (!ts25.isBinaryExpression(expr)) return false;
+  if (!ts26.isBinaryExpression(expr)) return false;
   const op = expr.operatorToken.kind;
-  if (op === ts25.SyntaxKind.GreaterThanToken) {
+  if (op === ts26.SyntaxKind.GreaterThanToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
   }
-  if (op === ts25.SyntaxKind.GreaterThanEqualsToken) {
+  if (op === ts26.SyntaxKind.GreaterThanEqualsToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
-  if (op === ts25.SyntaxKind.ExclamationEqualsEqualsToken || op === ts25.SyntaxKind.ExclamationEqualsToken) {
+  if (op === ts26.SyntaxKind.ExclamationEqualsEqualsToken || op === ts26.SyntaxKind.ExclamationEqualsToken) {
     if (isLengthAccess2(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
   }
   return false;
 }
 function isEarlyExit(stmt) {
-  if (ts25.isReturnStatement(stmt) || ts25.isThrowStatement(stmt)) return true;
-  if (ts25.isBlock(stmt) && stmt.statements.length === 1) {
+  if (ts26.isReturnStatement(stmt) || ts26.isThrowStatement(stmt)) return true;
+  if (ts26.isBlock(stmt) && stmt.statements.length === 1) {
     const inner = stmt.statements[0];
     if (inner === void 0) return false;
-    return ts25.isReturnStatement(inner) || ts25.isThrowStatement(inner);
+    return ts26.isReturnStatement(inner) || ts26.isThrowStatement(inner);
   }
   return false;
 }
 function isNumericLiteralValue(node, value) {
-  return ts25.isNumericLiteral(node) && node.text === String(value);
+  return ts26.isNumericLiteral(node) && node.text === String(value);
 }
 function isNumericLiteralGte(node, min) {
-  return ts25.isNumericLiteral(node) && Number(node.text) >= min;
+  return ts26.isNumericLiteral(node) && Number(node.text) >= min;
 }
 function getIdentifierName(node) {
-  if (ts25.isIdentifier(node)) return node.text;
+  if (ts26.isIdentifier(node)) return node.text;
   return null;
 }
 function findVariableInit(id) {
   const sourceFile = id.getSourceFile();
   let result;
   function visit(node) {
-    if (ts25.isVariableDeclaration(node) && ts25.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
+    if (ts26.isVariableDeclaration(node) && ts26.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
       result = node.initializer;
     }
-    if (!result) ts25.forEachChild(node, visit);
+    if (!result) ts26.forEachChild(node, visit);
   }
   visit(sourceFile);
   return result;
 }
 
 // src/rules/ts/no-swallowed-catch.ts
-import * as ts26 from "typescript";
+import * as ts27 from "typescript";
 var noSwallowedCatch = {
   kind: "ts",
   id: "no-swallowed-catch",
   severity: "warning",
   message: "Catch swallows the error: it neither throws nor returns a value referencing the caught error. Propagate via throw, or model failure into the return type carrying the original error",
+  syntaxKinds: [ts27.SyntaxKind.CatchClause, ts27.SyntaxKind.CallExpression],
   visit(node, ctx) {
-    if (ts26.isCatchClause(node)) {
+    if (ts27.isCatchClause(node)) {
       const binding = identifierBindingName(node.variableDeclaration);
       if (handlesError(node.block, binding)) return;
       ctx.report(node);
       return;
     }
-    if (ts26.isCallExpression(node)) {
+    if (ts27.isCallExpression(node)) {
       const callee = node.expression;
-      if (!ts26.isPropertyAccessExpression(callee)) return;
+      if (!ts27.isPropertyAccessExpression(callee)) return;
       if (callee.name.text !== "catch") return;
       if (node.arguments.length !== 1) return;
       const handler = node.arguments[0];
       if (!handler) return;
-      if (!ts26.isArrowFunction(handler) && !ts26.isFunctionExpression(handler)) return;
-      const recvType = ctx.checker.getTypeAtLocation(callee.expression);
-      if (!isPromiseLike(recvType, ctx.checker)) return;
+      if (!ts27.isArrowFunction(handler) && !ts27.isFunctionExpression(handler)) return;
+      const recvType = ctx.semantics.typeAtLocation(callee.expression);
+      if (!isPromiseLike(recvType, ctx.semantics)) return;
       const binding = identifierBindingName(handler.parameters[0]);
       if (handlesError(handler.body, binding)) return;
       ctx.report(node);
@@ -1855,21 +1918,21 @@ var noSwallowedCatch = {
 };
 function identifierBindingName(decl) {
   if (!decl) return void 0;
-  if (!ts26.isIdentifier(decl.name)) return void 0;
+  if (!ts27.isIdentifier(decl.name)) return void 0;
   return decl.name.text;
 }
 function handlesError(body, binding) {
-  if (!ts26.isBlock(body)) {
+  if (!ts27.isBlock(body)) {
     return binding !== void 0 && expressionReferencesBinding(body, binding);
   }
   return blockThrows(body) || binding !== void 0 && blockReturnsReferencingBinding(body, binding);
 }
 function blockThrows(body) {
-  return walkSkippingFunctions(body, (n) => ts26.isThrowStatement(n));
+  return walkSkippingFunctions(body, (n) => ts27.isThrowStatement(n));
 }
 function blockReturnsReferencingBinding(body, binding) {
   return walkSkippingFunctions(body, (n) => {
-    if (!ts26.isReturnStatement(n)) return false;
+    if (!ts27.isReturnStatement(n)) return false;
     if (!n.expression) return false;
     return expressionReferencesBinding(n.expression, binding);
   });
@@ -1878,30 +1941,30 @@ function walkSkippingFunctions(root, predicate) {
   let found = false;
   function walk(node) {
     if (found) return;
-    if (ts26.isFunctionDeclaration(node) || ts26.isFunctionExpression(node) || ts26.isArrowFunction(node) || ts26.isMethodDeclaration(node)) {
+    if (ts27.isFunctionDeclaration(node) || ts27.isFunctionExpression(node) || ts27.isArrowFunction(node) || ts27.isMethodDeclaration(node)) {
       return;
     }
     if (predicate(node)) {
       found = true;
       return;
     }
-    ts26.forEachChild(node, walk);
+    ts27.forEachChild(node, walk);
   }
-  ts26.forEachChild(root, walk);
+  ts27.forEachChild(root, walk);
   return found;
 }
 function expressionReferencesBinding(expr, binding) {
   let found = false;
   function walk(node) {
     if (found) return;
-    if (ts26.isFunctionDeclaration(node) || ts26.isFunctionExpression(node) || ts26.isArrowFunction(node) || ts26.isMethodDeclaration(node)) {
+    if (ts27.isFunctionDeclaration(node) || ts27.isFunctionExpression(node) || ts27.isArrowFunction(node) || ts27.isMethodDeclaration(node)) {
       return;
     }
-    if (ts26.isIdentifier(node) && node.text === binding && isReferenceUse(node)) {
+    if (ts27.isIdentifier(node) && node.text === binding && isReferenceUse(node)) {
       found = true;
       return;
     }
-    ts26.forEachChild(node, walk);
+    ts27.forEachChild(node, walk);
   }
   walk(expr);
   return found;
@@ -1909,44 +1972,45 @@ function expressionReferencesBinding(expr, binding) {
 function isReferenceUse(id) {
   const parent = id.parent;
   if (!parent) return true;
-  if (ts26.isPropertyAccessExpression(parent) && parent.name === id) return false;
-  if (ts26.isPropertyAssignment(parent) && parent.name === id) return false;
-  if (ts26.isMethodDeclaration(parent) && parent.name === id) return false;
-  if (ts26.isQualifiedName(parent) && parent.right === id) return false;
-  if (ts26.isBindingElement(parent) && parent.propertyName === id) return false;
-  if (ts26.isParameter(parent) && parent.name === id) return false;
-  if (ts26.isVariableDeclaration(parent) && parent.name === id) return false;
+  if (ts27.isPropertyAccessExpression(parent) && parent.name === id) return false;
+  if (ts27.isPropertyAssignment(parent) && parent.name === id) return false;
+  if (ts27.isMethodDeclaration(parent) && parent.name === id) return false;
+  if (ts27.isQualifiedName(parent) && parent.right === id) return false;
+  if (ts27.isBindingElement(parent) && parent.propertyName === id) return false;
+  if (ts27.isParameter(parent) && parent.name === id) return false;
+  if (ts27.isVariableDeclaration(parent) && parent.name === id) return false;
   return true;
 }
-function isPromiseLike(type, checker) {
-  if (hasThenMethod(type, checker)) return true;
-  if (type.isUnion()) return type.types.some((t) => isPromiseLike(t, checker));
-  if (type.isIntersection()) return type.types.some((t) => isPromiseLike(t, checker));
+function isPromiseLike(type, semantics) {
+  if (hasThenMethod(type, semantics)) return true;
+  if (type.isUnion()) return type.types.some((t) => isPromiseLike(t, semantics));
+  if (type.isIntersection()) return type.types.some((t) => isPromiseLike(t, semantics));
   return false;
 }
-function hasThenMethod(type, checker) {
-  const apparent = checker.getApparentType(type);
+function hasThenMethod(type, semantics) {
+  const apparent = semantics.apparentType(type);
   const then = apparent.getProperty("then");
   if (!then) return false;
   const declaration = then.valueDeclaration ?? then.declarations?.[0];
   if (!declaration) return false;
-  const thenType = checker.getTypeOfSymbolAtLocation(then, declaration);
+  const thenType = semantics.typeOfSymbolAtLocation(then, declaration);
   return thenType.getCallSignatures().length > 0;
 }
 
 // src/rules/ts/no-null-ternary-normalization.ts
-import * as ts27 from "typescript";
+import * as ts28 from "typescript";
 var noNullTernaryNormalization = {
   kind: "ts",
   id: "no-null-ternary-normalization",
   severity: "warning",
   message: "Ternary null-normalization (x == null ? fallback : x); if the type guarantees non-null, remove the ternary; if not, fix the type upstream",
+  syntaxKinds: [ts28.SyntaxKind.ConditionalExpression],
   visit(node, ctx) {
-    if (!ts27.isConditionalExpression(node)) return;
+    if (!ts28.isConditionalExpression(node)) return;
     const test = node.condition;
-    if (!ts27.isBinaryExpression(test)) return;
+    if (!ts28.isBinaryExpression(test)) return;
     const op = test.operatorToken.kind;
-    if (op !== ts27.SyntaxKind.EqualsEqualsEqualsToken && op !== ts27.SyntaxKind.ExclamationEqualsEqualsToken && op !== ts27.SyntaxKind.EqualsEqualsToken && op !== ts27.SyntaxKind.ExclamationEqualsToken) return;
+    if (op !== ts28.SyntaxKind.EqualsEqualsEqualsToken && op !== ts28.SyntaxKind.ExclamationEqualsEqualsToken && op !== ts28.SyntaxKind.EqualsEqualsToken && op !== ts28.SyntaxKind.ExclamationEqualsToken) return;
     const hasNullishComparand = isNullish(test.left) || isNullish(test.right);
     if (!hasNullishComparand) return;
     if (isNullish(node.whenTrue) || isNullish(node.whenFalse)) {
@@ -1960,54 +2024,55 @@ var noNullTernaryNormalization = {
   }
 };
 function isNullish(node) {
-  if (node.kind === ts27.SyntaxKind.NullKeyword) return true;
-  if (ts27.isIdentifier(node) && node.text === "undefined") return true;
-  if (ts27.isVoidExpression(node)) return true;
+  if (node.kind === ts28.SyntaxKind.NullKeyword) return true;
+  if (ts28.isIdentifier(node) && node.text === "undefined") return true;
+  if (ts28.isVoidExpression(node)) return true;
   return false;
 }
 
 // src/rules/ts/no-nullish-coalescing.ts
-import * as ts28 from "typescript";
+import * as ts29 from "typescript";
 var noNullishCoalescing = {
   kind: "ts",
   id: "no-nullish-coalescing",
   severity: "warning",
   message: "Nullish coalescing (??) fallback on a non-nullable type is dead code; remove the fallback or fix the type upstream",
+  syntaxKinds: [ts29.SyntaxKind.BinaryExpression],
   visit(node, ctx) {
-    if (!ts28.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts28.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts29.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts29.SyntaxKind.QuestionQuestionToken) return;
     if (isPossiblyMissingArrayBindingValue(node.left, ctx)) return;
     if (ctx.isNullable(node.left)) return;
     ctx.report(node);
   }
 };
 function isPossiblyMissingArrayBindingValue(node, ctx) {
-  if (!ts28.isIdentifier(node)) return false;
-  const symbol = ctx.checker.getSymbolAtLocation(node);
+  if (!ts29.isIdentifier(node)) return false;
+  const symbol = ctx.semantics.symbolAtLocation(node);
   if (!symbol) return false;
   for (const declaration of symbol.declarations ?? []) {
-    if (!ts28.isBindingElement(declaration)) continue;
+    if (!ts29.isBindingElement(declaration)) continue;
     if (declaration.initializer || declaration.dotDotDotToken) continue;
-    if (!ts28.isArrayBindingPattern(declaration.parent)) continue;
+    if (!ts29.isArrayBindingPattern(declaration.parent)) continue;
     const pattern = declaration.parent;
     const index = pattern.elements.indexOf(declaration);
     if (index < 0) continue;
-    if (!isTupleSlotDefinitelyPresent(ctx.checker.getTypeAtLocation(pattern), index, ctx.checker)) {
+    if (!isTupleSlotDefinitelyPresent(ctx.semantics.typeAtLocation(pattern), index, ctx)) {
       return true;
     }
   }
   return false;
 }
-function isTupleSlotDefinitelyPresent(type, index, checker) {
+function isTupleSlotDefinitelyPresent(type, index, ctx) {
   if (type.isUnion()) {
-    return type.types.every((member) => isTupleSlotDefinitelyPresent(member, index, checker));
+    return type.types.every((member) => isTupleSlotDefinitelyPresent(member, index, ctx));
   }
-  const apparent = checker.getApparentType(type);
-  if (!isTupleTypeReference(apparent, checker)) return false;
+  const apparent = ctx.semantics.apparentType(type);
+  if (!isTupleTypeReference(apparent, ctx)) return false;
   return index < apparent.target.minLength;
 }
-function isTupleTypeReference(type, checker) {
-  if (!checker.isTupleType(type)) return false;
+function isTupleTypeReference(type, ctx) {
+  if (!ctx.semantics.isTupleType(type)) return false;
   if (!("target" in type)) return false;
   const target = type.target;
   if (typeof target !== "object" || target === null) return false;
@@ -2016,14 +2081,15 @@ function isTupleTypeReference(type, checker) {
 }
 
 // src/rules/ts/no-optional-call.ts
-import * as ts29 from "typescript";
+import * as ts30 from "typescript";
 var noOptionalCall = {
   kind: "ts",
   id: "no-optional-call",
   severity: "warning",
   message: "Optional call (?.) on a non-nullable function is redundant; call directly or fix the type upstream",
+  syntaxKinds: [ts30.SyntaxKind.CallExpression],
   visit(node, ctx) {
-    if (!ts29.isCallExpression(node)) return;
+    if (!ts30.isCallExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -2031,14 +2097,15 @@ var noOptionalCall = {
 };
 
 // src/rules/ts/no-optional-element-access.ts
-import * as ts30 from "typescript";
+import * as ts31 from "typescript";
 var noOptionalElementAccess = {
   kind: "ts",
   id: "no-optional-element-access",
   severity: "warning",
   message: "Optional element access (?.[]) on a non-nullable type is redundant; use direct access or fix the type upstream",
+  syntaxKinds: [ts31.SyntaxKind.ElementAccessExpression],
   visit(node, ctx) {
-    if (!ts30.isElementAccessExpression(node)) return;
+    if (!ts31.isElementAccessExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -2046,14 +2113,15 @@ var noOptionalElementAccess = {
 };
 
 // src/rules/ts/no-optional-property-access.ts
-import * as ts31 from "typescript";
+import * as ts32 from "typescript";
 var noOptionalPropertyAccess = {
   kind: "ts",
   id: "no-optional-property-access",
   severity: "warning",
   message: "Optional chaining (?.) on a non-nullable type is redundant; use direct access or fix the type upstream",
+  syntaxKinds: [ts32.SyntaxKind.PropertyAccessExpression],
   visit(node, ctx) {
-    if (!ts31.isPropertyAccessExpression(node)) return;
+    if (!ts32.isPropertyAccessExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -2061,27 +2129,28 @@ var noOptionalPropertyAccess = {
 };
 
 // src/rules/ts/no-redundant-existence-guard.ts
-import * as ts32 from "typescript";
+import * as ts33 from "typescript";
 var noRedundantExistenceGuard = {
   kind: "ts",
   id: "no-redundant-existence-guard",
   severity: "warning",
   message: "Redundant existence guard (obj && obj.prop) on a non-nullable type; remove the guard or fix the type upstream",
+  syntaxKinds: [ts33.SyntaxKind.BinaryExpression],
   visit(node, ctx) {
-    if (!ts32.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts32.SyntaxKind.AmpersandAmpersandToken) return;
+    if (!ts33.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts33.SyntaxKind.AmpersandAmpersandToken) return;
     const left = node.left;
     const right = node.right;
-    if (ts32.isIdentifier(left) && accessesIdentifier(right, left.text)) {
+    if (ts33.isIdentifier(left) && accessesIdentifier(right, left.text)) {
       if (ctx.isNullable(left)) return;
       ctx.report(node);
       return;
     }
-    if (ts32.isBinaryExpression(left) && isNullCheck(left)) {
+    if (ts33.isBinaryExpression(left) && isNullCheck(left)) {
       const checked = getNullCheckedIdentifier(left);
       if (checked && accessesIdentifier(right, checked)) {
-        const identNode = ts32.isIdentifier(left.left) ? left.left : left.right;
-        if (ts32.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
+        const identNode = ts33.isIdentifier(left.left) ? left.left : left.right;
+        if (ts33.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
           ctx.report(node);
         }
       }
@@ -2090,114 +2159,134 @@ var noRedundantExistenceGuard = {
 };
 function accessesIdentifier(expr, name) {
   const root = getExpressionRoot(expr);
-  return ts32.isIdentifier(root) && root.text === name;
+  return ts33.isIdentifier(root) && root.text === name;
 }
 function getExpressionRoot(node) {
-  if (ts32.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts32.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts32.isCallExpression(node)) return getExpressionRoot(node.expression);
+  if (ts33.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts33.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts33.isCallExpression(node)) return getExpressionRoot(node.expression);
   return node;
 }
 function isNullCheck(expr) {
   const op = expr.operatorToken.kind;
-  if (op !== ts32.SyntaxKind.ExclamationEqualsToken && op !== ts32.SyntaxKind.ExclamationEqualsEqualsToken) return false;
+  if (op !== ts33.SyntaxKind.ExclamationEqualsToken && op !== ts33.SyntaxKind.ExclamationEqualsEqualsToken) return false;
   return isNullishLiteral(expr.right) || isNullishLiteral(expr.left);
 }
 function getNullCheckedIdentifier(expr) {
-  if (ts32.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
-  if (ts32.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
+  if (ts33.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
+  if (ts33.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
   return null;
 }
 
 // src/rules/ts/no-ts-ignore.ts
-import * as ts33 from "typescript";
+import * as ts34 from "typescript";
 var noTsIgnore = {
   kind: "ts",
   id: "no-ts-ignore",
   severity: "error",
   message: "@ts-ignore / @ts-expect-error suppresses type checking; fix the underlying type issue",
+  syntaxKinds: [ts34.SyntaxKind.SourceFile],
+  requiresTypeInfo: false,
   visit(node, ctx) {
-    const ranges = ts33.getLeadingCommentRanges(ctx.source, node.getFullStart());
-    if (!ranges) return;
-    for (const range of ranges) {
-      const text = ctx.source.slice(range.pos, range.end);
-      if (text.includes("@ts-ignore") || text.includes("@ts-expect-error")) {
-        ctx.reportAtOffset(range.pos);
-      }
+    if (!ts34.isSourceFile(node)) return;
+    const directives = getCommentDirectives(node);
+    if (directives === void 0) return;
+    for (const directive of directives) {
+      ctx.reportAtOffset(directive.range.pos);
     }
   }
 };
+function getCommentDirectives(sourceFile) {
+  const directives = Reflect.get(sourceFile, "commentDirectives");
+  if (!Array.isArray(directives)) return void 0;
+  if (!directives.every(isCommentDirective)) return void 0;
+  return directives;
+}
+function isCommentDirective(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("range" in value)) return false;
+  const range = value.range;
+  if (typeof range !== "object" || range === null) return false;
+  if (!("pos" in range)) return false;
+  return typeof range.pos === "number";
+}
 
 // src/rules/ts/no-type-assertion.ts
-import * as ts34 from "typescript";
+import * as ts35 from "typescript";
 var noTypeAssertion = {
   kind: "ts",
   id: "no-type-assertion",
   severity: "error",
   message: "Double type assertion (`as unknown as T`) circumvents the type system; fix the upstream type or use a type guard",
+  syntaxKinds: [ts35.SyntaxKind.AsExpression],
+  requiresTypeInfo: false,
   visit(node, ctx) {
-    if (!ts34.isAsExpression(node)) return;
-    if (!ts34.isAsExpression(node.expression)) return;
-    if (node.expression.type.kind !== ts34.SyntaxKind.UnknownKeyword) return;
+    if (!ts35.isAsExpression(node)) return;
+    if (!ts35.isAsExpression(node.expression)) return;
+    if (node.expression.type.kind !== ts35.SyntaxKind.UnknownKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/prefer-default-param-value.ts
-import * as ts35 from "typescript";
+import * as ts36 from "typescript";
 var preferDefaultParamValue = {
   kind: "ts",
   id: "prefer-default-param-value",
   severity: "info",
   message: "Use a default parameter value instead of reassigning from nullish coalescing inside the body",
+  syntaxKinds: [ts36.SyntaxKind.FunctionDeclaration, ts36.SyntaxKind.ArrowFunction],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     const result = getFirstFunctionStatement(node);
     if (result === null) return;
     const { firstStmt, fn } = result;
-    if (!ts35.isExpressionStatement(firstStmt)) return;
+    if (!ts36.isExpressionStatement(firstStmt)) return;
     const expr = firstStmt.expression;
-    if (!ts35.isBinaryExpression(expr) || expr.operatorToken.kind !== ts35.SyntaxKind.EqualsToken) return;
+    if (!ts36.isBinaryExpression(expr) || expr.operatorToken.kind !== ts36.SyntaxKind.EqualsToken) return;
     const right = expr.right;
-    if (!ts35.isBinaryExpression(right) || right.operatorToken.kind !== ts35.SyntaxKind.QuestionQuestionToken) return;
-    if (!ts35.isIdentifier(expr.left) || !ts35.isIdentifier(right.left)) return;
+    if (!ts36.isBinaryExpression(right) || right.operatorToken.kind !== ts36.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts36.isIdentifier(expr.left) || !ts36.isIdentifier(right.left)) return;
     if (expr.left.text !== right.left.text) return;
     const paramName = expr.left.text;
-    const isParam = fn.parameters.some((p) => ts35.isIdentifier(p.name) && p.name.text === paramName);
+    const isParam = fn.parameters.some((p) => ts36.isIdentifier(p.name) && p.name.text === paramName);
     if (isParam) ctx.report(firstStmt);
   }
 };
 
 // src/rules/ts/prefer-required-param-with-guard.ts
-import * as ts36 from "typescript";
+import * as ts37 from "typescript";
 var preferRequiredParamWithGuard = {
   kind: "ts",
   id: "prefer-required-param-with-guard",
   severity: "info",
   message: "Optional param with immediate guard (if (!param) return/throw); make it required instead",
+  syntaxKinds: [ts37.SyntaxKind.FunctionDeclaration, ts37.SyntaxKind.ArrowFunction],
+  requiresTypeInfo: false,
   visit(node, ctx) {
     const result = getFirstFunctionStatement(node);
     if (result === null) return;
     const { firstStmt, fn } = result;
-    if (!ts36.isIfStatement(firstStmt)) return;
+    if (!ts37.isIfStatement(firstStmt)) return;
     const test = firstStmt.expression;
     let guardedName = null;
-    if (ts36.isPrefixUnaryExpression(test) && test.operator === ts36.SyntaxKind.ExclamationToken) {
-      if (ts36.isIdentifier(test.operand)) guardedName = test.operand.text;
+    if (ts37.isPrefixUnaryExpression(test) && test.operator === ts37.SyntaxKind.ExclamationToken) {
+      if (ts37.isIdentifier(test.operand)) guardedName = test.operand.text;
     }
-    if (ts36.isBinaryExpression(test)) {
+    if (ts37.isBinaryExpression(test)) {
       const op = test.operatorToken.kind;
-      if (op === ts36.SyntaxKind.EqualsEqualsEqualsToken || op === ts36.SyntaxKind.EqualsEqualsToken) {
-        if (ts36.isIdentifier(test.left) && ts36.isIdentifier(test.right) && test.right.text === "undefined") {
+      if (op === ts37.SyntaxKind.EqualsEqualsEqualsToken || op === ts37.SyntaxKind.EqualsEqualsToken) {
+        if (ts37.isIdentifier(test.left) && ts37.isIdentifier(test.right) && test.right.text === "undefined") {
           guardedName = test.left.text;
         }
       }
     }
     if (!guardedName) return;
     const consequent = firstStmt.thenStatement;
-    const isGuard = ts36.isReturnStatement(consequent) || ts36.isThrowStatement(consequent) || ts36.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts36.isReturnStatement(consequent.statements[0]) || ts36.isThrowStatement(consequent.statements[0]));
+    const isGuard = ts37.isReturnStatement(consequent) || ts37.isThrowStatement(consequent) || ts37.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts37.isReturnStatement(consequent.statements[0]) || ts37.isThrowStatement(consequent.statements[0]));
     if (!isGuard) return;
     const isOptional = fn.parameters.some(
-      (p) => ts36.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
+      (p) => ts37.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
     );
     if (isOptional) ctx.report(firstStmt);
   }
@@ -2351,8 +2440,11 @@ function isFailOn(value) {
   return value === "none" || isSeverity(value);
 }
 
+// src/scan/analyze.ts
+import { readFileSync } from "fs";
+
 // src/collect/index.ts
-import * as ts39 from "typescript";
+import * as ts40 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
 // src/collect/type-registry.ts
@@ -2361,58 +2453,59 @@ import { dirname as dirname2, join } from "path";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts37 from "typescript";
+import * as ts38 from "typescript";
 function hashTypeShape(node, sourceFile) {
   const normalized = normalizeTypeNode(node, sourceFile);
   return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function normalizeTypeNode(node, sourceFile) {
-  if (ts37.isTypeLiteralNode(node)) {
+  if (ts38.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts37.isInterfaceDeclaration(node)) {
+  if (ts38.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts37.isPropertySignature(node)) {
+  if (ts38.isPropertySignature(node)) {
     const keyName = node.name.getText(sourceFile);
     const optional = node.questionToken ? "?" : "";
     const type = node.type ? normalizeTypeNode(node.type, sourceFile) : "any";
     return `${keyName}${optional}:${type}`;
   }
-  if (ts37.isTypeAliasDeclaration(node)) {
+  if (ts38.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
 }
-function hashFunctionBody(node, sourceFile) {
-  const normalized = stripComments(node.getText(sourceFile));
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-function bodyTextLength(node, sourceFile) {
-  return stripComments(node.getText(sourceFile)).length;
-}
 function stripComments(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
 }
-function normalizeBody(node, sourceFile, paramNames) {
-  let text = node.getText(sourceFile);
-  text = text.replace(/\/\/[^\n]*/g, "");
-  text = text.replace(/\/\*[\s\S]*?\*\//g, "");
-  text = text.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
-  text = text.replace(/'(?:[^'\\]|\\.)*'/g, '"__STR__"');
-  text = text.replace(/`(?:[^`\\]|\\.)*`/g, '"__STR__"');
-  text = text.replace(/\b\d+(?:\.\d+)?\b/g, "__NUM__");
+function normalizeBodyText(text, paramNames) {
+  let normalized = text;
+  normalized = normalized.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
+  normalized = normalized.replace(/'(?:[^'\\]|\\.)*'/g, '"__STR__"');
+  normalized = normalized.replace(/`(?:[^`\\]|\\.)*`/g, '"__STR__"');
+  normalized = normalized.replace(/\b\d+(?:\.\d+)?\b/g, "__NUM__");
   for (let i = 0; i < paramNames.length; i++) {
     const name = paramNames[i];
     const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    text = text.replace(new RegExp(`\\b${escaped}\\b`, "g"), `$${i}`);
+    normalized = normalized.replace(new RegExp(`\\b${escaped}\\b`, "g"), `$${i}`);
   }
-  text = text.replace(/\bthis\./g, "$_.");
-  text = text.replace(/\$\d+\./g, "$_.");
-  text = text.replace(/\s+/g, " ").trim();
-  return text;
+  normalized = normalized.replace(/\bthis\./g, "$_.");
+  normalized = normalized.replace(/\$\d+\./g, "$_.");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+function analyzeFunctionBody(node, sourceFile, paramNames) {
+  const stripped = stripComments(node.getText(sourceFile));
+  const normalized = normalizeBodyText(stripped, paramNames);
+  return {
+    hash: hashText(stripped),
+    normalizedHash: hashText(normalized),
+    bodyLength: stripped.length,
+    normalizedBodyLength: normalized.length
+  };
 }
 function normalizeText2(text) {
   let t = text.replace(/\/\/[^\n]*/g, "");
@@ -2428,13 +2521,6 @@ function normalizeText2(text) {
 function hashText(text) {
   return createHash("sha256").update(text).digest("hex").slice(0, 16);
 }
-function hashFunctionBodyNormalized(node, sourceFile, paramNames) {
-  const text = normalizeBody(node, sourceFile, paramNames);
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-function normalizedBodyTextLength(node, sourceFile, paramNames) {
-  return normalizeBody(node, sourceFile, paramNames).length;
-}
 
 // src/collect/base-registry.ts
 var BaseRegistry = class {
@@ -2567,15 +2653,17 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts38 from "typescript";
-function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
+import * as ts39 from "typescript";
+function buildContext(rule, sourceFile, semantics, source, filename, diagnostics) {
+  const checker = semantics.checker;
   return {
     filename,
     source,
     sourceFile,
     checker,
+    semantics,
     report(node, message) {
-      const { line, character } = ts38.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -2586,7 +2674,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts38.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts39.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -2597,11 +2685,11 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     isNullable(node) {
-      const type = checker.getTypeAtLocation(node);
+      const type = semantics.typeAtLocation(node);
       return isNullableType(checker, type);
     },
     isExternal(node) {
-      const type = checker.getTypeAtLocation(node);
+      const type = semantics.typeAtLocation(node);
       const symbol = type.getSymbol();
       if (!symbol) return false;
       const declarations = symbol.getDeclarations();
@@ -2611,198 +2699,537 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
   };
 }
 
+// src/typecheck/semantic-cache.ts
+var SemanticCache = class {
+  constructor(checker) {
+    this.checker = checker;
+  }
+  typesAtLocation = /* @__PURE__ */ new WeakMap();
+  symbolsAtLocation = /* @__PURE__ */ new WeakMap();
+  resolvedSignatures = /* @__PURE__ */ new WeakMap();
+  typesFromTypeNodes = /* @__PURE__ */ new WeakMap();
+  contextualTypes = /* @__PURE__ */ new WeakMap();
+  typesOfSymbols = /* @__PURE__ */ new WeakMap();
+  aliasedSymbols = /* @__PURE__ */ new WeakMap();
+  awaitedTypes = /* @__PURE__ */ new WeakMap();
+  apparentTypes = /* @__PURE__ */ new WeakMap();
+  arrayTypes = /* @__PURE__ */ new WeakMap();
+  tupleTypes = /* @__PURE__ */ new WeakMap();
+  assignability = /* @__PURE__ */ new WeakMap();
+  typeAtLocation(node) {
+    const cached = this.typesAtLocation.get(node);
+    if (cached !== void 0) return cached;
+    const type = this.checker.getTypeAtLocation(node);
+    this.typesAtLocation.set(node, type);
+    return type;
+  }
+  symbolAtLocation(node) {
+    const cached = this.symbolsAtLocation.get(node);
+    if (cached !== void 0) return cached ?? void 0;
+    const symbol = this.checker.getSymbolAtLocation(node);
+    this.symbolsAtLocation.set(node, symbol ?? null);
+    return symbol;
+  }
+  resolvedSignature(node) {
+    const cached = this.resolvedSignatures.get(node);
+    if (cached !== void 0) return cached ?? void 0;
+    const signature = this.checker.getResolvedSignature(node);
+    this.resolvedSignatures.set(node, signature ?? null);
+    return signature;
+  }
+  typeFromTypeNode(node) {
+    const cached = this.typesFromTypeNodes.get(node);
+    if (cached !== void 0) return cached;
+    const type = this.checker.getTypeFromTypeNode(node);
+    this.typesFromTypeNodes.set(node, type);
+    return type;
+  }
+  contextualType(node) {
+    const cached = this.contextualTypes.get(node);
+    if (cached !== void 0) return cached ?? void 0;
+    const type = this.checker.getContextualType(node);
+    this.contextualTypes.set(node, type ?? null);
+    return type;
+  }
+  typeOfSymbolAtLocation(symbol, node) {
+    let byNode = this.typesOfSymbols.get(symbol);
+    if (byNode === void 0) {
+      byNode = /* @__PURE__ */ new WeakMap();
+      this.typesOfSymbols.set(symbol, byNode);
+    }
+    const cached = byNode.get(node);
+    if (cached !== void 0) return cached;
+    const type = this.checker.getTypeOfSymbolAtLocation(symbol, node);
+    byNode.set(node, type);
+    return type;
+  }
+  aliasedSymbol(symbol) {
+    const cached = this.aliasedSymbols.get(symbol);
+    if (cached !== void 0) return cached;
+    const aliased = this.checker.getAliasedSymbol(symbol);
+    this.aliasedSymbols.set(symbol, aliased);
+    return aliased;
+  }
+  awaitedType(type) {
+    const cached = this.awaitedTypes.get(type);
+    if (cached !== void 0) return cached ?? void 0;
+    const awaited = this.checker.getAwaitedType(type);
+    this.awaitedTypes.set(type, awaited ?? null);
+    return awaited;
+  }
+  apparentType(type) {
+    const cached = this.apparentTypes.get(type);
+    if (cached !== void 0) return cached;
+    const apparent = this.checker.getApparentType(type);
+    this.apparentTypes.set(type, apparent);
+    return apparent;
+  }
+  isArrayType(type) {
+    const cached = this.arrayTypes.get(type);
+    if (cached !== void 0) return cached;
+    const result = this.checker.isArrayType(type);
+    this.arrayTypes.set(type, result);
+    return result;
+  }
+  isTupleType(type) {
+    const cached = this.tupleTypes.get(type);
+    if (cached !== void 0) return cached;
+    const result = this.checker.isTupleType(type);
+    this.tupleTypes.set(type, result);
+    return result;
+  }
+  isTypeAssignableTo(source, target) {
+    let byTarget = this.assignability.get(source);
+    if (byTarget === void 0) {
+      byTarget = /* @__PURE__ */ new WeakMap();
+      this.assignability.set(source, byTarget);
+    }
+    const cached = byTarget.get(target);
+    if (cached !== void 0) return cached;
+    const result = this.checker.isTypeAssignableTo(source, target);
+    byTarget.set(target, result);
+    return result;
+  }
+};
+
 // src/collect/index.ts
-function collectProject(program, tsRules, allowedFiles) {
+var commentCache = /* @__PURE__ */ new WeakMap();
+var ALL_PROJECT_INDEX_NEEDS = /* @__PURE__ */ new Set([
+  "files",
+  "types",
+  "functions",
+  "functionSymbols",
+  "constants",
+  "callSites",
+  "callSiteSymbols",
+  "overloadCallSignatures",
+  "imports",
+  "fileHashes",
+  "statementSequences",
+  "inlineParamTypes"
+]);
+function createProjectIndex() {
+  return {
+    types: new TypeRegistry(),
+    functions: new FunctionRegistry(),
+    constants: new ConstantRegistry(),
+    callSites: [],
+    imports: [],
+    files: /* @__PURE__ */ new Map(),
+    fileHashes: /* @__PURE__ */ new Map(),
+    statementSequences: new StatementSequenceRegistry(),
+    inlineParamTypes: new InlineParamTypeRegistry()
+  };
+}
+function collectSourceText(file, source, tsRules, options = {}) {
+  const sourceFile = ts40.createSourceFile(file, source, ts40.ScriptTarget.Latest, true, scriptKindForFile(file));
+  const diagnostics = [];
+  const semantics = buildUnavailableSemantics(file);
+  const needs = options.needs ?? /* @__PURE__ */ new Set();
+  const index = options.index;
+  if (index !== void 0) {
+    if (needs.has("fileHashes")) addFileHash(index, file, source);
+  }
+  const ruleDispatch = buildRuleDispatch(tsRules.map((rule) => ({
+    rule,
+    ctx: buildSyntaxContext(rule, sourceFile, source, file, diagnostics)
+  })));
+  function visit(node) {
+    visitRuleContexts(node, ruleDispatch);
+    if (index !== void 0 && needs.size > 0) {
+      collectIndexNode(node, file, sourceFile, semantics, index, needs);
+    }
+    ts40.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (index !== void 0 && options.retainFile !== false) {
+    index.files.set(file, { source, sourceFile });
+  }
+  return { diagnostics };
+}
+function scriptKindForFile(file) {
+  if (file.endsWith(".tsx")) return ts40.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts40.ScriptKind.JSX;
+  if (file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs")) return ts40.ScriptKind.JS;
+  if (file.endsWith(".json")) return ts40.ScriptKind.JSON;
+  return ts40.ScriptKind.TS;
+}
+function buildSyntaxContext(rule, sourceFile, source, filename, diagnostics) {
+  const checker = buildUnavailableChecker(`rule "${rule.id}"`);
+  const semantics = buildUnavailableSemantics(`rule "${rule.id}"`);
+  return {
+    filename,
+    source,
+    sourceFile,
+    checker,
+    semantics,
+    report(node, message) {
+      const { line, character } = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      diagnostics.push({
+        ruleId: rule.id,
+        severity: rule.severity,
+        message: message ?? rule.message,
+        file: filename,
+        line: line + 1,
+        column: character + 1
+      });
+    },
+    reportAtOffset(offset, message) {
+      const { line, character } = ts40.getLineAndCharacterOfPosition(sourceFile, offset);
+      diagnostics.push({
+        ruleId: rule.id,
+        severity: rule.severity,
+        message: message ?? rule.message,
+        file: filename,
+        line: line + 1,
+        column: character + 1
+      });
+    },
+    isNullable: unavailableTypeInfo,
+    isExternal: unavailableTypeInfo
+  };
+}
+function buildUnavailableChecker(label) {
+  return new Proxy({}, {
+    get() {
+      throw new Error(`${label} requires type checking and cannot run in source-only mode.`);
+    }
+  });
+}
+function unavailableTypeInfo() {
+  throw new Error("This rule requires type checking and cannot run in source-only mode.");
+}
+function buildUnavailableSemantics(label) {
+  const checker = buildUnavailableChecker(label);
+  return {
+    checker,
+    typeAtLocation: unavailableTypeInfo,
+    symbolAtLocation: unavailableTypeInfo,
+    resolvedSignature: unavailableTypeInfo,
+    typeFromTypeNode: unavailableTypeInfo,
+    contextualType: unavailableTypeInfo,
+    typeOfSymbolAtLocation: unavailableTypeInfo,
+    aliasedSymbol: unavailableTypeInfo,
+    awaitedType: unavailableTypeInfo,
+    apparentType: unavailableTypeInfo,
+    isArrayType: unavailableTypeInfo,
+    isTupleType: unavailableTypeInfo,
+    isTypeAssignableTo: unavailableTypeInfo
+  };
+}
+function collectProject(program, tsRules, allowedFiles, options = {}) {
+  const index = options.index ?? createProjectIndex();
+  const needs = options.needs ?? ALL_PROJECT_INDEX_NEEDS;
   const checker = program.getTypeChecker();
-  const types = new TypeRegistry();
-  const functions = new FunctionRegistry();
-  const constants = new ConstantRegistry();
-  const callSites = [];
-  const imports = [];
-  const statementSequences = new StatementSequenceRegistry();
-  const inlineParamTypes = new InlineParamTypeRegistry();
-  const fileMap = /* @__PURE__ */ new Map();
+  const semantics = new SemanticCache(checker);
   const diagnostics = [];
+  const overloadCalleeNames = needs.has("overloadCallSignatures") ? collectOverloadCalleeNames(program, options.collectFiles ?? allowedFiles) : void 0;
   for (const sourceFile of program.getSourceFiles()) {
     let visit2 = function(node) {
-      collectTypes(node, file, sourceFile, types);
-      collectFunctions(node, file, sourceFile, checker, functions);
-      collectConstants(node, file, sourceFile, constants);
-      collectCallSites(node, file, sourceFile, checker, callSites);
-      collectStatementSequences(node, file, sourceFile, statementSequences);
-      collectInlineParamTypes(node, file, sourceFile, inlineParamTypes);
-      collectImports(node, file, imports);
-      if (ruleContexts) {
-        for (const { rule, ctx } of ruleContexts) {
-          rule.visit(node, ctx);
-        }
+      if (shouldCollect) {
+        collectIndexNode(node, file, sourceFile, semantics, index, needs, overloadCalleeNames);
+      }
+      if (ruleDispatch) {
+        visitRuleContexts(node, ruleDispatch);
       }
-      ts39.forEachChild(node, visit2);
+      ts40.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
     if (sourceFile.isDeclarationFile) continue;
     if (file.includes("node_modules")) continue;
     const isReportable = !allowedFiles || allowedFiles.has(file);
+    const shouldCollect = options.collectFiles === void 0 || options.collectFiles.has(file);
+    if (!isReportable && !shouldCollect) continue;
     const source = sourceFile.getFullText();
-    if (isReportable) {
-      const comments = collectAllComments(sourceFile);
-      fileMap.set(file, { source, sourceFile, comments });
+    if (isReportable || shouldCollect && needs.has("files")) {
+      index.files.set(file, { source, sourceFile });
     }
-    const ruleContexts = isReportable ? tsRules?.map((rule) => ({
+    if (shouldCollect && needs.has("fileHashes")) {
+      addFileHash(index, file, source);
+    }
+    const ruleDispatch = isReportable ? buildRuleDispatch(tsRules?.map((rule) => ({
       rule,
-      ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
-    })) : void 0;
-    ts39.forEachChild(sourceFile, visit2);
-  }
-  const fileHashes = /* @__PURE__ */ new Map();
-  for (const [file, { source }] of fileMap) {
-    const normalized = source.replace(/\s+/g, " ").trim();
-    const hash = createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
-    let list = fileHashes.get(hash);
-    if (list === void 0) {
-      list = [];
-      fileHashes.set(hash, list);
+      ctx: buildContext(rule, sourceFile, semantics, source, file, diagnostics)
+    })) ?? []) : void 0;
+    visit2(sourceFile);
+  }
+  return { index, diagnostics };
+}
+function collectIndexNode(node, file, sourceFile, semantics, index, needs, overloadCalleeNames) {
+  switch (node.kind) {
+    case ts40.SyntaxKind.TypeAliasDeclaration:
+    case ts40.SyntaxKind.InterfaceDeclaration:
+      if (!needs.has("types")) return;
+      collectTypes(node, file, sourceFile, index.types);
+      return;
+    case ts40.SyntaxKind.VariableStatement:
+      if (needs.has("functions")) {
+        collectFunctions(node, file, sourceFile, semantics, index.functions, needs.has("functionSymbols"));
+      }
+      if (needs.has("constants")) {
+        collectConstants(node, file, sourceFile, index.constants);
+      }
+      return;
+    case ts40.SyntaxKind.FunctionDeclaration:
+    case ts40.SyntaxKind.PropertyAssignment:
+    case ts40.SyntaxKind.ArrowFunction:
+    case ts40.SyntaxKind.FunctionExpression:
+    case ts40.SyntaxKind.MethodDeclaration:
+      if (needs.has("functions")) {
+        collectFunctions(node, file, sourceFile, semantics, index.functions, needs.has("functionSymbols"));
+      }
+      return;
+    case ts40.SyntaxKind.CallExpression:
+      if (!needs.has("callSites")) return;
+      collectCallSites(
+        node,
+        file,
+        sourceFile,
+        semantics,
+        index.callSites,
+        needs.has("callSiteSymbols"),
+        needs.has("overloadCallSignatures"),
+        overloadCalleeNames
+      );
+      return;
+    case ts40.SyntaxKind.Block:
+      if (!needs.has("statementSequences")) return;
+      collectStatementSequences(node, file, sourceFile, index.statementSequences);
+      return;
+    case ts40.SyntaxKind.TypeLiteral:
+      if (!needs.has("inlineParamTypes")) return;
+      collectInlineParamTypes(node, file, sourceFile, index.inlineParamTypes);
+      return;
+    case ts40.SyntaxKind.ImportDeclaration:
+    case ts40.SyntaxKind.ExportDeclaration:
+      if (!needs.has("imports")) return;
+      collectImports(node, file, index.imports);
+      return;
+  }
+}
+function addFileHash(index, file, source) {
+  const normalized = source.replace(/\s+/g, " ").trim();
+  const hash = createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
+  let list = index.fileHashes.get(hash);
+  if (list === void 0) {
+    list = [];
+    index.fileHashes.set(hash, list);
+  }
+  if (!list.includes(file)) list.push(file);
+}
+function buildRuleDispatch(ruleContexts) {
+  const byKind = /* @__PURE__ */ new Map();
+  const global = [];
+  for (const ruleContext of ruleContexts) {
+    const kinds = ruleContext.rule.syntaxKinds;
+    if (kinds === void 0) {
+      global.push(ruleContext);
+      continue;
+    }
+    for (const kind of kinds) {
+      let contexts = byKind.get(kind);
+      if (contexts === void 0) {
+        contexts = [];
+        byKind.set(kind, contexts);
+      }
+      contexts.push(ruleContext);
+    }
+  }
+  return { byKind, global };
+}
+function visitRuleContexts(node, ruleDispatch) {
+  const contexts = ruleDispatch.byKind.get(node.kind);
+  if (contexts !== void 0) {
+    for (const { rule, ctx } of contexts) {
+      rule.visit(node, ctx);
+    }
+  }
+  for (const { rule, ctx } of ruleDispatch.global) {
+    rule.visit(node, ctx);
+  }
+}
+function collectOverloadCalleeNames(program, collectFiles) {
+  const overloaded = /* @__PURE__ */ new Set();
+  for (const sourceFile of program.getSourceFiles()) {
+    let visit2 = function(node) {
+      if ((ts40.isFunctionDeclaration(node) || ts40.isMethodDeclaration(node)) && node.name !== void 0) {
+        const name = node.name.getText(sourceFile);
+        if (node.body === void 0) {
+          signatures.push(name);
+        } else {
+          implementations.add(name);
+        }
+      }
+      ts40.forEachChild(node, visit2);
+    };
+    var visit = visit2;
+    if (sourceFile.isDeclarationFile) continue;
+    if (sourceFile.fileName.includes("node_modules")) continue;
+    if (collectFiles !== void 0 && !collectFiles.has(sourceFile.fileName)) continue;
+    const implementations = /* @__PURE__ */ new Set();
+    const signatures = [];
+    visit2(sourceFile);
+    for (const name of signatures) {
+      if (implementations.has(name)) overloaded.add(name);
     }
-    list.push(file);
   }
-  return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
+  return overloaded;
 }
 function hasNonPublicModifier(node) {
-  if (!ts39.canHaveModifiers(node)) return false;
-  const mods = ts39.getModifiers(node);
+  if (!ts40.canHaveModifiers(node)) return false;
+  const mods = ts40.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts39.SyntaxKind.PrivateKeyword || m.kind === ts39.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts40.SyntaxKind.PrivateKeyword || m.kind === ts40.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts39.canHaveModifiers(node)) return false;
-  const mods = ts39.getModifiers(node);
+  if (!ts40.canHaveModifiers(node)) return false;
+  const mods = ts40.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts39.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts40.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts39.isTypeAliasDeclaration(node)) {
-    const line = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts40.isTypeAliasDeclaration(node)) {
+    const line = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts39.isInterfaceDeclaration(node)) {
-    const line = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts40.isInterfaceDeclaration(node)) {
+    const line = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  if (ts39.isStringLiteral(node)) return true;
-  if (ts39.isNumericLiteral(node)) return true;
-  if (ts39.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts39.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
-  if (ts39.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  if (ts40.isStringLiteral(node)) return true;
+  if (ts40.isNumericLiteral(node)) return true;
+  if (ts40.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts40.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts40.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts39.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts39.NodeFlags.Const)) return;
+  if (!ts40.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts40.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts39.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts40.isIdentifier(decl.name)) continue;
     if (!isConstantValue(decl.initializer)) continue;
     const valueText = decl.initializer.getText(sourceFile).replace(/\s+/g, " ").trim();
     const valueHash = createHash2("sha256").update(valueText).digest("hex").slice(0, 16);
-    const line = ts39.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts40.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
     registry.add({ name: decl.name.text, file, line, valueHash, valueText, exported });
   }
 }
-function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name, extra) {
-  const line = ts39.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name, extra, bodyAnalysis) {
+  const line = ts40.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
-  const hash = hashFunctionBody(body, sourceFile);
-  const normalizedHash = hashFunctionBodyNormalized(body, sourceFile, paramNames);
-  const bodyLength = bodyTextLength(body, sourceFile);
-  const normalizedBodyLength = normalizedBodyTextLength(body, sourceFile, paramNames);
+  const analysis = bodyAnalysis ?? analyzeFunctionBody(body, sourceFile, paramNames);
   return {
     name,
     file,
     line,
-    hash,
-    normalizedHash,
+    hash: analysis.hash,
+    normalizedHash: analysis.normalizedHash,
     params,
     node: extra.node ?? body,
     exported: extra.exported ?? false,
-    bodyLength,
-    normalizedBodyLength,
+    bodyLength: analysis.bodyLength,
+    normalizedBodyLength: analysis.normalizedBodyLength,
     ...extra
   };
 }
-function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts39.isFunctionDeclaration(node) && node.name && node.body) {
+function collectFunctions(node, file, sourceFile, semantics, registry, resolveSymbols) {
+  if (ts40.isFunctionDeclaration(node) && node.name && node.body) {
     registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, node.name.text, {
       exported: isExported(node),
-      symbol: checker.getSymbolAtLocation(node.name),
+      symbol: resolveSymbols ? semantics.symbolAtLocation(node.name) : void 0,
       node
     }));
   }
-  if (ts39.isVariableStatement(node)) {
+  if (ts40.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts39.isArrowFunction(decl.initializer) && ts39.isIdentifier(decl.name)) {
+      if (decl.initializer && ts40.isArrowFunction(decl.initializer) && ts40.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
-          symbol: checker.getSymbolAtLocation(decl.name),
+          symbol: resolveSymbols ? semantics.symbolAtLocation(decl.name) : void 0,
           node: arrow
         }));
       }
-      if (decl.initializer && ts39.isFunctionExpression(decl.initializer) && ts39.isIdentifier(decl.name)) {
+      if (decl.initializer && ts40.isFunctionExpression(decl.initializer) && ts40.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
             exported,
-            symbol: checker.getSymbolAtLocation(decl.name),
+            symbol: resolveSymbols ? semantics.symbolAtLocation(decl.name) : void 0,
             node: fn
           }));
         }
       }
     }
   }
-  if (ts39.isPropertyAssignment(node) && (ts39.isIdentifier(node.name) || ts39.isStringLiteral(node.name))) {
+  if (ts40.isPropertyAssignment(node) && (ts40.isIdentifier(node.name) || ts40.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts39.isArrowFunction(init)) {
+    if (ts40.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts39.isFunctionExpression(init) && init.body) {
+    if (ts40.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts39.isArrowFunction(node) || ts39.isFunctionExpression(node)) {
+  if (ts40.isArrowFunction(node) || ts40.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts39.isVariableDeclaration(parent) && ts39.isIdentifier(parent.name)) {
-    } else if (ts39.isPropertyAssignment(parent)) {
+    if (ts40.isVariableDeclaration(parent) && ts40.isIdentifier(parent.name)) {
+    } else if (ts40.isPropertyAssignment(parent)) {
     } else {
-      const body = ts39.isArrowFunction(node) ? node.body : node.body;
+      const body = ts40.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
-        if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
+        const params = extractParams(node.parameters, sourceFile);
+        const bodyAnalysis = analyzeFunctionBody(body, sourceFile, params.map((p) => p.name));
+        if (bodyAnalysis.bodyLength >= MIN_ANON_BODY) {
           const name = deriveAnonymousName(node, sourceFile);
-          registry.add(buildFunctionEntry(body, node.parameters, sourceFile, file, node, name, { node }));
+          registry.add(buildFunctionEntry(body, node.parameters, sourceFile, file, node, name, { node }, bodyAnalysis));
         }
       }
     }
   }
-  if (ts39.isMethodDeclaration(node) && node.body && ts39.isIdentifier(node.name)) {
+  if (ts40.isMethodDeclaration(node) && node.body && ts40.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts39.isClassDeclaration(parent)) {
+    if (ts40.isClassDeclaration(parent)) {
       if (hasNonPublicModifier(node)) return;
       const className = parent.name ? parent.name.text : "<anonymous>";
       const name = `${className}.${node.name.text}`;
       const implementsInterface = parent.heritageClauses?.some(
-        (c) => c.token === ts39.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts40.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
-        symbol: checker.getSymbolAtLocation(node.name),
+        symbol: resolveSymbols ? semantics.symbolAtLocation(node.name) : void 0,
         node,
         className,
         implementsInterface
@@ -2821,16 +3248,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts39.isCallExpression(parent)) {
+  const line = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts40.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts39.isPropertyAssignment(grandparent) && ts39.isIdentifier(grandparent.name)) {
+    if (ts40.isPropertyAssignment(grandparent) && ts40.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts39.isIdentifier(parent.expression)) {
+    if (ts40.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts39.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts40.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -2841,7 +3268,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts39.isImportDeclaration(node) && ts39.isStringLiteral(node.moduleSpecifier)) {
+  if (ts40.isImportDeclaration(node) && ts40.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -2853,7 +3280,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts39.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts40.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -2864,9 +3291,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts39.isExportDeclaration(node) && node.moduleSpecifier && ts39.isStringLiteral(node.moduleSpecifier)) {
+  if (ts40.isExportDeclaration(node) && node.moduleSpecifier && ts40.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts39.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts40.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -2879,7 +3306,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts39.isBlock(node)) return;
+  if (!ts40.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -2896,32 +3323,33 @@ function collectStatementSequences(node, file, sourceFile, registry) {
       const firstStmt = window[0];
       const lastStmt = window[window.length - 1];
       if (firstStmt === void 0 || lastStmt === void 0) continue;
-      const line = ts39.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts39.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts40.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts40.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
       registry.add({ file, line, endLine, hash, normalizedHash, statementCount: size, normalizedBodyLength: normalized.length });
     }
   }
 }
 function collectInlineParamTypes(node, file, sourceFile, registry) {
   if (!isInlineParamType(node)) return;
-  const line = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  const line = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
-function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts39.isCallExpression(node)) return;
+function collectCallSites(node, file, sourceFile, semantics, sites, resolveSymbol, resolveOverloadSignatures, overloadCalleeNames) {
+  if (!ts40.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts39.isIdentifier(node.expression)) {
+  if (ts40.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts39.isPropertyAccessExpression(node.expression)) {
+  } else if (ts40.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts39.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-    let symbol = checker.getSymbolAtLocation(node.expression);
-    if (symbol && symbol.flags & ts39.SymbolFlags.Alias) {
-      symbol = checker.getAliasedSymbol(symbol);
+    const line = ts40.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    let symbol = resolveSymbol ? semantics.symbolAtLocation(node.expression) : void 0;
+    if (symbol !== void 0 && symbol.flags & ts40.SymbolFlags.Alias) {
+      symbol = semantics.aliasedSymbol(symbol);
     }
-    const signature = checker.getResolvedSignature(node);
+    const shouldResolveSignature = resolveOverloadSignatures && overloadCalleeNames?.has(calleeName) === true;
+    const signature = shouldResolveSignature ? semantics.resolvedSignature(node) : void 0;
     const resolvedDeclaration = signature?.declaration;
     sites.push({
       calleeName,
@@ -2935,6 +3363,8 @@ function collectCallSites(node, file, sourceFile, checker, sites) {
   }
 }
 function collectAllComments(sourceFile) {
+  const cached = commentCache.get(sourceFile);
+  if (cached !== void 0) return cached;
   const comments = [];
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
@@ -2943,7 +3373,7 @@ function collectAllComments(sourceFile) {
     for (const r of ranges) {
       if (seen.has(r.pos)) continue;
       seen.add(r.pos);
-      const isLine = r.kind === ts39.SyntaxKind.SingleLineCommentTrivia;
+      const isLine = r.kind === ts40.SyntaxKind.SingleLineCommentTrivia;
       comments.push({
         type: isLine ? "Line" : "Block",
         value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -2953,54 +3383,132 @@ function collectAllComments(sourceFile) {
     }
   }
   function visit(node) {
-    addRanges(ts39.getLeadingCommentRanges(source, node.getFullStart()));
-    addRanges(ts39.getTrailingCommentRanges(source, node.getEnd()));
-    ts39.forEachChild(node, visit);
+    addRanges(ts40.getLeadingCommentRanges(source, node.getFullStart()));
+    addRanges(ts40.getTrailingCommentRanges(source, node.getEnd()));
+    ts40.forEachChild(node, visit);
   }
   visit(sourceFile);
+  commentCache.set(sourceFile, comments);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts40 from "typescript";
+import * as ts41 from "typescript";
 import { dirname as dirname3 } from "path";
 var defaultOptions = {
-  target: ts40.ScriptTarget.ESNext,
-  module: ts40.ModuleKind.ESNext,
-  moduleResolution: ts40.ModuleResolutionKind.Bundler,
+  target: ts41.ScriptTarget.ESNext,
+  module: ts41.ModuleKind.ESNext,
+  moduleResolution: ts41.ModuleResolutionKind.Bundler,
   strict: true,
   skipLibCheck: true,
   noEmit: true
 };
 function findTsconfig(file) {
-  return ts40.findConfigFile(dirname3(file), ts40.sys.fileExists, "tsconfig.json");
+  return ts41.findConfigFile(dirname3(file), ts41.sys.fileExists, "tsconfig.json");
 }
-function createProgramForConfig(files, configPath) {
+function createProgramBuildCache() {
+  return {
+    sourceFiles: /* @__PURE__ */ new Map(),
+    readFiles: /* @__PURE__ */ new Map(),
+    fileExists: /* @__PURE__ */ new Map(),
+    directoryExists: /* @__PURE__ */ new Map()
+  };
+}
+function createProgramForConfig(files, configPath, cache) {
   if (configPath) {
-    const configFile = ts40.readConfigFile(configPath, ts40.sys.readFile);
-    const parsed = ts40.parseJsonConfigFileContent(configFile.config, ts40.sys, dirname3(configPath));
-    return ts40.createProgram({
+    const configFile = ts41.readConfigFile(configPath, ts41.sys.readFile);
+    const parsed = ts41.parseJsonConfigFileContent(configFile.config, ts41.sys, dirname3(configPath));
+    const options = { ...parsed.options, skipLibCheck: true };
+    return ts41.createProgram({
       rootNames: files,
-      options: { ...parsed.options, skipLibCheck: true }
+      options,
+      host: maybeCachedCompilerHost(options, cache)
     });
   }
-  return ts40.createProgram({ rootNames: files, options: defaultOptions });
+  return ts41.createProgram({
+    rootNames: files,
+    options: defaultOptions,
+    host: maybeCachedCompilerHost(defaultOptions, cache)
+  });
+}
+function maybeCachedCompilerHost(options, cache) {
+  if (cache === void 0) return void 0;
+  return createCachedCompilerHost(options, cache);
+}
+function createCachedCompilerHost(options, cache) {
+  const host = ts41.createCompilerHost(options);
+  const baseGetSourceFile = host.getSourceFile.bind(host);
+  const baseReadFile = host.readFile.bind(host);
+  const baseFileExists = host.fileExists.bind(host);
+  const baseDirectoryExists = host.directoryExists?.bind(host);
+  function cacheKey(fileName) {
+    return host.getCanonicalFileName(ts41.sys.resolvePath(fileName));
+  }
+  host.readFile = (fileName) => {
+    const key = cacheKey(fileName);
+    if (cache.readFiles.has(key)) return cache.readFiles.get(key);
+    const text = baseReadFile(fileName);
+    cache.readFiles.set(key, text);
+    return text;
+  };
+  host.fileExists = (fileName) => {
+    const key = cacheKey(fileName);
+    const cached = cache.fileExists.get(key);
+    if (cached !== void 0) return cached;
+    const exists = baseFileExists(fileName);
+    cache.fileExists.set(key, exists);
+    return exists;
+  };
+  if (baseDirectoryExists !== void 0) {
+    host.directoryExists = (directoryName) => {
+      const key = cacheKey(directoryName);
+      const cached = cache.directoryExists.get(key);
+      if (cached !== void 0) return cached;
+      const exists = baseDirectoryExists(directoryName);
+      cache.directoryExists.set(key, exists);
+      return exists;
+    };
+  }
+  host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+    if (!isStableCachedSourceFile(fileName)) {
+      return baseGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    }
+    const key = sourceFileCacheKey(cacheKey(fileName), languageVersionOrOptions);
+    if (!shouldCreateNewSourceFile) {
+      const cached = cache.sourceFiles.get(key);
+      if (cached !== void 0) return cached;
+    }
+    const sourceFile = baseGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    if (sourceFile !== void 0) cache.sourceFiles.set(key, sourceFile);
+    return sourceFile;
+  };
+  return host;
+}
+function isStableCachedSourceFile(fileName) {
+  const normalized = fileName.replaceAll("\\", "/");
+  return normalized.includes("/node_modules/") || /\.d\.[cm]?ts$/.test(normalized) || normalized.endsWith(".json");
+}
+function sourceFileCacheKey(fileKey, languageVersionOrOptions) {
+  if (typeof languageVersionOrOptions !== "object") {
+    return `${fileKey}\0${languageVersionOrOptions}\0\0`;
+  }
+  return `${fileKey}\0${languageVersionOrOptions.languageVersion}\0${languageVersionOrOptions.impliedNodeFormat ?? ""}\0${languageVersionOrOptions.jsDocParsingMode ?? ""}`;
 }
 function expandProjectFiles(group) {
   const configs = [group.configPath, ...group.expandConfigPaths ?? []];
   const expanded = new Set(group.scanFiles);
   for (const cp of configs) {
     if (!cp) continue;
-    const configFile = ts40.readConfigFile(cp, ts40.sys.readFile);
-    const parsed = ts40.parseJsonConfigFileContent(configFile.config, ts40.sys, dirname3(cp));
+    const configFile = ts41.readConfigFile(cp, ts41.sys.readFile);
+    const parsed = ts41.parseJsonConfigFileContent(configFile.config, ts41.sys, dirname3(cp));
     for (const f of parsed.fileNames) expanded.add(f);
   }
   return [...expanded];
 }
 function effectiveOptionsKey(configPath) {
   if (!configPath) return "\0default";
-  const configFile = ts40.readConfigFile(configPath, ts40.sys.readFile);
-  const parsed = ts40.parseJsonConfigFileContent(configFile.config, ts40.sys, dirname3(configPath));
+  const configFile = ts41.readConfigFile(configPath, ts41.sys.readFile);
+  const parsed = ts41.parseJsonConfigFileContent(configFile.config, ts41.sys, dirname3(configPath));
   const o = parsed.options;
   return JSON.stringify({
     target: o.target,
@@ -3027,9 +3535,10 @@ function mergeCompatibleGroups(groups) {
     }
     list.push(group);
   }
-  return [...byKey.values()].map((compatible) => {
-    const [primary, ...rest] = compatible;
-    if (!primary) return compatible[0];
+  return [...byKey.values()].flatMap((compatible) => {
+    const primary = compatible[0];
+    if (primary === void 0) return [];
+    const rest = compatible.slice(1);
     if (rest.length === 0) return primary;
     return {
       configPath: primary.configPath,
@@ -3054,32 +3563,95 @@ function groupFilesByTsconfig(scanFiles) {
 }
 function createProgramForGroup(group, options) {
   const rootFiles = options.expandProjectFiles ? expandProjectFiles(group) : group.scanFiles;
-  return createProgramForConfig(rootFiles, group.configPath);
+  return createProgramForConfig(rootFiles, group.configPath, options.cache);
 }
 
 // src/scan/analyze.ts
 function analyzeFiles(files, rules) {
   const tsRules = rules.filter(isTSRule);
   const crossFileRules = rules.filter((r) => !isTSRule(r));
+  const indexNeeds = collectIndexNeeds(crossFileRules);
+  if (!requiresProgram(tsRules, indexNeeds)) {
+    return analyzeSourceOnlyFiles(files, tsRules, crossFileRules, indexNeeds);
+  }
   const groupConfigs = mergeCompatibleGroups(groupFilesByTsconfig(files));
   if (groupConfigs.length === 0) return [];
   const allDiagnostics = [];
   const allFiles = /* @__PURE__ */ new Map();
-  const allowedAll = new Set(files);
+  const programCache = createProgramBuildCache();
   for (const groupConfig of groupConfigs) {
-    const program = createProgramForGroup(groupConfig, { expandProjectFiles: true });
+    const projectIndex = createProjectIndex();
+    const program = createProgramForGroup(groupConfig, { expandProjectFiles: true, cache: programCache });
     const allowed = new Set(groupConfig.scanFiles);
-    const { index, diagnostics } = collectProject(program, tsRules, allowed);
+    const collectFiles = indexNeeds.size > 0 ? new Set(expandProjectFiles(groupConfig).filter(isAnalyzableSourcePath)) : /* @__PURE__ */ new Set();
+    const { diagnostics } = collectProject(program, tsRules, allowed, {
+      collectFiles,
+      needs: indexNeeds,
+      index: projectIndex
+    });
     allDiagnostics.push(...diagnostics);
-    for (const rule of crossFileRules) {
-      const ruleDiags = rule.analyze(index);
-      allDiagnostics.push(...ruleDiags.filter((d) => allowedAll.has(d.file)));
+    allDiagnostics.push(...runCrossFileRules(crossFileRules, projectIndex, allowed));
+    addFileData(allFiles, projectIndex, allowed);
+  }
+  return finalizeDiagnostics(allDiagnostics, allFiles);
+}
+function analyzeSourceOnlyFiles(files, tsRules, crossFileRules, indexNeeds) {
+  const diagnostics = [];
+  const allFiles = /* @__PURE__ */ new Map();
+  const groupConfigs = mergeCompatibleGroups(groupFilesByTsconfig(files));
+  for (const groupConfig of groupConfigs) {
+    const projectIndex = createProjectIndex();
+    const allowed = new Set(groupConfig.scanFiles.filter(isAnalyzableSourcePath));
+    const collectFiles = (indexNeeds.size > 0 ? expandProjectFiles(groupConfig) : groupConfig.scanFiles).filter(isAnalyzableSourcePath);
+    for (const file of collectFiles) {
+      const source = readFileSync(file, "utf8");
+      const result = collectSourceText(file, source, allowed.has(file) ? tsRules : [], {
+        index: projectIndex,
+        needs: indexNeeds,
+        retainFile: allowed.has(file) || indexNeeds.has("files")
+      });
+      diagnostics.push(...result.diagnostics);
     }
-    for (const [k, v] of index.files) {
-      allFiles.set(k, { source: v.source, comments: v.comments });
+    diagnostics.push(...runCrossFileRules(crossFileRules, projectIndex, allowed));
+    addFileData(allFiles, projectIndex, allowed);
+  }
+  return finalizeDiagnostics(diagnostics, allFiles);
+}
+function runCrossFileRules(rules, projectIndex, allowed) {
+  const diagnostics = [];
+  const crossFileContext = { reportableFiles: allowed };
+  for (const rule of rules) {
+    const ruleDiags = rule.analyze(projectIndex, crossFileContext);
+    diagnostics.push(...ruleDiags.filter((d) => allowed.has(d.file)));
+  }
+  return diagnostics;
+}
+function addFileData(files, projectIndex, allowed) {
+  for (const [k, v] of projectIndex.files) {
+    if (!allowed.has(k)) continue;
+    files.set(k, { source: v.source, sourceFile: v.sourceFile });
+  }
+}
+function isAnalyzableSourcePath(file) {
+  const normalized = file.replaceAll("\\", "/");
+  if (normalized.includes("/node_modules/")) return false;
+  return !/\.d\.[cm]?ts$/i.test(normalized);
+}
+function requiresProgram(tsRules, indexNeeds) {
+  if (tsRules.some((rule) => rule.requiresTypeInfo !== false)) return true;
+  return indexNeeds.has("functionSymbols") || indexNeeds.has("callSiteSymbols") || indexNeeds.has("overloadCallSignatures");
+}
+function collectIndexNeeds(rules) {
+  const needs = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    for (const need of rule.requires ?? []) {
+      needs.add(need);
     }
   }
-  return finalizeDiagnostics(allDiagnostics, allFiles);
+  if (needs.has("functionSymbols")) needs.add("functions");
+  if (needs.has("callSiteSymbols") || needs.has("overloadCallSignatures")) needs.add("callSites");
+  if (needs.has("overloadCallSignatures")) needs.add("callSiteSymbols");
+  return needs;
 }
 function dedupeDiagnostics(diagnostics) {
   const seen = /* @__PURE__ */ new Set();
@@ -3109,7 +3681,7 @@ function finalizeDiagnostics(diagnostics, files) {
       finalized.push(...fileDiagnostics);
       continue;
     }
-    finalized.push(...annotateAndFilter(fileDiagnostics, fileData.comments, fileData.source));
+    finalized.push(...annotateAndFilter(fileDiagnostics, collectAllComments(fileData.sourceFile), fileData.source));
   }
   return dedupeDiagnostics(finalized);
 }
@@ -3222,7 +3794,7 @@ function lineAt(source, offset) {
 // src/scan/discover.ts
 import fg from "fast-glob";
 import ignore from "ignore";
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { relative, resolve as resolve2, sep } from "path";
 async function discoverFiles(config) {
   const globs = expandGlobs(config.paths);
@@ -3246,7 +3818,7 @@ function expandGlobs(paths) {
 function applyGitIgnore(files) {
   const gitIgnorePath = resolve2(process.cwd(), ".gitignore");
   if (!existsSync2(gitIgnorePath)) return files;
-  const matcher = ignore().add(readFileSync(gitIgnorePath, "utf8"));
+  const matcher = ignore().add(readFileSync2(gitIgnorePath, "utf8"));
   return files.filter((file) => {
     const rel = relative(process.cwd(), file);
     if (rel.startsWith("..")) return true;
@@ -3360,4 +3932,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-XCFM224P.js.map
+//# sourceMappingURL=chunk-VHRD75ET.js.map