unguard 0.13.2 → 0.13.3

package/dist/{chunk-2QER6GG7.js → chunk-WUH4JLMB.js}

@@ -653,7 +653,8 @@ var repeatedLiteralProperty = {
             }
             const line = ts8.getLineAndCharacterOfPosition(sourceFile, prop.getStart(sourceFile)).line + 1;
             const scopeId = findEnclosingFunctionStart(prop, sourceFile);
-            list.push({ line, isAsConst: result.isAsConst, scopeId });
+            const key = ts8.isIdentifier(prop.name) ? prop.name.text : ts8.isStringLiteral(prop.name) ? prop.name.text : "";
+            list.push({ line, isAsConst: result.isAsConst, scopeId, key });
           }
         }
         ts8.forEachChild(node, visit2);
@@ -662,6 +663,8 @@ var repeatedLiteralProperty = {
       const valueMap = /* @__PURE__ */ new Map();
       ts8.forEachChild(sourceFile, visit2);
       for (const [value, occurrences] of valueMap) {
+        const uniqueKeys = new Set(occurrences.map((o) => o.key).filter((k) => k !== ""));
+        if (uniqueKeys.size === 1) continue;
         const hasAsConst = occurrences.some((o) => o.isAsConst);
         const uniqueScopes = new Set(occurrences.map((o) => o.scopeId));
         const threshold = hasAsConst ? 3 : 5;
@@ -753,7 +756,7 @@ var repeatedReturnShape = {
     const shapeMap = /* @__PURE__ */ new Map();
     for (const [file, { sourceFile }] of project.files) {
       let visit2 = function(node) {
-        if (isFunctionLike(node)) {
+        if (isFunctionLike(node) && !isCallbackArgument(node)) {
           const functionName = deriveFunctionName(node, sourceFile);
           const line = ts10.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
           collectReturnShapes(node, file, line, functionName, sourceFile, shapeMap);
@@ -763,7 +766,9 @@ var repeatedReturnShape = {
       var visit = visit2;
       ts10.forEachChild(sourceFile, visit2);
     }
-    for (const [, entries] of shapeMap) {
+    const knownTypeShapes = buildKnownTypeShapes(project.types.getAll());
+    for (const [shapeKey, entries] of shapeMap) {
+      if (knownTypeShapes.has(shapeKey)) continue;
       const byFunction = /* @__PURE__ */ new Map();
       for (const entry of entries) {
         const key = `${entry.file}:${entry.line}`;
@@ -773,6 +778,8 @@ var repeatedReturnShape = {
       }
       const unique = [...byFunction.values()];
       if (unique.length < THRESHOLD) continue;
+      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;
@@ -832,6 +839,43 @@ function addShape(objLiteral, file, funcLine, functionName, sourceFile, shapeMap
   const { sorted, list } = getShapeGroup(shapeMap, props);
   list.push({ file, line: funcLine, functionName, props: sorted });
 }
+function isCallbackArgument(node) {
+  let current = node;
+  if (ts10.isParenthesizedExpression(current.parent)) {
+    current = current.parent;
+  }
+  const parent = current.parent;
+  if (!ts10.isCallExpression(parent)) return false;
+  return parent.arguments.some((arg) => arg === current);
+}
+function buildKnownTypeShapes(typeEntries) {
+  const shapes = /* @__PURE__ */ new Set();
+  for (const entry of typeEntries) {
+    const props = extractTypePropertyNames(entry.node);
+    if (props && props.length >= 2) {
+      shapes.add([...props].sort().join("\0"));
+    }
+  }
+  return shapes;
+}
+function extractTypePropertyNames(node) {
+  let members;
+  if (ts10.isTypeLiteralNode(node)) {
+    members = node.members;
+  } else if (ts10.isInterfaceDeclaration(node)) {
+    members = node.members;
+  }
+  if (!members) return null;
+  const names = [];
+  for (const member of members) {
+    if (ts10.isPropertySignature(member) && member.name) {
+      if (ts10.isIdentifier(member.name)) names.push(member.name.text);
+      else if (ts10.isStringLiteral(member.name)) names.push(member.name.text);
+      else return null;
+    }
+  }
+  return names.length > 0 ? names : null;
+}
 function deriveFunctionName(node, sourceFile) {
   if (ts10.isFunctionDeclaration(node) && node.name) {
     return node.name.text;
@@ -1290,174 +1334,15 @@ function hasOptionalChaining(node) {
   return false;
 }
 
-// src/rules/ts/no-module-state-write.ts
-import * as ts21 from "typescript";
-var arrayMutators = /* @__PURE__ */ new Set([
-  "copyWithin",
-  "fill",
-  "pop",
-  "push",
-  "reverse",
-  "shift",
-  "sort",
-  "splice",
-  "unshift"
-]);
-var mapMutators = /* @__PURE__ */ new Set(["clear", "delete", "set"]);
-var setMutators = /* @__PURE__ */ new Set(["add", "clear", "delete"]);
-var noModuleStateWrite = {
-  kind: "ts",
-  id: "no-module-state-write",
-  severity: "warning",
-  message: "Function mutates module-scope state; make the dependency explicit instead of writing ambient state",
-  visit(node, ctx) {
-    if (getEnclosingFunctionLike(node) === null) return;
-    const bindingName = getAmbientWriteBinding(node, ctx);
-    if (!bindingName) return;
-    ctx.report(node, `Function mutates module-scope state through "${bindingName}"`);
-  }
-};
-function getAmbientWriteBinding(node, ctx) {
-  if (ts21.isBinaryExpression(node) && isAssignmentOperator(node.operatorToken.kind)) {
-    return getAmbientBindingFromWriteTarget(node.left, ctx);
-  }
-  if (ts21.isPrefixUnaryExpression(node)) {
-    if (node.operator === ts21.SyntaxKind.PlusPlusToken || node.operator === ts21.SyntaxKind.MinusMinusToken) {
-      return getAmbientBindingFromWriteTarget(node.operand, ctx);
-    }
-  }
-  if (ts21.isPostfixUnaryExpression(node)) {
-    if (node.operator === ts21.SyntaxKind.PlusPlusToken || node.operator === ts21.SyntaxKind.MinusMinusToken) {
-      return getAmbientBindingFromWriteTarget(node.operand, ctx);
-    }
-  }
-  if (ts21.isDeleteExpression(node)) {
-    return getAmbientBindingFromWriteTarget(node.expression, ctx);
-  }
-  if (ts21.isCallExpression(node)) {
-    return getAmbientBindingFromMutatorCall(node, ctx);
-  }
-  return null;
-}
-function getAmbientBindingFromWriteTarget(node, ctx) {
-  const target = unwrapExpression2(node);
-  if (ts21.isIdentifier(target)) {
-    return isAmbientBinding(target, ctx) ? target.text : null;
-  }
-  if (ts21.isPropertyAccessExpression(target) || ts21.isElementAccessExpression(target)) {
-    const root = getRootIdentifier(target.expression);
-    if (!root) return null;
-    return isAmbientBinding(root, ctx) ? root.text : null;
-  }
-  return null;
-}
-function getAmbientBindingFromMutatorCall(node, ctx) {
-  const callee = unwrapExpression2(node.expression);
-  if (!ts21.isPropertyAccessExpression(callee)) return null;
-  const receiver = unwrapExpression2(callee.expression);
-  const root = getRootIdentifier(receiver);
-  if (!root || !isAmbientBinding(root, ctx)) return null;
-  const receiverType = ctx.checker.getTypeAtLocation(receiver);
-  const method = callee.name.text;
-  if (!isKnownMutator(receiverType, method, ctx.checker)) return null;
-  return root.text;
-}
-function isAmbientBinding(node, ctx) {
-  const symbol = ctx.checker.getSymbolAtLocation(node);
-  if (!symbol) return false;
-  for (const declaration of symbol.declarations ?? []) {
-    if (!isAmbientBindingDeclaration(declaration, ctx.sourceFile)) continue;
-    return true;
-  }
-  return false;
-}
-function isAmbientBindingDeclaration(node, sourceFile) {
-  if (node.getSourceFile() !== sourceFile) return false;
-  if (getEnclosingFunctionLike(node) !== null) return false;
-  return ts21.isVariableDeclaration(node) || ts21.isBindingElement(node) || ts21.isImportClause(node) || ts21.isImportSpecifier(node) || ts21.isNamespaceImport(node) || ts21.isImportEqualsDeclaration(node);
-}
-function getRootIdentifier(node) {
-  const target = unwrapExpression2(node);
-  if (ts21.isIdentifier(target)) return target;
-  if (ts21.isPropertyAccessExpression(target) || ts21.isElementAccessExpression(target)) {
-    return getRootIdentifier(target.expression);
-  }
-  return null;
-}
-function unwrapExpression2(node) {
-  let current = node;
-  while (true) {
-    if (ts21.isParenthesizedExpression(current)) {
-      current = current.expression;
-      continue;
-    }
-    if (ts21.isAsExpression(current) || ts21.isTypeAssertionExpression(current) || ts21.isNonNullExpression(current)) {
-      current = current.expression;
-      continue;
-    }
-    if (ts21.isSatisfiesExpression(current)) {
-      current = current.expression;
-      continue;
-    }
-    return current;
-  }
-}
-function isAssignmentOperator(kind) {
-  switch (kind) {
-    case ts21.SyntaxKind.EqualsToken:
-    case ts21.SyntaxKind.PlusEqualsToken:
-    case ts21.SyntaxKind.MinusEqualsToken:
-    case ts21.SyntaxKind.AsteriskEqualsToken:
-    case ts21.SyntaxKind.AsteriskAsteriskEqualsToken:
-    case ts21.SyntaxKind.SlashEqualsToken:
-    case ts21.SyntaxKind.PercentEqualsToken:
-    case ts21.SyntaxKind.AmpersandEqualsToken:
-    case ts21.SyntaxKind.BarEqualsToken:
-    case ts21.SyntaxKind.CaretEqualsToken:
-    case ts21.SyntaxKind.LessThanLessThanEqualsToken:
-    case ts21.SyntaxKind.GreaterThanGreaterThanEqualsToken:
-    case ts21.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
-    case ts21.SyntaxKind.BarBarEqualsToken:
-    case ts21.SyntaxKind.AmpersandAmpersandEqualsToken:
-    case ts21.SyntaxKind.QuestionQuestionEqualsToken:
-      return true;
-    default:
-      return false;
-  }
-}
-function getEnclosingFunctionLike(node) {
-  let current = node.parent;
-  while (current) {
-    if (ts21.isFunctionLike(current)) return current;
-    current = current.parent;
-  }
-  return null;
-}
-function isKnownMutator(type, method, checker) {
-  const apparent = checker.getApparentType(type);
-  if (checker.isArrayType(apparent) || checker.isTupleType(apparent)) {
-    return arrayMutators.has(method);
-  }
-  const symbol = apparent.getSymbol();
-  const name = symbol?.getName();
-  if (name === "Map" || name === "WeakMap") {
-    return mapMutators.has(method);
-  }
-  if (name === "Set" || name === "WeakSet") {
-    return setMutators.has(method);
-  }
-  return false;
-}
-
 // src/rules/ts/no-non-null-assertion.ts
-import * as ts22 from "typescript";
+import * as ts21 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",
   visit(node, ctx) {
-    if (!ts22.isNonNullExpression(node)) return;
+    if (!ts21.isNonNullExpression(node)) return;
     const inner = node.expression;
     if (!ctx.isNullable(inner)) return;
     if (ctx.isExternal(inner)) return;
@@ -1468,32 +1353,32 @@ var noNonNullAssertion = {
   }
 };
 function isSplitElementAccess(node) {
-  if (!ts22.isElementAccessExpression(node)) return false;
+  if (!ts21.isElementAccessExpression(node)) return false;
   const obj = node.expression;
-  if (!ts22.isCallExpression(obj)) return false;
+  if (!ts21.isCallExpression(obj)) return false;
   const callee = obj.expression;
-  if (!ts22.isPropertyAccessExpression(callee)) return false;
+  if (!ts21.isPropertyAccessExpression(callee)) return false;
   return callee.name.text === "split";
 }
 function isFilterElementAccess(node) {
-  if (ts22.isElementAccessExpression(node)) {
+  if (ts21.isElementAccessExpression(node)) {
     const obj = node.expression;
-    if (ts22.isCallExpression(obj)) {
+    if (ts21.isCallExpression(obj)) {
       const callee = obj.expression;
-      if (ts22.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+      if (ts21.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
     }
-    if (ts22.isIdentifier(obj)) {
+    if (ts21.isIdentifier(obj)) {
       const init = findVariableInit(obj);
-      if (init && ts22.isCallExpression(init)) {
+      if (init && ts21.isCallExpression(init)) {
         const callee = init.expression;
-        if (ts22.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+        if (ts21.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
       }
     }
   }
   return false;
 }
 function isLengthGuardedAccess(node) {
-  if (!ts22.isElementAccessExpression(node)) return false;
+  if (!ts21.isElementAccessExpression(node)) return false;
   const arr = node.expression;
   const arrName = getIdentifierName(arr);
   if (!arrName) return false;
@@ -1504,25 +1389,25 @@ function isInsideForLoopBoundedBy(node, arrName) {
   let current = node;
   while (current.parent) {
     current = current.parent;
-    if (ts22.isForStatement(current) && current.condition) {
+    if (ts21.isForStatement(current) && current.condition) {
       if (isLengthBoundCondition(current.condition, arrName)) return true;
     }
   }
   return false;
 }
 function isLengthBoundCondition(cond, arrName) {
-  if (!ts22.isBinaryExpression(cond)) return false;
+  if (!ts21.isBinaryExpression(cond)) return false;
   const op = cond.operatorToken.kind;
-  if (op === ts22.SyntaxKind.LessThanToken || op === ts22.SyntaxKind.LessThanEqualsToken) {
+  if (op === ts21.SyntaxKind.LessThanToken || op === ts21.SyntaxKind.LessThanEqualsToken) {
     return isLengthAccess(cond.right, arrName);
   }
-  if (op === ts22.SyntaxKind.GreaterThanToken || op === ts22.SyntaxKind.GreaterThanEqualsToken) {
+  if (op === ts21.SyntaxKind.GreaterThanToken || op === ts21.SyntaxKind.GreaterThanEqualsToken) {
     return isLengthAccess(cond.left, arrName);
   }
   return false;
 }
 function isLengthAccess(node, arrName) {
-  if (!ts22.isPropertyAccessExpression(node)) return false;
+  if (!ts21.isPropertyAccessExpression(node)) return false;
   if (node.name.text !== "length") return false;
   return getIdentifierName(node.expression) === arrName;
 }
@@ -1530,16 +1415,16 @@ function hasPrecedingLengthGuard(node, arrName) {
   let current = node;
   while (current.parent) {
     const parent = current.parent;
-    if (ts22.isBlock(parent)) {
+    if (ts21.isBlock(parent)) {
       for (const stmt of parent.statements) {
         if (stmt === current || stmt.pos >= current.pos) break;
-        if (ts22.isIfStatement(stmt) && isLengthGuardWithEarlyExit(stmt, arrName)) return true;
+        if (ts21.isIfStatement(stmt) && isLengthGuardWithEarlyExit(stmt, arrName)) return true;
       }
     }
-    if (ts22.isIfStatement(parent) && parent.thenStatement === current) {
+    if (ts21.isIfStatement(parent) && parent.thenStatement === current) {
       if (isPositiveLengthCheck(parent.expression, arrName)) return true;
     }
-    if (ts22.isBlock(current) && ts22.isIfStatement(parent) && parent.thenStatement === current) {
+    if (ts21.isBlock(current) && ts21.isIfStatement(parent) && parent.thenStatement === current) {
       if (isPositiveLengthCheck(parent.expression, arrName)) return true;
     }
     current = parent;
@@ -1551,79 +1436,79 @@ function isLengthGuardWithEarlyExit(stmt, arrName) {
   return isZeroLengthCheck(stmt.expression, arrName);
 }
 function isZeroLengthCheck(expr, arrName) {
-  if (!ts22.isBinaryExpression(expr)) return false;
+  if (!ts21.isBinaryExpression(expr)) return false;
   const op = expr.operatorToken.kind;
-  if (op === ts22.SyntaxKind.EqualsEqualsEqualsToken || op === ts22.SyntaxKind.EqualsEqualsToken) {
+  if (op === ts21.SyntaxKind.EqualsEqualsEqualsToken || op === ts21.SyntaxKind.EqualsEqualsToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
     if (isLengthAccess(expr.right, arrName) && isNumericLiteralValue(expr.left, 0)) return true;
   }
-  if (op === ts22.SyntaxKind.LessThanToken) {
+  if (op === ts21.SyntaxKind.LessThanToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
-  if (op === ts22.SyntaxKind.ExclamationEqualsEqualsToken || op === ts22.SyntaxKind.ExclamationEqualsToken) {
+  if (op === ts21.SyntaxKind.ExclamationEqualsEqualsToken || op === ts21.SyntaxKind.ExclamationEqualsToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
   return false;
 }
 function isPositiveLengthCheck(expr, arrName) {
-  if (!ts22.isBinaryExpression(expr)) return false;
+  if (!ts21.isBinaryExpression(expr)) return false;
   const op = expr.operatorToken.kind;
-  if (op === ts22.SyntaxKind.GreaterThanToken) {
+  if (op === ts21.SyntaxKind.GreaterThanToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
   }
-  if (op === ts22.SyntaxKind.GreaterThanEqualsToken) {
+  if (op === ts21.SyntaxKind.GreaterThanEqualsToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
   }
-  if (op === ts22.SyntaxKind.ExclamationEqualsEqualsToken || op === ts22.SyntaxKind.ExclamationEqualsToken) {
+  if (op === ts21.SyntaxKind.ExclamationEqualsEqualsToken || op === ts21.SyntaxKind.ExclamationEqualsToken) {
     if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
   }
   return false;
 }
 function isEarlyExit(stmt) {
-  if (ts22.isReturnStatement(stmt) || ts22.isThrowStatement(stmt)) return true;
-  if (ts22.isBlock(stmt) && stmt.statements.length === 1) {
+  if (ts21.isReturnStatement(stmt) || ts21.isThrowStatement(stmt)) return true;
+  if (ts21.isBlock(stmt) && stmt.statements.length === 1) {
     const inner = stmt.statements[0];
     if (inner === void 0) return false;
-    return ts22.isReturnStatement(inner) || ts22.isThrowStatement(inner);
+    return ts21.isReturnStatement(inner) || ts21.isThrowStatement(inner);
   }
   return false;
 }
 function isNumericLiteralValue(node, value) {
-  return ts22.isNumericLiteral(node) && node.text === String(value);
+  return ts21.isNumericLiteral(node) && node.text === String(value);
 }
 function isNumericLiteralGte(node, min) {
-  return ts22.isNumericLiteral(node) && Number(node.text) >= min;
+  return ts21.isNumericLiteral(node) && Number(node.text) >= min;
 }
 function getIdentifierName(node) {
-  if (ts22.isIdentifier(node)) return node.text;
+  if (ts21.isIdentifier(node)) return node.text;
   return null;
 }
 function findVariableInit(id) {
   const sourceFile = id.getSourceFile();
   let result;
   function visit(node) {
-    if (ts22.isVariableDeclaration(node) && ts22.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
+    if (ts21.isVariableDeclaration(node) && ts21.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
       result = node.initializer;
     }
-    if (!result) ts22.forEachChild(node, visit);
+    if (!result) ts21.forEachChild(node, visit);
   }
   visit(sourceFile);
   return result;
 }
 
 // src/rules/ts/no-null-ternary-normalization.ts
-import * as ts23 from "typescript";
+import * as ts22 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",
   visit(node, ctx) {
-    if (!ts23.isConditionalExpression(node)) return;
+    if (!ts22.isConditionalExpression(node)) return;
     const test = node.condition;
-    if (!ts23.isBinaryExpression(test)) return;
+    if (!ts22.isBinaryExpression(test)) return;
     const op = test.operatorToken.kind;
-    if (op !== ts23.SyntaxKind.EqualsEqualsEqualsToken && op !== ts23.SyntaxKind.ExclamationEqualsEqualsToken && op !== ts23.SyntaxKind.EqualsEqualsToken && op !== ts23.SyntaxKind.ExclamationEqualsToken) return;
+    if (op !== ts22.SyntaxKind.EqualsEqualsEqualsToken && op !== ts22.SyntaxKind.ExclamationEqualsEqualsToken && op !== ts22.SyntaxKind.EqualsEqualsToken && op !== ts22.SyntaxKind.ExclamationEqualsToken) return;
     const hasNullishComparand = isNullish(test.left) || isNullish(test.right);
     if (!hasNullishComparand) return;
     if (isNullish(node.whenTrue) || isNullish(node.whenFalse)) {
@@ -1637,35 +1522,35 @@ var noNullTernaryNormalization = {
   }
 };
 function isNullish(node) {
-  if (node.kind === ts23.SyntaxKind.NullKeyword) return true;
-  if (ts23.isIdentifier(node) && node.text === "undefined") return true;
-  if (ts23.isVoidExpression(node)) return true;
+  if (node.kind === ts22.SyntaxKind.NullKeyword) return true;
+  if (ts22.isIdentifier(node) && node.text === "undefined") return true;
+  if (ts22.isVoidExpression(node)) return true;
   return false;
 }
 
 // src/rules/ts/no-nullish-coalescing.ts
-import * as ts24 from "typescript";
+import * as ts23 from "typescript";
 var noNullishCoalescing = {
   kind: "ts",
   id: "no-nullish-coalescing",
   severity: "warning",
   message: "Nullish coalescing (??) on a non-nullable type is unreachable; remove the fallback or fix the type upstream",
   visit(node, ctx) {
-    if (!ts24.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts24.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts23.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts23.SyntaxKind.QuestionQuestionToken) return;
     if (isPossiblyMissingArrayBindingValue(node.left, ctx)) return;
     if (ctx.isNullable(node.left)) return;
     ctx.report(node);
   }
 };
 function isPossiblyMissingArrayBindingValue(node, ctx) {
-  if (!ts24.isIdentifier(node)) return false;
+  if (!ts23.isIdentifier(node)) return false;
   const symbol = ctx.checker.getSymbolAtLocation(node);
   if (!symbol) return false;
   for (const declaration of symbol.declarations ?? []) {
-    if (!ts24.isBindingElement(declaration)) continue;
+    if (!ts23.isBindingElement(declaration)) continue;
     if (declaration.initializer || declaration.dotDotDotToken) continue;
-    if (!ts24.isArrayBindingPattern(declaration.parent)) continue;
+    if (!ts23.isArrayBindingPattern(declaration.parent)) continue;
     const pattern = declaration.parent;
     const index = pattern.elements.indexOf(declaration);
     if (index < 0) continue;
@@ -1693,14 +1578,14 @@ function isTupleTypeReference(type, checker) {
 }
 
 // src/rules/ts/no-optional-call.ts
-import * as ts25 from "typescript";
+import * as ts24 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",
   visit(node, ctx) {
-    if (!ts25.isCallExpression(node)) return;
+    if (!ts24.isCallExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -1708,14 +1593,14 @@ var noOptionalCall = {
 };
 
 // src/rules/ts/no-optional-element-access.ts
-import * as ts26 from "typescript";
+import * as ts25 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",
   visit(node, ctx) {
-    if (!ts26.isElementAccessExpression(node)) return;
+    if (!ts25.isElementAccessExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -1723,14 +1608,14 @@ var noOptionalElementAccess = {
 };
 
 // src/rules/ts/no-optional-property-access.ts
-import * as ts27 from "typescript";
+import * as ts26 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",
   visit(node, ctx) {
-    if (!ts27.isPropertyAccessExpression(node)) return;
+    if (!ts26.isPropertyAccessExpression(node)) return;
     if (!node.questionDotToken) return;
     if (ctx.isNullable(node.expression)) return;
     ctx.report(node);
@@ -1738,27 +1623,27 @@ var noOptionalPropertyAccess = {
 };
 
 // src/rules/ts/no-redundant-existence-guard.ts
-import * as ts28 from "typescript";
+import * as ts27 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 (!ts28.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts28.SyntaxKind.AmpersandAmpersandToken) return;
+    if (!ts27.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts27.SyntaxKind.AmpersandAmpersandToken) return;
     const left = node.left;
     const right = node.right;
-    if (ts28.isIdentifier(left) && accessesIdentifier(right, left.text)) {
+    if (ts27.isIdentifier(left) && accessesIdentifier(right, left.text)) {
       if (ctx.isNullable(left)) return;
       ctx.report(node);
       return;
     }
-    if (ts28.isBinaryExpression(left) && isNullCheck(left)) {
+    if (ts27.isBinaryExpression(left) && isNullCheck(left)) {
       const checked = getNullCheckedIdentifier(left);
       if (checked && accessesIdentifier(right, checked)) {
-        const identNode = ts28.isIdentifier(left.left) ? left.left : left.right;
-        if (ts28.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
+        const identNode = ts27.isIdentifier(left.left) ? left.left : left.right;
+        if (ts27.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
           ctx.report(node);
         }
       }
@@ -1767,34 +1652,34 @@ var noRedundantExistenceGuard = {
 };
 function accessesIdentifier(expr, name) {
   const root = getExpressionRoot(expr);
-  return ts28.isIdentifier(root) && root.text === name;
+  return ts27.isIdentifier(root) && root.text === name;
 }
 function getExpressionRoot(node) {
-  if (ts28.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts28.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
-  if (ts28.isCallExpression(node)) return getExpressionRoot(node.expression);
+  if (ts27.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts27.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts27.isCallExpression(node)) return getExpressionRoot(node.expression);
   return node;
 }
 function isNullCheck(expr) {
   const op = expr.operatorToken.kind;
-  if (op !== ts28.SyntaxKind.ExclamationEqualsToken && op !== ts28.SyntaxKind.ExclamationEqualsEqualsToken) return false;
+  if (op !== ts27.SyntaxKind.ExclamationEqualsToken && op !== ts27.SyntaxKind.ExclamationEqualsEqualsToken) return false;
   return isNullishLiteral(expr.right) || isNullishLiteral(expr.left);
 }
 function getNullCheckedIdentifier(expr) {
-  if (ts28.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
-  if (ts28.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
+  if (ts27.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
+  if (ts27.isIdentifier(expr.right) && isNullishLiteral(expr.left)) return expr.right.text;
   return null;
 }
 
 // src/rules/ts/no-ts-ignore.ts
-import * as ts29 from "typescript";
+import * as ts28 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",
   visit(node, ctx) {
-    const ranges = ts29.getLeadingCommentRanges(ctx.source, node.getFullStart());
+    const ranges = ts28.getLeadingCommentRanges(ctx.source, node.getFullStart());
     if (!ranges) return;
     for (const range of ranges) {
       const text = ctx.source.slice(range.pos, range.end);
@@ -1806,22 +1691,22 @@ var noTsIgnore = {
 };
 
 // src/rules/ts/no-type-assertion.ts
-import * as ts30 from "typescript";
+import * as ts29 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 (!ts30.isAsExpression(node)) return;
-    if (!ts30.isAsExpression(node.expression)) return;
-    if (node.expression.type.kind !== ts30.SyntaxKind.UnknownKeyword) return;
+    if (!ts29.isAsExpression(node)) return;
+    if (!ts29.isAsExpression(node.expression)) return;
+    if (node.expression.type.kind !== ts29.SyntaxKind.UnknownKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/prefer-default-param-value.ts
-import * as ts31 from "typescript";
+import * as ts30 from "typescript";
 var preferDefaultParamValue = {
   kind: "ts",
   id: "prefer-default-param-value",
@@ -1831,21 +1716,21 @@ var preferDefaultParamValue = {
     const result = getFirstFunctionStatement(node);
     if (result === null) return;
     const { firstStmt, fn } = result;
-    if (!ts31.isExpressionStatement(firstStmt)) return;
+    if (!ts30.isExpressionStatement(firstStmt)) return;
     const expr = firstStmt.expression;
-    if (!ts31.isBinaryExpression(expr) || expr.operatorToken.kind !== ts31.SyntaxKind.EqualsToken) return;
+    if (!ts30.isBinaryExpression(expr) || expr.operatorToken.kind !== ts30.SyntaxKind.EqualsToken) return;
     const right = expr.right;
-    if (!ts31.isBinaryExpression(right) || right.operatorToken.kind !== ts31.SyntaxKind.QuestionQuestionToken) return;
-    if (!ts31.isIdentifier(expr.left) || !ts31.isIdentifier(right.left)) return;
+    if (!ts30.isBinaryExpression(right) || right.operatorToken.kind !== ts30.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts30.isIdentifier(expr.left) || !ts30.isIdentifier(right.left)) return;
     if (expr.left.text !== right.left.text) return;
     const paramName = expr.left.text;
-    const isParam = fn.parameters.some((p) => ts31.isIdentifier(p.name) && p.name.text === paramName);
+    const isParam = fn.parameters.some((p) => ts30.isIdentifier(p.name) && p.name.text === paramName);
     if (isParam) ctx.report(firstStmt);
   }
 };
 
 // src/rules/ts/prefer-required-param-with-guard.ts
-import * as ts32 from "typescript";
+import * as ts31 from "typescript";
 var preferRequiredParamWithGuard = {
   kind: "ts",
   id: "prefer-required-param-with-guard",
@@ -1855,26 +1740,26 @@ var preferRequiredParamWithGuard = {
     const result = getFirstFunctionStatement(node);
     if (result === null) return;
     const { firstStmt, fn } = result;
-    if (!ts32.isIfStatement(firstStmt)) return;
+    if (!ts31.isIfStatement(firstStmt)) return;
     const test = firstStmt.expression;
     let guardedName = null;
-    if (ts32.isPrefixUnaryExpression(test) && test.operator === ts32.SyntaxKind.ExclamationToken) {
-      if (ts32.isIdentifier(test.operand)) guardedName = test.operand.text;
+    if (ts31.isPrefixUnaryExpression(test) && test.operator === ts31.SyntaxKind.ExclamationToken) {
+      if (ts31.isIdentifier(test.operand)) guardedName = test.operand.text;
     }
-    if (ts32.isBinaryExpression(test)) {
+    if (ts31.isBinaryExpression(test)) {
       const op = test.operatorToken.kind;
-      if (op === ts32.SyntaxKind.EqualsEqualsEqualsToken || op === ts32.SyntaxKind.EqualsEqualsToken) {
-        if (ts32.isIdentifier(test.left) && ts32.isIdentifier(test.right) && test.right.text === "undefined") {
+      if (op === ts31.SyntaxKind.EqualsEqualsEqualsToken || op === ts31.SyntaxKind.EqualsEqualsToken) {
+        if (ts31.isIdentifier(test.left) && ts31.isIdentifier(test.right) && test.right.text === "undefined") {
           guardedName = test.left.text;
         }
       }
     }
     if (!guardedName) return;
     const consequent = firstStmt.thenStatement;
-    const isGuard = ts32.isReturnStatement(consequent) || ts32.isThrowStatement(consequent) || ts32.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts32.isReturnStatement(consequent.statements[0]) || ts32.isThrowStatement(consequent.statements[0]));
+    const isGuard = ts31.isReturnStatement(consequent) || ts31.isThrowStatement(consequent) || ts31.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts31.isReturnStatement(consequent.statements[0]) || ts31.isThrowStatement(consequent.statements[0]));
     if (!isGuard) return;
     const isOptional = fn.parameters.some(
-      (p) => ts32.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
+      (p) => ts31.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
     );
     if (isOptional) ctx.report(firstStmt);
   }
@@ -1901,7 +1786,6 @@ var allRules = [
   preferDefaultParamValue,
   preferRequiredParamWithGuard,
   noInlineParamType,
-  noModuleStateWrite,
   duplicateTypeDeclaration,
   duplicateFunctionDeclaration,
   optionalArgAlwaysUsed,
@@ -1944,7 +1828,6 @@ var ruleMetadata = {
   "prefer-default-param-value": { category: "interface-design", tags: ["api"] },
   "prefer-required-param-with-guard": { category: "interface-design", tags: ["api"] },
   "no-inline-param-type": { category: "interface-design", tags: ["api"] },
-  "no-module-state-write": { category: "state-management", tags: ["state"] },
   "duplicate-type-declaration": { category: "cross-file", tags: ["duplicate"] },
   "duplicate-type-name": { category: "cross-file", tags: ["duplicate"] },
   "duplicate-function-declaration": { category: "cross-file", tags: ["duplicate"] },
@@ -2021,32 +1904,36 @@ function isFailOn(value) {
 }
 
 // src/collect/index.ts
-import * as ts35 from "typescript";
+import * as ts34 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
+// src/collect/type-registry.ts
+import { existsSync } from "fs";
+import { dirname as dirname2, join } from "path";
+
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts33 from "typescript";
+import * as ts32 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 (ts33.isTypeLiteralNode(node)) {
+  if (ts32.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts33.isInterfaceDeclaration(node)) {
+  if (ts32.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts33.isPropertySignature(node)) {
+  if (ts32.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 (ts33.isTypeAliasDeclaration(node)) {
+  if (ts32.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
@@ -2149,22 +2036,42 @@ var TypeRegistry = class extends BaseRegistry {
   }
 };
 function getExportedNameCollisions(entries) {
-  const byName = /* @__PURE__ */ new Map();
+  const byNameAndPackage = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.exported) continue;
-    let list = byName.get(entry.name);
+    const pkg = findPackageRoot(entry.file);
+    const key = `${pkg}\0${entry.name}`;
+    let list = byNameAndPackage.get(key);
     if (list === void 0) {
       list = [];
-      byName.set(entry.name, list);
+      byNameAndPackage.set(key, list);
     }
     list.push(entry);
   }
-  return [...byName.values()].filter((group) => {
+  return [...byNameAndPackage.values()].filter((group) => {
     if (group.length < 2) return false;
     const files = new Set(group.map((e) => e.file));
     return files.size > 1;
   });
 }
+var packageRootCache = /* @__PURE__ */ new Map();
+function findPackageRoot(filePath) {
+  let dir = dirname2(filePath);
+  const cached = packageRootCache.get(dir);
+  if (cached !== void 0) return cached;
+  const startDir = dir;
+  const visited = [dir];
+  while (dir !== dirname2(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      for (const d of visited) packageRootCache.set(d, dir);
+      return dir;
+    }
+    dir = dirname2(dir);
+    visited.push(dir);
+  }
+  for (const d of visited) packageRootCache.set(d, dir);
+  return dir;
+}
 
 // src/collect/function-registry.ts
 var FunctionRegistry = class extends DualHashRegistry {
@@ -2212,7 +2119,7 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts34 from "typescript";
+import * as ts33 from "typescript";
 function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
   return {
     filename,
@@ -2220,7 +2127,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
     sourceFile,
     checker,
     report(node, message) {
-      const { line, character } = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts33.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -2231,7 +2138,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts34.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts33.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -2282,21 +2189,23 @@ function collectProject(program, tsRules, allowedFiles) {
           rule.visit(node, ctx);
         }
       }
-      ts35.forEachChild(node, visit2);
+      ts34.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
     if (sourceFile.isDeclarationFile) continue;
     if (file.includes("node_modules")) continue;
-    if (allowedFiles && !allowedFiles.has(file)) continue;
+    const isReportable = !allowedFiles || allowedFiles.has(file);
     const source = sourceFile.getFullText();
-    const comments = collectAllComments(sourceFile);
-    fileMap.set(file, { source, sourceFile, comments });
-    const ruleContexts = tsRules?.map((rule) => ({
+    if (isReportable) {
+      const comments = collectAllComments(sourceFile);
+      fileMap.set(file, { source, sourceFile, comments });
+    }
+    const ruleContexts = isReportable ? tsRules?.map((rule) => ({
       rule,
       ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
-    }));
-    ts35.forEachChild(sourceFile, visit2);
+    })) : void 0;
+    ts34.forEachChild(sourceFile, visit2);
   }
   const fileHashes = /* @__PURE__ */ new Map();
   for (const [file, { source }] of fileMap) {
@@ -2312,52 +2221,52 @@ function collectProject(program, tsRules, allowedFiles) {
   return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
 }
 function hasNonPublicModifier(node) {
-  if (!ts35.canHaveModifiers(node)) return false;
-  const mods = ts35.getModifiers(node);
+  if (!ts34.canHaveModifiers(node)) return false;
+  const mods = ts34.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts35.SyntaxKind.PrivateKeyword || m.kind === ts35.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts34.SyntaxKind.PrivateKeyword || m.kind === ts34.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts35.canHaveModifiers(node)) return false;
-  const mods = ts35.getModifiers(node);
+  if (!ts34.canHaveModifiers(node)) return false;
+  const mods = ts34.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts35.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts34.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts35.isTypeAliasDeclaration(node)) {
-    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts34.isTypeAliasDeclaration(node)) {
+    const line = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts35.isInterfaceDeclaration(node)) {
-    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts34.isInterfaceDeclaration(node)) {
+    const line = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  if (ts35.isStringLiteral(node)) return true;
-  if (ts35.isNumericLiteral(node)) return true;
-  if (ts35.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts35.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
-  if (ts35.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  if (ts34.isStringLiteral(node)) return true;
+  if (ts34.isNumericLiteral(node)) return true;
+  if (ts34.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts34.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts34.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts35.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts35.NodeFlags.Const)) return;
+  if (!ts34.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts34.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts35.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts34.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 = ts35.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts34.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 = ts35.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const line = ts34.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
   const hash = hashFunctionBody(body, sourceFile);
@@ -2379,17 +2288,17 @@ function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name,
   };
 }
 function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts35.isFunctionDeclaration(node) && node.name && node.body) {
+  if (ts34.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 (ts35.isVariableStatement(node)) {
+  if (ts34.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts35.isArrowFunction(decl.initializer) && ts35.isIdentifier(decl.name)) {
+      if (decl.initializer && ts34.isArrowFunction(decl.initializer) && ts34.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
@@ -2397,7 +2306,7 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
           node: arrow
         }));
       }
-      if (decl.initializer && ts35.isFunctionExpression(decl.initializer) && ts35.isIdentifier(decl.name)) {
+      if (decl.initializer && ts34.isFunctionExpression(decl.initializer) && ts34.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
@@ -2409,22 +2318,22 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts35.isPropertyAssignment(node) && (ts35.isIdentifier(node.name) || ts35.isStringLiteral(node.name))) {
+  if (ts34.isPropertyAssignment(node) && (ts34.isIdentifier(node.name) || ts34.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts35.isArrowFunction(init)) {
+    if (ts34.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts35.isFunctionExpression(init) && init.body) {
+    if (ts34.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts35.isArrowFunction(node) || ts35.isFunctionExpression(node)) {
+  if (ts34.isArrowFunction(node) || ts34.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts35.isVariableDeclaration(parent) && ts35.isIdentifier(parent.name)) {
-    } else if (ts35.isPropertyAssignment(parent)) {
+    if (ts34.isVariableDeclaration(parent) && ts34.isIdentifier(parent.name)) {
+    } else if (ts34.isPropertyAssignment(parent)) {
     } else {
-      const body = ts35.isArrowFunction(node) ? node.body : node.body;
+      const body = ts34.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
         if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
@@ -2434,14 +2343,14 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts35.isMethodDeclaration(node) && node.body && ts35.isIdentifier(node.name)) {
+  if (ts34.isMethodDeclaration(node) && node.body && ts34.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts35.isClassDeclaration(parent)) {
+    if (ts34.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 === ts35.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts34.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
@@ -2464,16 +2373,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts35.isCallExpression(parent)) {
+  const line = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts34.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts35.isPropertyAssignment(grandparent) && ts35.isIdentifier(grandparent.name)) {
+    if (ts34.isPropertyAssignment(grandparent) && ts34.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts35.isIdentifier(parent.expression)) {
+    if (ts34.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts35.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts34.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -2484,7 +2393,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts35.isImportDeclaration(node) && ts35.isStringLiteral(node.moduleSpecifier)) {
+  if (ts34.isImportDeclaration(node) && ts34.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -2496,7 +2405,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts35.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts34.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -2507,9 +2416,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts35.isExportDeclaration(node) && node.moduleSpecifier && ts35.isStringLiteral(node.moduleSpecifier)) {
+  if (ts34.isExportDeclaration(node) && node.moduleSpecifier && ts34.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts35.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts34.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -2522,7 +2431,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts35.isBlock(node)) return;
+  if (!ts34.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -2539,32 +2448,32 @@ 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 = ts35.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts35.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts34.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts34.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 = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  const line = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts35.isCallExpression(node)) return;
+  if (!ts34.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts35.isIdentifier(node.expression)) {
+  if (ts34.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts35.isPropertyAccessExpression(node.expression)) {
+  } else if (ts34.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
     let resolvedDeclaration;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts35.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts34.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
       const signature = checker.getResolvedSignature(node);
@@ -2591,7 +2500,7 @@ function collectAllComments(sourceFile) {
     for (const r of ranges) {
       if (seen.has(r.pos)) continue;
       seen.add(r.pos);
-      const isLine = r.kind === ts35.SyntaxKind.SingleLineCommentTrivia;
+      const isLine = r.kind === ts34.SyntaxKind.SingleLineCommentTrivia;
       comments.push({
         type: isLine ? "Line" : "Block",
         value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -2601,53 +2510,63 @@ function collectAllComments(sourceFile) {
     }
   }
   function visit(node) {
-    addRanges(ts35.getLeadingCommentRanges(source, node.getFullStart()));
-    addRanges(ts35.getTrailingCommentRanges(source, node.getEnd()));
-    ts35.forEachChild(node, visit);
+    addRanges(ts34.getLeadingCommentRanges(source, node.getFullStart()));
+    addRanges(ts34.getTrailingCommentRanges(source, node.getEnd()));
+    ts34.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts36 from "typescript";
-import { dirname as dirname2 } from "path";
+import * as ts35 from "typescript";
+import { dirname as dirname3 } from "path";
 function createProgramFromFiles(files) {
   let configPath;
   if (files.length > 0) {
-    configPath = ts36.findConfigFile(dirname2(files[0]), ts36.sys.fileExists, "tsconfig.json");
+    configPath = ts35.findConfigFile(dirname3(files[0]), ts35.sys.fileExists, "tsconfig.json");
   }
   if (configPath) {
-    const configFile = ts36.readConfigFile(configPath, ts36.sys.readFile);
-    const parsed = ts36.parseJsonConfigFileContent(configFile.config, ts36.sys, dirname2(configPath));
-    return ts36.createProgram({
+    const configFile = ts35.readConfigFile(configPath, ts35.sys.readFile);
+    const parsed = ts35.parseJsonConfigFileContent(configFile.config, ts35.sys, dirname3(configPath));
+    return ts35.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts36.createProgram({
+  return ts35.createProgram({
     rootNames: files,
     options: {
-      target: ts36.ScriptTarget.ESNext,
-      module: ts36.ModuleKind.ESNext,
-      moduleResolution: ts36.ModuleResolutionKind.Bundler,
+      target: ts35.ScriptTarget.ESNext,
+      module: ts35.ModuleKind.ESNext,
+      moduleResolution: ts35.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
     }
   });
 }
+function resolveProjectFiles(scanFiles) {
+  if (scanFiles.length === 0) return [];
+  const configPath = ts35.findConfigFile(dirname3(scanFiles[0]), ts35.sys.fileExists, "tsconfig.json");
+  if (!configPath) return scanFiles;
+  const configFile = ts35.readConfigFile(configPath, ts35.sys.readFile);
+  const parsed = ts35.parseJsonConfigFileContent(configFile.config, ts35.sys, dirname3(configPath));
+  return [.../* @__PURE__ */ new Set([...scanFiles, ...parsed.fileNames])];
+}
 
 // src/scan/analyze.ts
 function analyzeFiles(files, rules) {
   const tsRules = rules.filter(isTSRule);
   const crossFileRules = rules.filter((r) => !isTSRule(r));
-  const program = files.length > 0 ? createProgramFromFiles(files) : null;
+  const projectFiles = resolveProjectFiles(files);
+  const program = projectFiles.length > 0 ? createProgramFromFiles(projectFiles) : null;
   if (!program) return [];
   const allowedFiles = new Set(files);
   const { index, diagnostics } = collectProject(program, tsRules, allowedFiles);
   for (const rule of crossFileRules) {
-    diagnostics.push(...rule.analyze(index));
+    const ruleDiagnostics = rule.analyze(index);
+    diagnostics.push(...ruleDiagnostics.filter((d) => allowedFiles.has(d.file)));
   }
   return finalizeDiagnostics(diagnostics, index.files);
 }
@@ -2791,7 +2710,7 @@ function lineAt(source, offset) {
 // src/scan/discover.ts
 import fg from "fast-glob";
 import ignore from "ignore";
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { relative, resolve as resolve2, sep } from "path";
 async function discoverFiles(config) {
   const globs = expandGlobs(config.paths);
@@ -2814,7 +2733,7 @@ function expandGlobs(paths) {
 }
 function applyGitIgnore(files) {
   const gitIgnorePath = resolve2(process.cwd(), ".gitignore");
-  if (!existsSync(gitIgnorePath)) return files;
+  if (!existsSync2(gitIgnorePath)) return files;
   const matcher = ignore().add(readFileSync(gitIgnorePath, "utf8"));
   return files.filter((file) => {
     const rel = relative(process.cwd(), file);
@@ -2929,4 +2848,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-2QER6GG7.js.map
+//# sourceMappingURL=chunk-WUH4JLMB.js.map