unguard 0.10.4 → 0.12.0

package/dist/{chunk-7UXUNJSF.js → chunk-HE647T6E.js}

@@ -314,9 +314,17 @@ function isTupleSlotDefinitelyPresent(type, index, checker) {
     return type.types.every((member) => isTupleSlotDefinitelyPresent(member, index, checker));
   }
   const apparent = checker.getApparentType(type);
-  if (!checker.isTupleType(apparent)) return false;
+  if (!isTupleTypeReference(apparent, checker)) return false;
   return index < apparent.target.minLength;
 }
+function isTupleTypeReference(type, checker) {
+  if (!checker.isTupleType(type)) return false;
+  if (!("target" in type)) return false;
+  const target = type.target;
+  if (typeof target !== "object" || target === null) return false;
+  if (!("minLength" in target)) return false;
+  return typeof target.minLength === "number";
+}
 
 // src/rules/ts/no-optional-call.ts
 import * as ts7 from "typescript";
@@ -535,43 +543,61 @@ var duplicateInlineTypeInParams = {
   }
 };
 
-// src/rules/ts/no-type-assertion.ts
+// src/rules/ts/no-inline-type-assertion.ts
 import * as ts14 from "typescript";
+var noInlineTypeAssertion = {
+  kind: "ts",
+  id: "no-inline-type-assertion",
+  severity: "error",
+  message: "Inline object type assertions (`x as { ... }`) hide missing named types; extract a named type or fix the upstream type",
+  visit(node, ctx) {
+    if (ts14.isAsExpression(node) && ts14.isTypeLiteralNode(node.type)) {
+      ctx.report(node);
+      return;
+    }
+    if (ts14.isTypeAssertionExpression(node) && ts14.isTypeLiteralNode(node.type)) {
+      ctx.report(node);
+    }
+  }
+};
+
+// src/rules/ts/no-type-assertion.ts
+import * as ts15 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",
   visit(node, ctx) {
-    if (!ts14.isAsExpression(node)) return;
-    if (!ts14.isAsExpression(node.expression)) return;
-    if (node.expression.type.kind !== ts14.SyntaxKind.UnknownKeyword) return;
+    if (!ts15.isAsExpression(node)) return;
+    if (!ts15.isAsExpression(node.expression)) return;
+    if (node.expression.type.kind !== ts15.SyntaxKind.UnknownKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/no-redundant-existence-guard.ts
-import * as ts15 from "typescript";
+import * as ts16 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",
   visit(node, ctx) {
-    if (!ts15.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts15.SyntaxKind.AmpersandAmpersandToken) return;
+    if (!ts16.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts16.SyntaxKind.AmpersandAmpersandToken) return;
     const left = node.left;
     const right = node.right;
-    if (ts15.isIdentifier(left) && accessesIdentifier(right, left.text)) {
+    if (ts16.isIdentifier(left) && accessesIdentifier(right, left.text)) {
       if (ctx.isNullable(left)) return;
       ctx.report(node);
       return;
     }
-    if (ts15.isBinaryExpression(left) && isNullCheck(left)) {
+    if (ts16.isBinaryExpression(left) && isNullCheck(left)) {
       const checked = getNullCheckedIdentifier(left);
       if (checked && accessesIdentifier(right, checked)) {
-        const identNode = ts15.isIdentifier(left.left) ? left.left : left.right;
-        if (ts15.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
+        const identNode = ts16.isIdentifier(left.left) ? left.left : left.right;
+        if (ts16.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
           ctx.report(node);
         }
       }
@@ -580,27 +606,27 @@ var noRedundantExistenceGuard = {
 };
 function accessesIdentifier(expr, name) {
   const root = getExpressionRoot(expr);
-  return ts15.isIdentifier(root) && root.text === name;
+  return ts16.isIdentifier(root) && root.text === name;
 }
 function getExpressionRoot(node) {
-  if (ts15.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts15.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts15.isCallExpression(node)) return getExpressionRoot(node.expression);
+  if (ts16.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts16.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts16.isCallExpression(node)) return getExpressionRoot(node.expression);
   return node;
 }
 function isNullCheck(expr) {
   const op = expr.operatorToken.kind;
-  if (op !== ts15.SyntaxKind.ExclamationEqualsToken && op !== ts15.SyntaxKind.ExclamationEqualsEqualsToken) return false;
+  if (op !== ts16.SyntaxKind.ExclamationEqualsToken && op !== ts16.SyntaxKind.ExclamationEqualsEqualsToken) return false;
   return isNullishLiteral(expr.right) || isNullishLiteral(expr.left);
 }
 function getNullCheckedIdentifier(expr) {
-  if (ts15.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
-  if (ts15.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
+  if (ts16.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
+  if (ts16.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
   return null;
 }
 
 // src/rules/ts/prefer-default-param-value.ts
-import * as ts16 from "typescript";
+import * as ts17 from "typescript";
 var preferDefaultParamValue = {
   kind: "ts",
   id: "prefer-default-param-value",
@@ -611,21 +637,21 @@ var preferDefaultParamValue = {
     if (result === null) return;
     const { statements: stmts, fn } = result;
     const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts16.isExpressionStatement(firstStmt)) return;
+    if (firstStmt === void 0 || !ts17.isExpressionStatement(firstStmt)) return;
     const expr = firstStmt.expression;
-    if (!ts16.isBinaryExpression(expr) || expr.operatorToken.kind !== ts16.SyntaxKind.EqualsToken) return;
+    if (!ts17.isBinaryExpression(expr) || expr.operatorToken.kind !== ts17.SyntaxKind.EqualsToken) return;
     const right = expr.right;
-    if (!ts16.isBinaryExpression(right) || right.operatorToken.kind !== ts16.SyntaxKind.QuestionQuestionToken) return;
-    if (!ts16.isIdentifier(expr.left) || !ts16.isIdentifier(right.left)) return;
+    if (!ts17.isBinaryExpression(right) || right.operatorToken.kind !== ts17.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts17.isIdentifier(expr.left) || !ts17.isIdentifier(right.left)) return;
     if (expr.left.text !== right.left.text) return;
     const paramName = expr.left.text;
-    const isParam = fn.parameters.some((p) => ts16.isIdentifier(p.name) && p.name.text === paramName);
+    const isParam = fn.parameters.some((p) => ts17.isIdentifier(p.name) && p.name.text === paramName);
     if (isParam) ctx.report(firstStmt);
   }
 };
 
 // src/rules/ts/prefer-required-param-with-guard.ts
-import * as ts17 from "typescript";
+import * as ts18 from "typescript";
 var preferRequiredParamWithGuard = {
   kind: "ts",
   id: "prefer-required-param-with-guard",
@@ -636,33 +662,33 @@ var preferRequiredParamWithGuard = {
     if (result === null) return;
     const { statements: stmts, fn } = result;
     const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts17.isIfStatement(firstStmt)) return;
+    if (firstStmt === void 0 || !ts18.isIfStatement(firstStmt)) return;
     const test = firstStmt.expression;
     let guardedName = null;
-    if (ts17.isPrefixUnaryExpression(test) && test.operator === ts17.SyntaxKind.ExclamationToken) {
-      if (ts17.isIdentifier(test.operand)) guardedName = test.operand.text;
+    if (ts18.isPrefixUnaryExpression(test) && test.operator === ts18.SyntaxKind.ExclamationToken) {
+      if (ts18.isIdentifier(test.operand)) guardedName = test.operand.text;
     }
-    if (ts17.isBinaryExpression(test)) {
+    if (ts18.isBinaryExpression(test)) {
       const op = test.operatorToken.kind;
-      if (op === ts17.SyntaxKind.EqualsEqualsEqualsToken || op === ts17.SyntaxKind.EqualsEqualsToken) {
-        if (ts17.isIdentifier(test.left) && ts17.isIdentifier(test.right) && test.right.text === "undefined") {
+      if (op === ts18.SyntaxKind.EqualsEqualsEqualsToken || op === ts18.SyntaxKind.EqualsEqualsToken) {
+        if (ts18.isIdentifier(test.left) && ts18.isIdentifier(test.right) && test.right.text === "undefined") {
           guardedName = test.left.text;
         }
       }
     }
     if (!guardedName) return;
     const consequent = firstStmt.thenStatement;
-    const isGuard = ts17.isReturnStatement(consequent) || ts17.isThrowStatement(consequent) || ts17.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts17.isReturnStatement(consequent.statements[0]) || ts17.isThrowStatement(consequent.statements[0]));
+    const isGuard = ts18.isReturnStatement(consequent) || ts18.isThrowStatement(consequent) || ts18.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts18.isReturnStatement(consequent.statements[0]) || ts18.isThrowStatement(consequent.statements[0]));
     if (!isGuard) return;
     const isOptional = fn.parameters.some(
-      (p) => ts17.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
+      (p) => ts18.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
     );
     if (isOptional) ctx.report(firstStmt);
   }
 };
 
 // src/rules/cross-file/duplicate-type-declaration.ts
-import * as ts18 from "typescript";
+import * as ts19 from "typescript";
 var duplicateTypeDeclaration = {
   id: "duplicate-type-declaration",
   severity: "warning",
@@ -686,13 +712,13 @@ var duplicateTypeDeclaration = {
   }
 };
 function isTrivialObjectShape(node) {
-  if (ts18.isTypeLiteralNode(node)) return node.members.length <= 1;
-  if (ts18.isInterfaceDeclaration(node)) return node.members.length <= 1;
+  if (ts19.isTypeLiteralNode(node)) return node.members.length <= 1;
+  if (ts19.isInterfaceDeclaration(node)) return node.members.length <= 1;
   return false;
 }
 
 // src/rules/cross-file/duplicate-function-declaration.ts
-import * as ts19 from "typescript";
+import * as ts20 from "typescript";
 var duplicateFunctionDeclaration = {
   id: "duplicate-function-declaration",
   severity: "warning",
@@ -717,13 +743,13 @@ var duplicateFunctionDeclaration = {
   }
 };
 function getBodyBlock(node) {
-  if (ts19.isFunctionDeclaration(node) || ts19.isFunctionExpression(node)) return node.body;
-  if (ts19.isArrowFunction(node)) return ts19.isBlock(node.body) ? node.body : void 0;
-  if (ts19.isMethodDeclaration(node)) return node.body;
+  if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node)) return node.body;
+  if (ts20.isArrowFunction(node)) return ts20.isBlock(node.body) ? node.body : void 0;
+  if (ts20.isMethodDeclaration(node)) return node.body;
   return void 0;
 }
 function isSingleStatement(node) {
-  if (ts19.isArrowFunction(node) && !ts19.isBlock(node.body)) return true;
+  if (ts20.isArrowFunction(node) && !ts20.isBlock(node.body)) return true;
   const body = getBodyBlock(node);
   return body !== void 0 && body.statements.length <= 1;
 }
@@ -731,8 +757,8 @@ function isSetter(node) {
   const body = getBodyBlock(node);
   if (!body || body.statements.length !== 1) return false;
   const stmt = body.statements[0];
-  if (stmt === void 0 || !ts19.isExpressionStatement(stmt)) return false;
-  return ts19.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts19.SyntaxKind.EqualsToken;
+  if (stmt === void 0 || !ts20.isExpressionStatement(stmt)) return false;
+  return ts20.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts20.SyntaxKind.EqualsToken;
 }
 
 // src/rules/cross-file/optional-arg-always-used.ts
@@ -767,14 +793,14 @@ var optionalArgAlwaysUsed = {
 };
 
 // src/rules/ts/no-catch-return.ts
-import * as ts20 from "typescript";
+import * as ts21 from "typescript";
 var noCatchReturn = {
   kind: "ts",
   id: "no-catch-return",
   severity: "warning",
   message: "Catch block silently returns a fallback value with no logging; rethrow, log the error, or let it propagate",
   visit(node, ctx) {
-    if (!ts20.isCatchClause(node)) return;
+    if (!ts21.isCatchClause(node)) return;
     const block = node.block;
     if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
       ctx.report(node);
@@ -784,57 +810,57 @@ var noCatchReturn = {
 function walkBlock(block, predicate) {
   function visit(node) {
     if (predicate(node)) return true;
-    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return false;
-    return ts20.forEachChild(node, visit) ?? false;
+    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return false;
+    return ts21.forEachChild(node, visit) ?? false;
   }
-  return ts20.forEachChild(block, visit) ?? false;
+  return ts21.forEachChild(block, visit) ?? false;
 }
 function hasReturn(block) {
-  return walkBlock(block, (n) => ts20.isReturnStatement(n));
+  return walkBlock(block, (n) => ts21.isReturnStatement(n));
 }
 function hasThrow(block) {
-  return walkBlock(block, (n) => ts20.isThrowStatement(n));
+  return walkBlock(block, (n) => ts21.isThrowStatement(n));
 }
 var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
 function hasLogging(block) {
   return walkBlock(block, (n) => {
-    if (!ts20.isCallExpression(n)) return false;
+    if (!ts21.isCallExpression(n)) return false;
     const callee = n.expression;
-    if (!ts20.isPropertyAccessExpression(callee)) return false;
-    if (!ts20.isIdentifier(callee.expression)) return false;
+    if (!ts21.isPropertyAccessExpression(callee)) return false;
+    if (!ts21.isIdentifier(callee.expression)) return false;
     return LOG_OBJECTS.has(callee.expression.text);
   });
 }
 
 // src/rules/ts/no-error-rewrap.ts
-import * as ts21 from "typescript";
+import * as ts22 from "typescript";
 var noErrorRewrap = {
   kind: "ts",
   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",
   visit(node, ctx) {
-    if (!ts21.isCatchClause(node)) return;
+    if (!ts22.isCatchClause(node)) return;
     if (!node.variableDeclaration) return;
     const param = node.variableDeclaration.name;
-    if (!ts21.isIdentifier(param)) return;
+    if (!ts22.isIdentifier(param)) return;
     const catchName = param.text;
     findRewraps(node.block, catchName, ctx);
   }
 };
 function findRewraps(block, catchName, ctx) {
   function visit(node) {
-    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return;
-    if (ts21.isThrowStatement(node) && node.expression && ts21.isNewExpression(node.expression)) {
+    if (ts22.isFunctionDeclaration(node) || ts22.isFunctionExpression(node) || ts22.isArrowFunction(node)) return;
+    if (ts22.isThrowStatement(node) && node.expression && ts22.isNewExpression(node.expression)) {
       const args = node.expression.arguments;
       if (args && args.length > 0 && referencesName(args, catchName) && !hasCauseArg(args)) {
         ctx.report(node);
       }
       return;
     }
-    ts21.forEachChild(node, visit);
+    ts22.forEachChild(node, visit);
   }
-  ts21.forEachChild(block, visit);
+  ts22.forEachChild(block, visit);
 }
 function referencesName(args, name) {
   for (const arg of args) {
@@ -843,15 +869,15 @@ function referencesName(args, name) {
   return false;
 }
 function containsIdentifier(node, name) {
-  if (ts21.isIdentifier(node) && node.text === name) return true;
-  return ts21.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+  if (ts22.isIdentifier(node) && node.text === name) return true;
+  return ts22.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
 }
 function hasCauseArg(args) {
   for (const arg of args) {
-    if (ts21.isObjectLiteralExpression(arg)) {
+    if (ts22.isObjectLiteralExpression(arg)) {
       for (const prop of arg.properties) {
-        if (ts21.isPropertyAssignment(prop) && ts21.isIdentifier(prop.name) && prop.name.text === "cause") return true;
-        if (ts21.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
+        if (ts22.isPropertyAssignment(prop) && ts22.isIdentifier(prop.name) && prop.name.text === "cause") return true;
+        if (ts22.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
       }
     }
   }
@@ -859,7 +885,7 @@ function hasCauseArg(args) {
 }
 
 // src/rules/cross-file/explicit-null-arg.ts
-import * as ts22 from "typescript";
+import * as ts23 from "typescript";
 var explicitNullArg = {
   id: "explicit-null-arg",
   severity: "warning",
@@ -879,7 +905,7 @@ var explicitNullArg = {
         const arg = site.node.arguments[i];
         if (arg === void 0) continue;
         if (isNullishLiteral(arg)) {
-          const val = arg.kind === ts22.SyntaxKind.NullKeyword ? "null" : "undefined";
+          const val = arg.kind === ts23.SyntaxKind.NullKeyword ? "null" : "undefined";
           diagnostics.push({
             ruleId: this.id,
             severity: this.severity,
@@ -952,7 +978,7 @@ function resolveCandidates(fromFile, specifier) {
 }
 
 // src/rules/cross-file/duplicate-type-name.ts
-import * as ts23 from "typescript";
+import * as ts24 from "typescript";
 var duplicateTypeName = {
   id: "duplicate-type-name",
   severity: "warning",
@@ -963,7 +989,7 @@ var duplicateTypeName = {
       const hashes = new Set(group.map((e) => e.hash));
       if (hashes.size === 1) continue;
       const hasInferredType = group.some(
-        (e) => !ts23.isTypeLiteralNode(e.node) && !ts23.isInterfaceDeclaration(e.node)
+        (e) => !ts24.isTypeLiteralNode(e.node) && !ts24.isInterfaceDeclaration(e.node)
       );
       if (hasInferredType) continue;
       reportDuplicateGroup(
@@ -1003,21 +1029,21 @@ var duplicateConstantDeclaration = {
 };
 
 // src/rules/ts/no-dynamic-import.ts
-import * as ts24 from "typescript";
+import * as ts25 from "typescript";
 var noDynamicImport = {
   kind: "ts",
   id: "no-dynamic-import",
   severity: "error",
   message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
   visit(node, ctx) {
-    if (!ts24.isCallExpression(node)) return;
-    if (node.expression.kind !== ts24.SyntaxKind.ImportKeyword) return;
+    if (!ts25.isCallExpression(node)) return;
+    if (node.expression.kind !== ts25.SyntaxKind.ImportKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/cross-file/near-duplicate-function.ts
-import * as ts25 from "typescript";
+import * as ts26 from "typescript";
 var nearDuplicateFunction = {
   id: "near-duplicate-function",
   severity: "warning",
@@ -1041,24 +1067,24 @@ var nearDuplicateFunction = {
   }
 };
 function getFunctionBody(node) {
-  if (ts25.isFunctionDeclaration(node) || ts25.isFunctionExpression(node)) return node.body;
-  if (ts25.isArrowFunction(node)) return node.body;
-  if (ts25.isMethodDeclaration(node)) return node.body;
+  if (ts26.isFunctionDeclaration(node) || ts26.isFunctionExpression(node)) return node.body;
+  if (ts26.isArrowFunction(node)) return node.body;
+  if (ts26.isMethodDeclaration(node)) return node.body;
   return void 0;
 }
 function getTopLevelStatementCount(body) {
-  if (ts25.isBlock(body)) return body.statements.length;
+  if (ts26.isBlock(body)) return body.statements.length;
   return 1;
 }
 function hasControlFlow(node) {
   let found = false;
   function visit(current) {
     if (found) return;
-    if (ts25.isIfStatement(current) || ts25.isSwitchStatement(current) || ts25.isTryStatement(current) || ts25.isForStatement(current) || ts25.isForInStatement(current) || ts25.isForOfStatement(current) || ts25.isWhileStatement(current) || ts25.isDoStatement(current)) {
+    if (ts26.isIfStatement(current) || ts26.isSwitchStatement(current) || ts26.isTryStatement(current) || ts26.isForStatement(current) || ts26.isForInStatement(current) || ts26.isForOfStatement(current) || ts26.isWhileStatement(current) || ts26.isDoStatement(current)) {
       found = true;
       return;
     }
-    ts25.forEachChild(current, visit);
+    ts26.forEachChild(current, visit);
   }
   visit(node);
   return found;
@@ -1071,36 +1097,36 @@ function isSimpleStructure(entry) {
 }
 
 // src/rules/cross-file/trivial-wrapper.ts
-import * as ts26 from "typescript";
+import * as ts27 from "typescript";
 function getFunctionBody2(node) {
-  if (ts26.isFunctionDeclaration(node) || ts26.isFunctionExpression(node)) {
+  if (ts27.isFunctionDeclaration(node) || ts27.isFunctionExpression(node)) {
     return node.body;
   }
-  if (ts26.isArrowFunction(node)) {
+  if (ts27.isArrowFunction(node)) {
     return node.body;
   }
-  if (ts26.isMethodDeclaration(node)) {
+  if (ts27.isMethodDeclaration(node)) {
     return node.body;
   }
   return void 0;
 }
 function getCalleeName(expr) {
-  if (ts26.isIdentifier(expr)) return expr.text;
-  if (ts26.isPropertyAccessExpression(expr)) return expr.name.text;
+  if (ts27.isIdentifier(expr)) return expr.text;
+  if (ts27.isPropertyAccessExpression(expr)) return expr.name.text;
   return void 0;
 }
 function getTrivialCallTarget(fn) {
   const body = getFunctionBody2(fn.node);
   if (!body) return null;
   let callExpr;
-  if (ts26.isBlock(body)) {
+  if (ts27.isBlock(body)) {
     if (body.statements.length !== 1) return null;
     const stmt = body.statements[0];
-    if (!stmt || !ts26.isReturnStatement(stmt) || !stmt.expression) return null;
-    if (!ts26.isCallExpression(stmt.expression)) return null;
+    if (!stmt || !ts27.isReturnStatement(stmt) || !stmt.expression) return null;
+    if (!ts27.isCallExpression(stmt.expression)) return null;
     callExpr = stmt.expression;
   } else {
-    if (!ts26.isCallExpression(body)) return null;
+    if (!ts27.isCallExpression(body)) return null;
     callExpr = body;
   }
   const calleeName = getCalleeName(callExpr.expression);
@@ -1108,7 +1134,7 @@ function getTrivialCallTarget(fn) {
   const paramNames = fn.params.map((p) => p.name);
   const args = callExpr.arguments;
   for (const arg of args) {
-    if (!ts26.isIdentifier(arg)) return null;
+    if (!ts27.isIdentifier(arg)) return null;
     if (!paramNames.includes(arg.text)) return null;
   }
   return { calleeName };
@@ -1278,6 +1304,177 @@ var duplicateStatementSequence = {
   }
 };
 
+// src/rules/cross-file/dead-overload.ts
+import * as ts28 from "typescript";
+var deadOverload = {
+  id: "dead-overload",
+  severity: "warning",
+  message: "Overload signature has no matching call sites in the project",
+  analyze(project) {
+    const diagnostics = [];
+    for (const [file, { sourceFile }] of project.files) {
+      for (const family of collectOverloadFamilies(sourceFile, file)) {
+        const matchedOverloads = /* @__PURE__ */ new Set();
+        for (const site of project.callSites) {
+          const declaration = site.resolvedDeclaration;
+          if (declaration === void 0) continue;
+          if (family.overloads.includes(declaration)) {
+            matchedOverloads.add(declaration);
+          }
+        }
+        if (matchedOverloads.size === 0) continue;
+        const deadOverloads = family.overloads.filter((overload) => !matchedOverloads.has(overload));
+        const liveOverloads = family.overloads.filter((overload) => matchedOverloads.has(overload));
+        for (const overload of deadOverloads) {
+          diagnostics.push({
+            ruleId: this.id,
+            severity: this.severity,
+            message: buildMessage(family, overload, deadOverloads, liveOverloads),
+            file,
+            line: lineOf(sourceFile, overload),
+            column: 1
+          });
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+function buildMessage(family, overload, deadOverloads, liveOverloads) {
+  const base = `Overload signature for "${family.name}" has no matching call sites in the project`;
+  if (!shouldMentionCascade(family, overload, deadOverloads, liveOverloads)) {
+    return base;
+  }
+  return `${base}; removing it may let you collapse to the remaining constrained signature and drop implementation casts`;
+}
+function shouldMentionCascade(family, overload, deadOverloads, liveOverloads) {
+  if (deadOverloads.length !== 1 || liveOverloads.length !== 1) return false;
+  if (deadOverloads[0] !== overload) return false;
+  const liveOverload = liveOverloads[0];
+  if (liveOverload === void 0) return false;
+  if (family.implementation.typeParameters === void 0 || liveOverload.typeParameters === void 0) return false;
+  const body = family.implementation.body;
+  if (body === void 0) return false;
+  const implementationTypeParams = family.implementation.typeParameters;
+  const liveTypeParams = liveOverload.typeParameters;
+  if (implementationTypeParams.length === 0 || implementationTypeParams.length !== liveTypeParams.length) return false;
+  const constrainedParams = implementationTypeParams.flatMap((typeParam, index) => {
+    const liveTypeParam = liveTypeParams[index];
+    if (liveTypeParam === void 0) return [];
+    if (typeParam.constraint !== void 0) return [];
+    if (liveTypeParam.constraint === void 0) return [];
+    return [{
+      paramName: typeParam.name.text,
+      constraintText: normalizeText(liveTypeParam.constraint.getText(family.sourceFile))
+    }];
+  });
+  if (constrainedParams.length === 0) return false;
+  return constrainedParams.some(
+    ({ paramName, constraintText }) => hasIntersectionCast(body, family.sourceFile, paramName, constraintText)
+  );
+}
+function hasIntersectionCast(body, sourceFile, paramName, constraintText) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts28.isAsExpression(node) || ts28.isTypeAssertionExpression(node)) {
+      if (isConstraintIntersection(node.type, sourceFile, paramName, constraintText)) {
+        found = true;
+        return;
+      }
+    }
+    ts28.forEachChild(node, visit);
+  }
+  visit(body);
+  return found;
+}
+function isConstraintIntersection(typeNode, sourceFile, paramName, constraintText) {
+  const target = unwrapParenthesizedType(typeNode);
+  if (!ts28.isIntersectionTypeNode(target)) return false;
+  let hasParam = false;
+  let hasConstraint = false;
+  for (const part of target.types) {
+    const text = normalizeText(unwrapParenthesizedType(part).getText(sourceFile));
+    if (text === paramName) hasParam = true;
+    if (text === constraintText) hasConstraint = true;
+  }
+  return hasParam && hasConstraint;
+}
+function unwrapParenthesizedType(typeNode) {
+  let current = typeNode;
+  while (ts28.isParenthesizedTypeNode(current)) {
+    current = current.type;
+  }
+  return current;
+}
+function collectOverloadFamilies(sourceFile, file) {
+  const families = [];
+  collectFromList(sourceFile.statements, sourceFile, file, families);
+  function visit(node) {
+    if (ts28.isClassDeclaration(node) || ts28.isClassExpression(node)) {
+      collectFromList(node.members, sourceFile, file, families);
+    }
+    ts28.forEachChild(node, visit);
+  }
+  ts28.forEachChild(sourceFile, visit);
+  return families;
+}
+function collectFromList(nodes, sourceFile, file, families) {
+  for (let index = 0; index < nodes.length; index++) {
+    const current = asOverloadDeclaration(nodes[index]);
+    const name = current ? getDeclarationName(current) : null;
+    if (current === null || name === null) continue;
+    const run = [current];
+    let nextIndex = index + 1;
+    while (nextIndex < nodes.length) {
+      const next = asOverloadDeclaration(nodes[nextIndex]);
+      if (next === null) break;
+      if (getDeclarationName(next) !== name) break;
+      run.push(next);
+      nextIndex++;
+    }
+    const family = toOverloadFamily(run, name, file, sourceFile);
+    if (family !== null) {
+      families.push(family);
+    }
+    index = nextIndex - 1;
+  }
+}
+function toOverloadFamily(run, name, file, sourceFile) {
+  if (run.length < 2) return null;
+  const implementation = run.at(-1);
+  if (implementation === void 0 || implementation.body === void 0) return null;
+  if (run.slice(0, -1).some((declaration) => declaration.body !== void 0)) return null;
+  return {
+    name,
+    file,
+    sourceFile,
+    overloads: run.slice(0, -1),
+    implementation
+  };
+}
+function asOverloadDeclaration(node) {
+  if (node === void 0) return null;
+  if (ts28.isFunctionDeclaration(node)) return node;
+  if (ts28.isMethodDeclaration(node)) return node;
+  return null;
+}
+function getDeclarationName(node) {
+  if (ts28.isFunctionDeclaration(node)) {
+    return node.name?.text ?? null;
+  }
+  if (ts28.isIdentifier(node.name) || ts28.isStringLiteral(node.name) || ts28.isNumericLiteral(node.name)) {
+    return node.name.text;
+  }
+  return null;
+}
+function lineOf(sourceFile, node) {
+  return ts28.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+}
+function normalizeText(text) {
+  return text.replace(/\s+/g, "");
+}
+
 // src/rules/index.ts
 var allRules = [
   noEmptyCatch,
@@ -1293,6 +1490,7 @@ var allRules = [
   noAnyCast,
   noExplicitAnyAnnotation,
   duplicateInlineTypeInParams,
+  noInlineTypeAssertion,
   noTypeAssertion,
   noRedundantExistenceGuard,
   preferDefaultParamValue,
@@ -1311,11 +1509,13 @@ var allRules = [
   trivialWrapper,
   unusedExport,
   duplicateFile,
-  duplicateStatementSequence
+  duplicateStatementSequence,
+  deadOverload
 ];
 var ruleMetadata = {
   "no-any-cast": { category: "type-evasion", tags: ["safety"] },
   "no-explicit-any-annotation": { category: "type-evasion", tags: ["safety"] },
+  "no-inline-type-assertion": { category: "type-evasion", tags: ["safety"] },
   "no-type-assertion": { category: "type-evasion", tags: ["safety"] },
   "no-ts-ignore": { category: "type-evasion", tags: ["safety"] },
   "no-optional-property-access": { category: "defensive-code", tags: ["type-aware"] },
@@ -1345,7 +1545,8 @@ var ruleMetadata = {
   "trivial-wrapper": { category: "cross-file", tags: ["duplicate"] },
   "unused-export": { category: "cross-file", tags: ["api"] },
   "duplicate-file": { category: "cross-file", tags: ["duplicate"] },
-  "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] }
+  "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] },
+  "dead-overload": { category: "cross-file", tags: ["api", "type-evasion"] }
 };
 function getRuleMetadata(ruleId) {
   const metadata = ruleMetadata[ruleId];
@@ -1405,32 +1606,32 @@ function isFailOn(value) {
 }
 
 // src/collect/index.ts
-import * as ts29 from "typescript";
+import * as ts31 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts27 from "typescript";
+import * as ts29 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 (ts27.isTypeLiteralNode(node)) {
+  if (ts29.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts27.isInterfaceDeclaration(node)) {
+  if (ts29.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts27.isPropertySignature(node)) {
+  if (ts29.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 (ts27.isTypeAliasDeclaration(node)) {
+  if (ts29.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
@@ -1463,7 +1664,7 @@ function normalizeBody(node, sourceFile, paramNames) {
   text = text.replace(/\s+/g, " ").trim();
   return text;
 }
-function normalizeText(text) {
+function normalizeText2(text) {
   let t = text.replace(/\/\/[^\n]*/g, "");
   t = t.replace(/\/\*[\s\S]*?\*\//g, "");
   t = t.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
@@ -1596,7 +1797,7 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts28 from "typescript";
+import * as ts30 from "typescript";
 function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
   return {
     filename,
@@ -1604,7 +1805,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
     sourceFile,
     checker,
     report(node, message) {
-      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1615,7 +1816,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1666,7 +1867,7 @@ function collectProject(program, tsRules, allowedFiles) {
           rule.visit(node, ctx);
         }
       }
-      ts29.forEachChild(node, visit2);
+      ts31.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
@@ -1680,7 +1881,7 @@ function collectProject(program, tsRules, allowedFiles) {
       rule,
       ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
     }));
-    ts29.forEachChild(sourceFile, visit2);
+    ts31.forEachChild(sourceFile, visit2);
   }
   const fileHashes = /* @__PURE__ */ new Map();
   for (const [file, { source }] of fileMap) {
@@ -1696,52 +1897,52 @@ function collectProject(program, tsRules, allowedFiles) {
   return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
 }
 function hasNonPublicModifier(node) {
-  if (!ts29.canHaveModifiers(node)) return false;
-  const mods = ts29.getModifiers(node);
+  if (!ts31.canHaveModifiers(node)) return false;
+  const mods = ts31.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts29.SyntaxKind.PrivateKeyword || m.kind === ts29.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts31.SyntaxKind.PrivateKeyword || m.kind === ts31.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts29.canHaveModifiers(node)) return false;
-  const mods = ts29.getModifiers(node);
+  if (!ts31.canHaveModifiers(node)) return false;
+  const mods = ts31.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts29.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts31.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts29.isTypeAliasDeclaration(node)) {
-    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isTypeAliasDeclaration(node)) {
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts29.isInterfaceDeclaration(node)) {
-    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isInterfaceDeclaration(node)) {
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  if (ts29.isStringLiteral(node)) return true;
-  if (ts29.isNumericLiteral(node)) return true;
-  if (ts29.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts29.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
-  if (ts29.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  if (ts31.isStringLiteral(node)) return true;
+  if (ts31.isNumericLiteral(node)) return true;
+  if (ts31.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts31.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts31.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts29.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts29.NodeFlags.Const)) return;
+  if (!ts31.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts31.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts29.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts31.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 = ts29.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts31.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 = ts29.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
   const hash = hashFunctionBody(body, sourceFile);
@@ -1763,17 +1964,17 @@ function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name,
   };
 }
 function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts29.isFunctionDeclaration(node) && node.name && node.body) {
+  if (ts31.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),
       node
     }));
   }
-  if (ts29.isVariableStatement(node)) {
+  if (ts31.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts29.isArrowFunction(decl.initializer) && ts29.isIdentifier(decl.name)) {
+      if (decl.initializer && ts31.isArrowFunction(decl.initializer) && ts31.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
@@ -1781,7 +1982,7 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
           node: arrow
         }));
       }
-      if (decl.initializer && ts29.isFunctionExpression(decl.initializer) && ts29.isIdentifier(decl.name)) {
+      if (decl.initializer && ts31.isFunctionExpression(decl.initializer) && ts31.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
@@ -1793,22 +1994,22 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts29.isPropertyAssignment(node) && (ts29.isIdentifier(node.name) || ts29.isStringLiteral(node.name))) {
+  if (ts31.isPropertyAssignment(node) && (ts31.isIdentifier(node.name) || ts31.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts29.isArrowFunction(init)) {
+    if (ts31.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts29.isFunctionExpression(init) && init.body) {
+    if (ts31.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts29.isArrowFunction(node) || ts29.isFunctionExpression(node)) {
+  if (ts31.isArrowFunction(node) || ts31.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts29.isVariableDeclaration(parent) && ts29.isIdentifier(parent.name)) {
-    } else if (ts29.isPropertyAssignment(parent)) {
+    if (ts31.isVariableDeclaration(parent) && ts31.isIdentifier(parent.name)) {
+    } else if (ts31.isPropertyAssignment(parent)) {
     } else {
-      const body = ts29.isArrowFunction(node) ? node.body : node.body;
+      const body = ts31.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
         if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
@@ -1818,14 +2019,14 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts29.isMethodDeclaration(node) && node.body && ts29.isIdentifier(node.name)) {
+  if (ts31.isMethodDeclaration(node) && node.body && ts31.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts29.isClassDeclaration(parent)) {
+    if (ts31.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 === ts29.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts31.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
@@ -1848,16 +2049,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts29.isCallExpression(parent)) {
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts31.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts29.isPropertyAssignment(grandparent) && ts29.isIdentifier(grandparent.name)) {
+    if (ts31.isPropertyAssignment(grandparent) && ts31.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts29.isIdentifier(parent.expression)) {
+    if (ts31.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts29.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts31.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -1868,7 +2069,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts29.isImportDeclaration(node) && ts29.isStringLiteral(node.moduleSpecifier)) {
+  if (ts31.isImportDeclaration(node) && ts31.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -1880,7 +2081,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts29.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts31.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -1891,9 +2092,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts29.isExportDeclaration(node) && node.moduleSpecifier && ts29.isStringLiteral(node.moduleSpecifier)) {
+  if (ts31.isExportDeclaration(node) && node.moduleSpecifier && ts31.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts29.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts31.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -1906,7 +2107,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts29.isBlock(node)) return;
+  if (!ts31.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -1916,43 +2117,46 @@ function collectStatementSequences(node, file, sourceFile, registry) {
       const window = stmts.slice(start, start + size);
       const texts = window.map((s) => s.getText(sourceFile));
       const joined = texts.join("\n");
-      const normalized = normalizeText(joined);
+      const normalized = normalizeText2(joined);
       if (normalized.length < 128) continue;
       const hash = hashText(joined.replace(/\s+/g, " ").trim());
       const normalizedHash = hashText(normalized);
       const firstStmt = window[0];
       const lastStmt = window[window.length - 1];
       if (firstStmt === void 0 || lastStmt === void 0) continue;
-      const line = ts29.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts29.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts31.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts31.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 (!ts29.isTypeLiteralNode(node)) return;
+  if (!ts31.isTypeLiteralNode(node)) return;
   const parent = node.parent;
-  if (!parent || !ts29.isParameter(parent)) return;
+  if (!parent || !ts31.isParameter(parent)) return;
   if (parent.type !== node) return;
-  const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts29.isCallExpression(node)) return;
+  if (!ts31.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts29.isIdentifier(node.expression)) {
+  if (ts31.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts29.isPropertyAccessExpression(node.expression)) {
+  } else if (ts31.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts29.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
+    let resolvedDeclaration;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts29.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts31.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
+      const signature = checker.getResolvedSignature(node);
+      resolvedDeclaration = signature?.declaration;
     } catch {
     }
     sites.push({
@@ -1961,7 +2165,8 @@ function collectCallSites(node, file, sourceFile, checker, sites) {
       line,
       argCount: node.arguments.length,
       node,
-      symbol
+      symbol,
+      resolvedDeclaration
     });
   }
 }
@@ -1970,12 +2175,12 @@ function collectAllComments(sourceFile) {
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
   function visit(node) {
-    const leading = ts29.getLeadingCommentRanges(source, node.getFullStart());
+    const leading = ts31.getLeadingCommentRanges(source, node.getFullStart());
     if (leading) {
       for (const r of leading) {
         if (seen.has(r.pos)) continue;
         seen.add(r.pos);
-        const isLine = r.kind === ts29.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts31.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1984,12 +2189,12 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    const trailing = ts29.getTrailingCommentRanges(source, node.getEnd());
+    const trailing = ts31.getTrailingCommentRanges(source, node.getEnd());
     if (trailing) {
       for (const r of trailing) {
         if (seen.has(r.pos)) continue;
         seen.add(r.pos);
-        const isLine = r.kind === ts29.SyntaxKind.SingleLineCommentTrivia;
+        const isLine = r.kind === ts31.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1998,34 +2203,34 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    ts29.forEachChild(node, visit);
+    ts31.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts30 from "typescript";
+import * as ts32 from "typescript";
 import { dirname as dirname2 } from "path";
 function createProgramFromFiles(files) {
   let configPath;
   if (files.length > 0) {
-    configPath = ts30.findConfigFile(dirname2(files[0]), ts30.sys.fileExists, "tsconfig.json");
+    configPath = ts32.findConfigFile(dirname2(files[0]), ts32.sys.fileExists, "tsconfig.json");
   }
   if (configPath) {
-    const configFile = ts30.readConfigFile(configPath, ts30.sys.readFile);
-    const parsed = ts30.parseJsonConfigFileContent(configFile.config, ts30.sys, dirname2(configPath));
-    return ts30.createProgram({
+    const configFile = ts32.readConfigFile(configPath, ts32.sys.readFile);
+    const parsed = ts32.parseJsonConfigFileContent(configFile.config, ts32.sys, dirname2(configPath));
+    return ts32.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts30.createProgram({
+  return ts32.createProgram({
     rootNames: files,
     options: {
-      target: ts30.ScriptTarget.ESNext,
-      module: ts30.ModuleKind.ESNext,
-      moduleResolution: ts30.ModuleResolutionKind.Bundler,
+      target: ts32.ScriptTarget.ESNext,
+      module: ts32.ModuleKind.ESNext,
+      moduleResolution: ts32.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -2265,4 +2470,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-7UXUNJSF.js.map
+//# sourceMappingURL=chunk-HE647T6E.js.map