unguard 0.12.0 → 0.13.0

package/dist/{chunk-HE647T6E.js → chunk-KNKWDZ6H.js}

@@ -1,541 +1,450 @@
-// src/rules/ts/no-empty-catch.ts
+// src/rules/cross-file/dead-overload.ts
 import * as ts from "typescript";
-var noEmptyCatch = {
-  kind: "ts",
-  id: "no-empty-catch",
-  severity: "error",
-  message: "Empty catch blocks hide failures; handle, annotate, or rethrow explicitly",
-  visit(node, ctx) {
-    if (!ts.isCatchClause(node)) return;
-    const block = node.block;
-    if (block.statements.length > 0) return;
-    const blockStart = block.getStart(ctx.sourceFile);
-    const blockEnd = block.getEnd();
-    const inner = ctx.source.slice(blockStart + 1, blockEnd - 1);
-    if (inner.includes("//") || inner.includes("/*")) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/ts/no-non-null-assertion.ts
-import * as ts2 from "typescript";
-var noNonNullAssertion = {
-  kind: "ts",
-  id: "no-non-null-assertion",
+var deadOverload = {
+  id: "dead-overload",
   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 (!ts2.isNonNullExpression(node)) return;
-    const inner = node.expression;
-    if (!ctx.isNullable(inner)) return;
-    if (ctx.isExternal(inner)) return;
-    if (isSplitElementAccess(inner)) return;
-    if (isFilterElementAccess(inner)) return;
-    if (isLengthGuardedAccess(inner)) return;
-    ctx.report(node);
-  }
-};
-function isSplitElementAccess(node) {
-  if (!ts2.isElementAccessExpression(node)) return false;
-  const obj = node.expression;
-  if (!ts2.isCallExpression(obj)) return false;
-  const callee = obj.expression;
-  if (!ts2.isPropertyAccessExpression(callee)) return false;
-  return callee.name.text === "split";
-}
-function isFilterElementAccess(node) {
-  if (ts2.isElementAccessExpression(node)) {
-    const obj = node.expression;
-    if (ts2.isCallExpression(obj)) {
-      const callee = obj.expression;
-      if (ts2.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
-    }
-    if (ts2.isIdentifier(obj)) {
-      const init = findVariableInit(obj);
-      if (init && ts2.isCallExpression(init)) {
-        const callee = init.expression;
-        if (ts2.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+  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;
   }
-  return false;
+};
+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 isLengthGuardedAccess(node) {
-  if (!ts2.isElementAccessExpression(node)) return false;
-  const arr = node.expression;
-  const arrName = getIdentifierName(arr);
-  if (!arrName) return false;
-  if (isInsideForLoopBoundedBy(node, arrName)) return true;
-  return hasPrecedingLengthGuard(node, arrName);
+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 isInsideForLoopBoundedBy(node, arrName) {
-  let current = node;
-  while (current.parent) {
-    current = current.parent;
-    if (ts2.isForStatement(current) && current.condition) {
-      if (isLengthBoundCondition(current.condition, arrName)) return true;
+function hasIntersectionCast(body, sourceFile, paramName, constraintText) {
+  let found = false;
+  function visit(node) {
+    if (found) return;
+    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+      if (isConstraintIntersection(node.type, sourceFile, paramName, constraintText)) {
+        found = true;
+        return;
+      }
     }
+    ts.forEachChild(node, visit);
   }
-  return false;
+  visit(body);
+  return found;
 }
-function isLengthBoundCondition(cond, arrName) {
-  if (!ts2.isBinaryExpression(cond)) return false;
-  const op = cond.operatorToken.kind;
-  if (op === ts2.SyntaxKind.LessThanToken || op === ts2.SyntaxKind.LessThanEqualsToken) {
-    return isLengthAccess(cond.right, arrName);
-  }
-  if (op === ts2.SyntaxKind.GreaterThanToken || op === ts2.SyntaxKind.GreaterThanEqualsToken) {
-    return isLengthAccess(cond.left, arrName);
+function isConstraintIntersection(typeNode, sourceFile, paramName, constraintText) {
+  const target = unwrapParenthesizedType(typeNode);
+  if (!ts.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 false;
+  return hasParam && hasConstraint;
 }
-function isLengthAccess(node, arrName) {
-  if (!ts2.isPropertyAccessExpression(node)) return false;
-  if (node.name.text !== "length") return false;
-  return getIdentifierName(node.expression) === arrName;
+function unwrapParenthesizedType(typeNode) {
+  let current = typeNode;
+  while (ts.isParenthesizedTypeNode(current)) {
+    current = current.type;
+  }
+  return current;
 }
-function hasPrecedingLengthGuard(node, arrName) {
-  let current = node;
-  while (current.parent) {
-    const parent = current.parent;
-    if (ts2.isBlock(parent)) {
-      for (const stmt of parent.statements) {
-        if (stmt === current || stmt.pos >= current.pos) break;
-        if (ts2.isIfStatement(stmt) && isLengthGuardWithEarlyExit(stmt, arrName)) return true;
-      }
+function collectOverloadFamilies(sourceFile, file) {
+  const families = [];
+  collectFromList(sourceFile.statements, sourceFile, file, families);
+  function visit(node) {
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+      collectFromList(node.members, sourceFile, file, families);
     }
-    if (ts2.isIfStatement(parent) && parent.thenStatement === current) {
-      if (isPositiveLengthCheck(parent.expression, arrName)) return true;
+    ts.forEachChild(node, visit);
+  }
+  ts.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++;
     }
-    if (ts2.isBlock(current) && ts2.isIfStatement(parent) && parent.thenStatement === current) {
-      if (isPositiveLengthCheck(parent.expression, arrName)) return true;
+    const family = toOverloadFamily(run, name, file, sourceFile);
+    if (family !== null) {
+      families.push(family);
     }
-    current = parent;
+    index = nextIndex - 1;
   }
-  return false;
 }
-function isLengthGuardWithEarlyExit(stmt, arrName) {
-  if (!isEarlyExit(stmt.thenStatement)) return false;
-  return isZeroLengthCheck(stmt.expression, arrName);
+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 isZeroLengthCheck(expr, arrName) {
-  if (!ts2.isBinaryExpression(expr)) return false;
-  const op = expr.operatorToken.kind;
-  if (op === ts2.SyntaxKind.EqualsEqualsEqualsToken || op === ts2.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 === ts2.SyntaxKind.LessThanToken) {
-    if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
-  }
-  if (op === ts2.SyntaxKind.ExclamationEqualsEqualsToken || op === ts2.SyntaxKind.ExclamationEqualsToken) {
-    if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
-  }
-  return false;
+function asOverloadDeclaration(node) {
+  if (node === void 0) return null;
+  if (ts.isFunctionDeclaration(node)) return node;
+  if (ts.isMethodDeclaration(node)) return node;
+  return null;
 }
-function isPositiveLengthCheck(expr, arrName) {
-  if (!ts2.isBinaryExpression(expr)) return false;
-  const op = expr.operatorToken.kind;
-  if (op === ts2.SyntaxKind.GreaterThanToken) {
-    if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
-  }
-  if (op === ts2.SyntaxKind.GreaterThanEqualsToken) {
-    if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
+function getDeclarationName(node) {
+  if (ts.isFunctionDeclaration(node)) {
+    return node.name?.text ?? null;
   }
-  if (op === ts2.SyntaxKind.ExclamationEqualsEqualsToken || op === ts2.SyntaxKind.ExclamationEqualsToken) {
-    if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
+  if (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name) || ts.isNumericLiteral(node.name)) {
+    return node.name.text;
   }
-  return false;
+  return null;
 }
-function isEarlyExit(stmt) {
-  if (ts2.isReturnStatement(stmt) || ts2.isThrowStatement(stmt)) return true;
-  if (ts2.isBlock(stmt) && stmt.statements.length === 1) {
-    const inner = stmt.statements[0];
-    if (inner === void 0) return false;
-    return ts2.isReturnStatement(inner) || ts2.isThrowStatement(inner);
-  }
-  return false;
+function lineOf(sourceFile, node) {
+  return ts.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
 }
-function isNumericLiteralValue(node, value) {
-  return ts2.isNumericLiteral(node) && node.text === String(value);
+function normalizeText(text) {
+  return text.replace(/\s+/g, "");
 }
-function isNumericLiteralGte(node, min) {
-  return ts2.isNumericLiteral(node) && Number(node.text) >= min;
+
+// src/rules/types.ts
+function isTSRule(r) {
+  return "kind" in r && r.kind === "ts";
 }
-function getIdentifierName(node) {
-  if (ts2.isIdentifier(node)) return node.text;
-  return null;
-}
-function findVariableInit(id) {
-  const sourceFile = id.getSourceFile();
-  let result;
-  function visit(node) {
-    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
-      result = node.initializer;
-    }
-    if (!result) ts2.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return result;
-}
-
-// src/rules/ts/no-double-negation-coercion.ts
-import * as ts4 from "typescript";
-
-// src/typecheck/utils.ts
-import * as ts3 from "typescript";
-function hasFlags(flags, mask) {
-  return (flags & mask) !== 0;
-}
-var NULLISH_FLAGS = ts3.TypeFlags.Null | ts3.TypeFlags.Undefined | ts3.TypeFlags.Void;
-function isNullableType(checker, type) {
-  if (type.isUnion()) {
-    return type.types.some((t) => hasFlags(t.flags, NULLISH_FLAGS));
-  }
-  return hasFlags(type.flags, NULLISH_FLAGS);
-}
-function isFromNodeModules(node) {
-  const sourceFile = node.getSourceFile();
-  return sourceFile.fileName.includes("/node_modules/");
-}
-function includesNumberType(type) {
-  if (type.isUnion()) {
-    return type.types.some((t) => hasFlags(t.flags, ts3.TypeFlags.NumberLike));
-  }
-  return hasFlags(type.flags, ts3.TypeFlags.NumberLike);
-}
-function includesBooleanType(type) {
-  if (type.isUnion()) {
-    return type.types.some((t) => hasFlags(t.flags, ts3.TypeFlags.BooleanLike));
-  }
-  return hasFlags(type.flags, ts3.TypeFlags.BooleanLike);
-}
-function isNullishLiteral(node) {
-  if (node.kind === ts3.SyntaxKind.NullKeyword) return true;
-  if (ts3.isIdentifier(node) && node.text === "undefined") return true;
-  return false;
-}
-function getFunctionBodyStatements(node) {
-  if (!ts3.isFunctionDeclaration(node) && !ts3.isArrowFunction(node)) return null;
-  if (!node.body || !ts3.isBlock(node.body)) return null;
-  if (node.body.statements.length === 0) return null;
-  return { statements: node.body.statements, fn: node };
+function reportDuplicateGroup(group, ruleId, severity, formatOther, formatMessage, diagnostics) {
+  const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+  for (const entry of sorted.slice(1)) {
+    const others = sorted.filter((e) => e !== entry).map(formatOther).join(", ");
+    diagnostics.push({
+      ruleId,
+      severity,
+      message: formatMessage(entry, others),
+      file: entry.file,
+      line: entry.line,
+      column: 1
+    });
+  }
 }
 
-// src/rules/ts/no-double-negation-coercion.ts
-var noDoubleNegationCoercion = {
-  kind: "ts",
-  id: "no-double-negation-coercion",
-  severity: "info",
-  message: "!! coercion hides intent; use an explicit check (!== null, !== undefined, .length > 0) so the condition documents what it tests",
-  visit(node, ctx) {
-    if (!ts4.isPrefixUnaryExpression(node)) return;
-    if (node.operator !== ts4.SyntaxKind.ExclamationToken) return;
-    const inner = node.operand;
-    if (!ts4.isPrefixUnaryExpression(inner)) return;
-    if (inner.operator !== ts4.SyntaxKind.ExclamationToken) return;
-    const operand = inner.operand;
-    const innerType = ctx.checker.getTypeAtLocation(operand);
-    if (includesBooleanType(innerType) && !(innerType.flags & ts4.TypeFlags.Union)) {
-      ctx.report(node, "!! on an already-boolean type is a no-op; remove the double negation");
-      return;
+// src/rules/cross-file/duplicate-constant-declaration.ts
+var duplicateConstantDeclaration = {
+  id: "duplicate-constant-declaration",
+  severity: "warning",
+  message: "Identical constant value declared in multiple files; consolidate to a single definition",
+  analyze(project) {
+    const diagnostics = [];
+    for (const group of project.constants.getDuplicateGroups()) {
+      const files = new Set(group.map((e) => e.file));
+      if (files.size < 2) continue;
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.name} (${e.file}:${e.line})`,
+        (e, others) => `Constant "${e.name}" has identical value \`${e.valueText}\` to: ${others}`,
+        diagnostics
+      );
     }
-    if (isBitwiseExpression(operand)) return;
-    ctx.report(node);
+    return diagnostics;
   }
 };
-var BITWISE_OPS = /* @__PURE__ */ new Set([
-  ts4.SyntaxKind.AmpersandToken,
-  ts4.SyntaxKind.BarToken,
-  ts4.SyntaxKind.CaretToken,
-  ts4.SyntaxKind.LessThanLessThanToken,
-  ts4.SyntaxKind.GreaterThanGreaterThanToken,
-  ts4.SyntaxKind.GreaterThanGreaterThanGreaterThanToken
-]);
-function isBitwiseExpression(node) {
-  if (ts4.isBinaryExpression(node) && BITWISE_OPS.has(node.operatorToken.kind)) return true;
-  if (ts4.isParenthesizedExpression(node)) return isBitwiseExpression(node.expression);
-  return false;
-}
 
-// src/rules/ts/no-ts-ignore.ts
-import * as ts5 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 = ts5.getLeadingCommentRanges(ctx.source, node.getFullStart());
-    if (!ranges) return;
-    for (const range of ranges) {
-      const text = ctx.source.slice(range.pos, range.end);
-      if (text.includes("@ts-ignore") || text.includes("@ts-expect-error")) {
-        ctx.reportAtOffset(range.pos);
+// src/rules/cross-file/duplicate-file.ts
+var duplicateFile = {
+  id: "duplicate-file",
+  severity: "warning",
+  message: "File has identical content to another file; one is likely dead code",
+  analyze(project) {
+    const diagnostics = [];
+    for (const files of project.fileHashes.values()) {
+      if (files.length < 2) continue;
+      const sorted = [...files].sort();
+      for (const file of sorted.slice(1)) {
+        const others = sorted.filter((f) => f !== file).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `File is identical to: ${others}`,
+          file,
+          line: 1,
+          column: 1
+        });
       }
     }
+    return diagnostics;
   }
 };
 
-// src/rules/ts/no-nullish-coalescing.ts
-import * as ts6 from "typescript";
-var noNullishCoalescing = {
-  kind: "ts",
-  id: "no-nullish-coalescing",
+// src/rules/cross-file/duplicate-function-declaration.ts
+import * as ts2 from "typescript";
+var duplicateFunctionDeclaration = {
+  id: "duplicate-function-declaration",
   severity: "warning",
-  message: "Nullish coalescing (??) on a non-nullable type is unreachable; remove the fallback or fix the type upstream",
-  visit(node, ctx) {
-    if (!ts6.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts6.SyntaxKind.QuestionQuestionToken) return;
-    if (isPossiblyMissingArrayBindingValue(node.left, ctx)) return;
-    if (ctx.isNullable(node.left)) return;
-    ctx.report(node);
-  }
-};
-function isPossiblyMissingArrayBindingValue(node, ctx) {
-  if (!ts6.isIdentifier(node)) return false;
-  const symbol = ctx.checker.getSymbolAtLocation(node);
-  if (!symbol) return false;
-  for (const declaration of symbol.declarations ?? []) {
-    if (!ts6.isBindingElement(declaration)) continue;
-    if (declaration.initializer || declaration.dotDotDotToken) continue;
-    if (!ts6.isArrayBindingPattern(declaration.parent)) continue;
-    const pattern = declaration.parent;
-    const index = pattern.elements.indexOf(declaration);
-    if (index < 0) continue;
-    if (!isTupleSlotDefinitelyPresent(ctx.checker.getTypeAtLocation(pattern), index, ctx.checker)) {
-      return true;
+  message: "Identical function body declared in multiple files; consolidate to a single definition",
+  analyze(project) {
+    const diagnostics = [];
+    for (const group of project.functions.getDuplicateGroups()) {
+      const first = group[0];
+      if (first === void 0) continue;
+      if (isSingleStatement(first.node)) continue;
+      if (isSetter(first.node)) continue;
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.name} (${e.file}:${e.line})`,
+        (e, others) => `Function "${e.name}" has identical body to: ${others}`,
+        diagnostics
+      );
     }
+    return diagnostics;
   }
-  return false;
+};
+function getBodyBlock(node) {
+  if (ts2.isFunctionDeclaration(node) || ts2.isFunctionExpression(node)) return node.body;
+  if (ts2.isArrowFunction(node)) return ts2.isBlock(node.body) ? node.body : void 0;
+  if (ts2.isMethodDeclaration(node)) return node.body;
+  return void 0;
 }
-function isTupleSlotDefinitelyPresent(type, index, checker) {
-  if (type.isUnion()) {
-    return type.types.every((member) => isTupleSlotDefinitelyPresent(member, index, checker));
-  }
-  const apparent = checker.getApparentType(type);
-  if (!isTupleTypeReference(apparent, checker)) return false;
-  return index < apparent.target.minLength;
+function isSingleStatement(node) {
+  if (ts2.isArrowFunction(node) && !ts2.isBlock(node.body)) return true;
+  const body = getBodyBlock(node);
+  return body !== void 0 && body.statements.length <= 1;
 }
-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";
+function isSetter(node) {
+  const body = getBodyBlock(node);
+  if (!body || body.statements.length !== 1) return false;
+  const stmt = body.statements[0];
+  if (stmt === void 0 || !ts2.isExpressionStatement(stmt)) return false;
+  return ts2.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts2.SyntaxKind.EqualsToken;
 }
 
-// src/rules/ts/no-optional-call.ts
-import * as ts7 from "typescript";
-var noOptionalCall = {
-  kind: "ts",
-  id: "no-optional-call",
+// src/rules/cross-file/duplicate-function-name.ts
+import { dirname, resolve } from "path";
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var duplicateFunctionName = {
+  id: "duplicate-function-name",
   severity: "warning",
-  message: "Optional call (?.) on a non-nullable function is redundant; call directly or fix the type upstream",
-  visit(node, ctx) {
-    if (!ts7.isCallExpression(node)) return;
-    if (!node.questionDotToken) return;
-    if (ctx.isNullable(node.expression)) return;
-    ctx.report(node);
+  message: "Same function name exported from multiple files; consolidate or rename to avoid ambiguity",
+  analyze(project) {
+    const diagnostics = [];
+    for (const group of project.functions.getNameCollisionGroups()) {
+      const hashes = new Set(group.map((e) => e.hash));
+      if (hashes.size === 1) continue;
+      const groupFiles = new Set(group.map((e) => e.file));
+      const first = group[0];
+      if (first === void 0) continue;
+      const funcName = first.name;
+      const hasImportLink = project.imports.some((imp) => {
+        if (!groupFiles.has(imp.file)) return false;
+        if (imp.importedName !== funcName && imp.localName !== funcName) return false;
+        if (!imp.source.startsWith(".")) return false;
+        const candidates = resolveCandidates(imp.file, imp.source);
+        if (candidates.some((c) => groupFiles.has(c))) return true;
+        return candidates.some(
+          (c) => project.imports.some((reExp) => {
+            if (reExp.file !== c) return false;
+            if (reExp.importedName !== funcName && reExp.localName !== funcName) return false;
+            if (!reExp.source.startsWith(".")) return false;
+            const innerCandidates = resolveCandidates(reExp.file, reExp.source);
+            return innerCandidates.some((ic) => groupFiles.has(ic));
+          })
+        );
+      });
+      if (hasImportLink) continue;
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.file}:${e.line}`,
+        (e, others) => `Exported function "${e.name}" also defined in: ${others}`,
+        diagnostics
+      );
+    }
+    return diagnostics;
   }
 };
+function resolveCandidates(fromFile, specifier) {
+  const base = resolve(dirname(fromFile), specifier);
+  const candidates = [base];
+  for (const ext of EXTENSIONS) {
+    candidates.push(base + ext);
+    candidates.push(resolve(base, `index${ext}`));
+  }
+  return candidates;
+}
 
-// src/rules/ts/no-optional-property-access.ts
-import * as ts8 from "typescript";
-var noOptionalPropertyAccess = {
-  kind: "ts",
-  id: "no-optional-property-access",
+// src/rules/cross-file/duplicate-inline-type-in-params.ts
+var duplicateInlineTypeInParams = {
+  id: "duplicate-inline-type-in-params",
   severity: "warning",
-  message: "Optional chaining (?.) on a non-nullable type is redundant; use direct access or fix the type upstream",
-  visit(node, ctx) {
-    if (!ts8.isPropertyAccessExpression(node)) return;
-    if (!node.questionDotToken) return;
-    if (ctx.isNullable(node.expression)) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/ts/no-optional-element-access.ts
-import * as ts9 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 (!ts9.isElementAccessExpression(node)) return;
-    if (!node.questionDotToken) return;
-    if (ctx.isNullable(node.expression)) return;
-    ctx.report(node);
+  message: "Same inline param type shape appears in multiple places; extract to a shared named type",
+  analyze(project) {
+    const diagnostics = [];
+    for (const group of project.inlineParamTypes.getDuplicateGroups()) {
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.typeText} (${e.file}:${e.line})`,
+        (e, others) => `Inline param type \`${e.typeText}\` also appears at: ${others}`,
+        diagnostics
+      );
+    }
+    return diagnostics;
   }
 };
 
-// src/rules/ts/no-logical-or-fallback.ts
-import * as ts10 from "typescript";
-var noLogicalOrFallback = {
-  kind: "ts",
-  id: "no-logical-or-fallback",
-  severity: "warning",
-  message: '|| fallback on a data-structure lookup swallows valid falsy values (0, ""); use ?? to only catch null/undefined',
-  visit(node, ctx) {
-    if (!ts10.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts10.SyntaxKind.BarBarToken) return;
-    const right = node.right;
-    if (!isLiteral(right)) return;
-    const left = node.left;
-    const lhsType = ctx.checker.getTypeAtLocation(left);
-    if (isNumericCoercionCall(left)) return;
-    if (isStringNotNullable(lhsType, ctx.checker)) return;
-    if (includesNumberType(lhsType) && !isZeroLiteral(right)) {
-      ctx.report(node, "|| on a numeric type swallows 0; use ?? to only catch null/undefined");
-      return;
-    }
-    if (isDataStructureLookup(left)) {
-      ctx.report(node);
+// src/rules/cross-file/duplicate-statement-sequence.ts
+var duplicateStatementSequence = {
+  id: "duplicate-statement-sequence",
+  severity: "info",
+  message: "Repeated statement sequence; consider extracting to a shared helper",
+  analyze(project) {
+    const diagnostics = [];
+    const MIN_NORMALIZED_BODY = 128;
+    for (const group of project.statementSequences.getNormalizedDuplicateGroups()) {
+      if (group.every((e) => e.normalizedBodyLength < MIN_NORMALIZED_BODY)) continue;
+      const byLocation = /* @__PURE__ */ new Map();
+      for (const entry of group) {
+        const key = `${entry.file}:${entry.line}`;
+        const existing = byLocation.get(key);
+        if (existing === void 0 || entry.statementCount > existing.statementCount) {
+          byLocation.set(key, entry);
+        }
+      }
+      const deduped = [...byLocation.values()];
+      if (deduped.length < 2) continue;
+      const sorted = deduped.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+      for (const entry of sorted.slice(1)) {
+        const others = sorted.filter((e) => e !== entry).map((e) => `${e.file}:${e.line}`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `Statement sequence (${entry.statementCount} statements) duplicated at: ${others}`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
     }
+    return diagnostics;
   }
 };
-function isStringNotNullable(type, checker) {
-  if (isNullableType(checker, type)) return false;
-  if (type.isUnion()) {
-    return type.types.every((t) => (t.flags & ts10.TypeFlags.StringLike) !== 0);
-  }
-  return (type.flags & ts10.TypeFlags.StringLike) !== 0;
-}
-function isLiteral(node) {
-  if (ts10.isStringLiteral(node) || ts10.isNumericLiteral(node) || ts10.isNoSubstitutionTemplateLiteral(node)) return true;
-  if (ts10.isTemplateExpression(node)) return true;
-  if (ts10.isArrayLiteralExpression(node) || ts10.isObjectLiteralExpression(node)) return true;
-  if (ts10.isIdentifier(node) && node.text === "undefined") return true;
-  if (node.kind === ts10.SyntaxKind.NullKeyword) return true;
-  if (node.kind === ts10.SyntaxKind.TrueKeyword || node.kind === ts10.SyntaxKind.FalseKeyword) return true;
-  return false;
-}
-function isNumericCoercionCall(node) {
-  if (!ts10.isCallExpression(node)) return false;
-  if (!ts10.isIdentifier(node.expression)) return false;
-  const name = node.expression.text;
-  return name === "Number" || name === "parseInt" || name === "parseFloat";
-}
-function isZeroLiteral(node) {
-  return ts10.isNumericLiteral(node) && node.text === "0";
-}
-function isDataStructureLookup(left) {
-  if (ts10.isCallExpression(left)) {
-    const callee = left.expression;
-    if (ts10.isPropertyAccessExpression(callee)) {
-      const methodName = callee.name.text;
-      if (methodName === "find" || methodName === "getStore" || methodName === "get") return true;
-    }
-  }
-  if (ts10.isElementAccessExpression(left)) return true;
-  if (hasOptionalChaining(left)) return true;
-  return false;
-}
-function hasOptionalChaining(node) {
-  if (ts10.isPropertyAccessExpression(node) && node.questionDotToken) return true;
-  if (ts10.isElementAccessExpression(node) && node.questionDotToken) return true;
-  if (ts10.isCallExpression(node) && node.questionDotToken) return true;
-  if (ts10.isPropertyAccessExpression(node)) return hasOptionalChaining(node.expression);
-  if (ts10.isCallExpression(node)) return hasOptionalChaining(node.expression);
-  if (ts10.isElementAccessExpression(node)) return hasOptionalChaining(node.expression);
-  return false;
-}
 
-// src/rules/ts/no-null-ternary-normalization.ts
-import * as ts11 from "typescript";
-var noNullTernaryNormalization = {
-  kind: "ts",
-  id: "no-null-ternary-normalization",
+// src/rules/cross-file/duplicate-type-declaration.ts
+import * as ts3 from "typescript";
+var duplicateTypeDeclaration = {
+  id: "duplicate-type-declaration",
   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 (!ts11.isConditionalExpression(node)) return;
-    const test = node.condition;
-    if (!ts11.isBinaryExpression(test)) return;
-    const op = test.operatorToken.kind;
-    if (op !== ts11.SyntaxKind.EqualsEqualsEqualsToken && op !== ts11.SyntaxKind.ExclamationEqualsEqualsToken && op !== ts11.SyntaxKind.EqualsEqualsToken && op !== ts11.SyntaxKind.ExclamationEqualsToken) return;
-    const hasNullishComparand = isNullish(test.left) || isNullish(test.right);
-    if (!hasNullishComparand) return;
-    if (isNullish(node.whenTrue) || isNullish(node.whenFalse)) {
-      const tested = isNullish(test.left) ? test.right : test.left;
-      if (!ctx.isNullable(tested)) {
-        ctx.report(node, "Ternary null-normalization on a non-nullable type is dead code; remove the ternary");
-        return;
-      }
-      ctx.report(node);
+  message: "Identical type shape declared in multiple files; consolidate to a single definition",
+  analyze(project) {
+    const diagnostics = [];
+    for (const group of project.types.getDuplicateGroups()) {
+      const files = new Set(group.map((e) => e.file));
+      if (files.size < 2) continue;
+      if (group.every((e) => isTrivialObjectShape(e.node))) continue;
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.name} (${e.file}:${e.line})`,
+        (e, others) => `Type "${e.name}" has identical shape to: ${others}`,
+        diagnostics
+      );
     }
+    return diagnostics;
   }
 };
-function isNullish(node) {
-  if (node.kind === ts11.SyntaxKind.NullKeyword) return true;
-  if (ts11.isIdentifier(node) && node.text === "undefined") return true;
-  if (ts11.isVoidExpression(node)) return true;
+function isTrivialObjectShape(node) {
+  if (ts3.isTypeLiteralNode(node)) return node.members.length <= 1;
+  if (ts3.isInterfaceDeclaration(node)) return node.members.length <= 1;
   return false;
 }
 
-// src/rules/ts/no-any-cast.ts
-import * as ts12 from "typescript";
-var noAnyCast = {
-  kind: "ts",
-  id: "no-any-cast",
-  severity: "error",
-  message: "Casting to `any` erases type safety; use a specific type or generic instead",
-  visit(node, ctx) {
-    if (!ts12.isAsExpression(node)) return;
-    if (node.type.kind !== ts12.SyntaxKind.AnyKeyword) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/ts/no-explicit-any-annotation.ts
-import * as ts13 from "typescript";
-var noExplicitAnyAnnotation = {
-  kind: "ts",
-  id: "no-explicit-any-annotation",
-  severity: "error",
-  message: "Explicit `any` annotation erases type safety; use a specific type, `unknown`, or a generic",
-  visit(node, ctx) {
-    if (node.kind !== ts13.SyntaxKind.AnyKeyword) return;
-    if (node.parent && ts13.isAsExpression(node.parent)) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/types.ts
-function isTSRule(r) {
-  return "kind" in r && r.kind === "ts";
-}
-function reportDuplicateGroup(group, ruleId, severity, formatOther, formatMessage, diagnostics) {
-  const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-  for (const entry of sorted.slice(1)) {
-    const others = sorted.filter((e) => e !== entry).map(formatOther).join(", ");
-    diagnostics.push({
-      ruleId,
-      severity,
-      message: formatMessage(entry, others),
-      file: entry.file,
-      line: entry.line,
-      column: 1
-    });
-  }
-}
-
-// src/rules/cross-file/duplicate-inline-type-in-params.ts
-var duplicateInlineTypeInParams = {
-  id: "duplicate-inline-type-in-params",
+// src/rules/cross-file/duplicate-type-name.ts
+import * as ts4 from "typescript";
+var duplicateTypeName = {
+  id: "duplicate-type-name",
   severity: "warning",
-  message: "Same inline param type shape appears in multiple places; extract to a shared named type",
+  message: "Same type name exported from multiple files; consolidate or rename to avoid ambiguity",
   analyze(project) {
     const diagnostics = [];
-    for (const group of project.inlineParamTypes.getDuplicateGroups()) {
+    for (const group of project.types.getNameCollisionGroups()) {
+      const hashes = new Set(group.map((e) => e.hash));
+      if (hashes.size === 1) continue;
+      const hasInferredType = group.some(
+        (e) => !ts4.isTypeLiteralNode(e.node) && !ts4.isInterfaceDeclaration(e.node)
+      );
+      if (hasInferredType) continue;
       reportDuplicateGroup(
         group,
         this.id,
         this.severity,
-        (e) => `${e.typeText} (${e.file}:${e.line})`,
-        (e, others) => `Inline param type \`${e.typeText}\` also appears at: ${others}`,
+        (e) => `${e.file}:${e.line}`,
+        (e, others) => `Exported type "${e.name}" also defined in: ${others}`,
         diagnostics
       );
     }
@@ -543,222 +452,151 @@ var duplicateInlineTypeInParams = {
   }
 };
 
-// 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/cross-file/explicit-null-arg.ts
+import * as ts6 from "typescript";
 
-// 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 (!ts15.isAsExpression(node)) return;
-    if (!ts15.isAsExpression(node.expression)) return;
-    if (node.expression.type.kind !== ts15.SyntaxKind.UnknownKeyword) return;
-    ctx.report(node);
+// src/typecheck/utils.ts
+import * as ts5 from "typescript";
+function hasFlags(flags, mask) {
+  return (flags & mask) !== 0;
+}
+var NULLISH_FLAGS = ts5.TypeFlags.Null | ts5.TypeFlags.Undefined | ts5.TypeFlags.Void;
+function isNullableType(checker, type) {
+  if (type.isUnion()) {
+    return type.types.some((t) => hasFlags(t.flags, NULLISH_FLAGS));
   }
-};
-
-// src/rules/ts/no-redundant-existence-guard.ts
-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 (!ts16.isBinaryExpression(node)) return;
-    if (node.operatorToken.kind !== ts16.SyntaxKind.AmpersandAmpersandToken) return;
-    const left = node.left;
-    const right = node.right;
-    if (ts16.isIdentifier(left) && accessesIdentifier(right, left.text)) {
-      if (ctx.isNullable(left)) return;
-      ctx.report(node);
-      return;
-    }
-    if (ts16.isBinaryExpression(left) && isNullCheck(left)) {
-      const checked = getNullCheckedIdentifier(left);
-      if (checked && accessesIdentifier(right, checked)) {
-        const identNode = ts16.isIdentifier(left.left) ? left.left : left.right;
-        if (ts16.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
-          ctx.report(node);
-        }
-      }
-    }
+  return hasFlags(type.flags, NULLISH_FLAGS);
+}
+function isFromNodeModules(node) {
+  const sourceFile = node.getSourceFile();
+  return sourceFile.fileName.includes("/node_modules/");
+}
+function includesNumberType(type) {
+  if (type.isUnion()) {
+    return type.types.some((t) => hasFlags(t.flags, ts5.TypeFlags.NumberLike));
   }
-};
-function accessesIdentifier(expr, name) {
-  const root = getExpressionRoot(expr);
-  return ts16.isIdentifier(root) && root.text === name;
+  return hasFlags(type.flags, ts5.TypeFlags.NumberLike);
 }
-function getExpressionRoot(node) {
-  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 includesBooleanType(type) {
+  if (type.isUnion()) {
+    return type.types.some((t) => hasFlags(t.flags, ts5.TypeFlags.BooleanLike));
+  }
+  return hasFlags(type.flags, ts5.TypeFlags.BooleanLike);
 }
-function isNullCheck(expr) {
-  const op = expr.operatorToken.kind;
-  if (op !== ts16.SyntaxKind.ExclamationEqualsToken && op !== ts16.SyntaxKind.ExclamationEqualsEqualsToken) return false;
-  return isNullishLiteral(expr.right) || isNullishLiteral(expr.left);
+function isNullishLiteral(node) {
+  if (node.kind === ts5.SyntaxKind.NullKeyword) return true;
+  if (ts5.isIdentifier(node) && node.text === "undefined") return true;
+  return false;
 }
-function getNullCheckedIdentifier(expr) {
-  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;
+function getFunctionBodyStatements(node) {
+  if (!ts5.isFunctionDeclaration(node) && !ts5.isArrowFunction(node)) return null;
+  if (!node.body || !ts5.isBlock(node.body)) return null;
+  if (node.body.statements.length === 0) return null;
+  return { statements: node.body.statements, fn: node };
+}
+function getFirstFunctionStatement(node) {
+  const result = getFunctionBodyStatements(node);
+  if (result === null) return null;
+  const firstStmt = result.statements[0];
+  if (firstStmt === void 0) return null;
+  return { firstStmt, fn: result.fn };
+}
+function isInlineParamType(node) {
+  if (!ts5.isTypeLiteralNode(node)) return false;
+  const parent = node.parent;
+  if (!parent || !ts5.isParameter(parent)) return false;
+  return parent.type === node;
 }
 
-// src/rules/ts/prefer-default-param-value.ts
-import * as ts17 from "typescript";
-var preferDefaultParamValue = {
-  kind: "ts",
-  id: "prefer-default-param-value",
-  severity: "info",
-  message: "Use a default parameter value instead of reassigning from nullish coalescing inside the body",
-  visit(node, ctx) {
-    const result = getFunctionBodyStatements(node);
-    if (result === null) return;
-    const { statements: stmts, fn } = result;
-    const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts17.isExpressionStatement(firstStmt)) return;
-    const expr = firstStmt.expression;
-    if (!ts17.isBinaryExpression(expr) || expr.operatorToken.kind !== ts17.SyntaxKind.EqualsToken) return;
-    const right = expr.right;
-    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) => ts17.isIdentifier(p.name) && p.name.text === paramName);
-    if (isParam) ctx.report(firstStmt);
-  }
-};
-
-// src/rules/ts/prefer-required-param-with-guard.ts
-import * as ts18 from "typescript";
-var preferRequiredParamWithGuard = {
-  kind: "ts",
-  id: "prefer-required-param-with-guard",
-  severity: "info",
-  message: "Optional param with immediate guard (if (!param) return/throw); make it required instead",
-  visit(node, ctx) {
-    const result = getFunctionBodyStatements(node);
-    if (result === null) return;
-    const { statements: stmts, fn } = result;
-    const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts18.isIfStatement(firstStmt)) return;
-    const test = firstStmt.expression;
-    let guardedName = null;
-    if (ts18.isPrefixUnaryExpression(test) && test.operator === ts18.SyntaxKind.ExclamationToken) {
-      if (ts18.isIdentifier(test.operand)) guardedName = test.operand.text;
-    }
-    if (ts18.isBinaryExpression(test)) {
-      const op = test.operatorToken.kind;
-      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 = 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) => 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 ts19 from "typescript";
-var duplicateTypeDeclaration = {
-  id: "duplicate-type-declaration",
+// src/rules/cross-file/explicit-null-arg.ts
+var explicitNullArg = {
+  id: "explicit-null-arg",
   severity: "warning",
-  message: "Identical type shape declared in multiple files; consolidate to a single definition",
+  message: "Explicit null/undefined passed to a project function; consider redesigning the interface to not accept nullish values",
   analyze(project) {
     const diagnostics = [];
-    for (const group of project.types.getDuplicateGroups()) {
-      const files = new Set(group.map((e) => e.file));
-      if (files.size < 2) continue;
-      if (group.every((e) => isTrivialObjectShape(e.node))) continue;
-      reportDuplicateGroup(
-        group,
-        this.id,
-        this.severity,
-        (e) => `${e.name} (${e.file}:${e.line})`,
-        (e, others) => `Type "${e.name}" has identical shape to: ${others}`,
-        diagnostics
-      );
+    const projectFnNames = /* @__PURE__ */ new Set();
+    const projectFnSymbols = /* @__PURE__ */ new Set();
+    for (const fn of project.functions.getAll()) {
+      projectFnNames.add(fn.name);
+      if (fn.symbol) projectFnSymbols.add(fn.symbol);
+    }
+    for (const site of project.callSites) {
+      const isProjectFn = site.symbol ? projectFnSymbols.has(site.symbol) : projectFnNames.has(site.calleeName);
+      if (!isProjectFn) continue;
+      for (let i = 0; i < site.node.arguments.length; i++) {
+        const arg = site.node.arguments[i];
+        if (arg === void 0) continue;
+        if (isNullishLiteral(arg)) {
+          const val = arg.kind === ts6.SyntaxKind.NullKeyword ? "null" : "undefined";
+          diagnostics.push({
+            ruleId: this.id,
+            severity: this.severity,
+            message: `Passing explicit ${val} to "${site.calleeName}" at argument ${i + 1}; consider redesigning the interface to not accept nullish values`,
+            file: site.file,
+            line: site.line,
+            column: 1
+          });
+          break;
+        }
+      }
     }
     return diagnostics;
   }
 };
-function isTrivialObjectShape(node) {
-  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 ts20 from "typescript";
-var duplicateFunctionDeclaration = {
-  id: "duplicate-function-declaration",
+// src/rules/cross-file/near-duplicate-function.ts
+import * as ts7 from "typescript";
+var nearDuplicateFunction = {
+  id: "near-duplicate-function",
   severity: "warning",
-  message: "Identical function body declared in multiple files; consolidate to a single definition",
+  message: "Near-duplicate function bodies across files; consider parameterizing",
   analyze(project) {
     const diagnostics = [];
-    for (const group of project.functions.getDuplicateGroups()) {
-      const first = group[0];
-      if (first === void 0) continue;
-      if (isSingleStatement(first.node)) continue;
-      if (isSetter(first.node)) continue;
+    for (const group of project.functions.getNearDuplicateGroups()) {
+      const MIN_NORMALIZED_BODY = 32;
+      if (group.every((e) => e.normalizedBodyLength < MIN_NORMALIZED_BODY)) continue;
+      if (group.every(isSimpleStructure)) continue;
       reportDuplicateGroup(
         group,
         this.id,
         this.severity,
         (e) => `${e.name} (${e.file}:${e.line})`,
-        (e, others) => `Function "${e.name}" has identical body to: ${others}`,
+        (e, others) => `Function "${e.name}" is near-duplicate of: ${others}`,
         diagnostics
       );
     }
     return diagnostics;
   }
 };
-function getBodyBlock(node) {
-  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;
+function getFunctionBody(node) {
+  if (ts7.isFunctionDeclaration(node) || ts7.isFunctionExpression(node)) return node.body;
+  if (ts7.isArrowFunction(node)) return node.body;
+  if (ts7.isMethodDeclaration(node)) return node.body;
   return void 0;
 }
-function isSingleStatement(node) {
-  if (ts20.isArrowFunction(node) && !ts20.isBlock(node.body)) return true;
-  const body = getBodyBlock(node);
-  return body !== void 0 && body.statements.length <= 1;
+function getTopLevelStatementCount(body) {
+  if (ts7.isBlock(body)) return body.statements.length;
+  return 1;
 }
-function isSetter(node) {
-  const body = getBodyBlock(node);
-  if (!body || body.statements.length !== 1) return false;
-  const stmt = body.statements[0];
-  if (stmt === void 0 || !ts20.isExpressionStatement(stmt)) return false;
-  return ts20.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts20.SyntaxKind.EqualsToken;
+function hasControlFlow(node) {
+  let found = false;
+  function visit(current) {
+    if (found) return;
+    if (ts7.isIfStatement(current) || ts7.isSwitchStatement(current) || ts7.isTryStatement(current) || ts7.isForStatement(current) || ts7.isForInStatement(current) || ts7.isForOfStatement(current) || ts7.isWhileStatement(current) || ts7.isDoStatement(current)) {
+      found = true;
+      return;
+    }
+    ts7.forEachChild(current, visit);
+  }
+  visit(node);
+  return found;
+}
+function isSimpleStructure(entry) {
+  const body = getFunctionBody(entry.node);
+  if (!body) return false;
+  if (hasControlFlow(body)) return false;
+  return getTopLevelStatementCount(body) <= 2;
 }
 
 // src/rules/cross-file/optional-arg-always-used.ts
@@ -792,341 +630,250 @@ var optionalArgAlwaysUsed = {
   }
 };
 
-// src/rules/ts/no-catch-return.ts
-import * as ts21 from "typescript";
-var noCatchReturn = {
-  kind: "ts",
-  id: "no-catch-return",
+// src/rules/cross-file/repeated-literal-property.ts
+import * as ts8 from "typescript";
+var repeatedLiteralProperty = {
+  id: "repeated-literal-property",
   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 (!ts21.isCatchClause(node)) return;
-    const block = node.block;
-    if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
-      ctx.report(node);
+  message: "Repeated literal value in object properties; consider extracting a constant or factory",
+  analyze(project) {
+    const diagnostics = [];
+    for (const [file, { sourceFile }] of project.files) {
+      let visit2 = function(node) {
+        if (ts8.isObjectLiteralExpression(node)) {
+          for (const prop of node.properties) {
+            if (!ts8.isPropertyAssignment(prop)) continue;
+            const result = extractLiteral(prop.initializer, sourceFile);
+            if (result.literalText === null) continue;
+            let list = valueMap.get(result.literalText);
+            if (!list) {
+              list = [];
+              valueMap.set(result.literalText, list);
+            }
+            const line = ts8.getLineAndCharacterOfPosition(sourceFile, prop.getStart(sourceFile)).line + 1;
+            list.push({ line, isAsConst: result.isAsConst });
+          }
+        }
+        ts8.forEachChild(node, visit2);
+      };
+      var visit = visit2;
+      const valueMap = /* @__PURE__ */ new Map();
+      ts8.forEachChild(sourceFile, visit2);
+      for (const [value, occurrences] of valueMap) {
+        const hasAsConst = occurrences.some((o) => o.isAsConst);
+        const threshold = hasAsConst ? 3 : 5;
+        if (occurrences.length < threshold) continue;
+        const sorted = [...occurrences].sort((a, b) => a.line - b.line);
+        for (const occ of sorted) {
+          const otherLines = sorted.filter((o) => o !== occ).map((o) => o.line).join(", ");
+          diagnostics.push({
+            ruleId: this.id,
+            severity: this.severity,
+            message: `${JSON.stringify(value)}${hasAsConst ? " as const" : ""} repeated ${occurrences.length} times as property value (also at lines ${otherLines})`,
+            file,
+            line: occ.line,
+            column: 1
+          });
+        }
+      }
     }
+    return diagnostics;
   }
 };
-function walkBlock(block, predicate) {
-  function visit(node) {
-    if (predicate(node)) return true;
-    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return false;
-    return ts21.forEachChild(node, visit) ?? false;
+function extractLiteral(node, sourceFile) {
+  if (ts8.isStringLiteral(node) || ts8.isNumericLiteral(node) || ts8.isNoSubstitutionTemplateLiteral(node)) {
+    return { literalText: node.text, isAsConst: false };
   }
-  return ts21.forEachChild(block, visit) ?? false;
-}
-function hasReturn(block) {
-  return walkBlock(block, (n) => ts21.isReturnStatement(n));
-}
-function hasThrow(block) {
-  return walkBlock(block, (n) => ts21.isThrowStatement(n));
+  if (node.kind === ts8.SyntaxKind.TrueKeyword) return { literalText: "true", isAsConst: false };
+  if (node.kind === ts8.SyntaxKind.FalseKeyword) return { literalText: "false", isAsConst: false };
+  if (ts8.isAsExpression(node) && node.type.getText(sourceFile).trim() === "const") {
+    const inner = extractLiteral(node.expression, sourceFile);
+    if (inner.literalText !== null) {
+      return { literalText: inner.literalText, isAsConst: true };
+    }
+  }
+  return { literalText: null, isAsConst: false };
 }
-var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
-function hasLogging(block) {
-  return walkBlock(block, (n) => {
-    if (!ts21.isCallExpression(n)) return false;
-    const callee = n.expression;
-    if (!ts21.isPropertyAccessExpression(callee)) return false;
-    if (!ts21.isIdentifier(callee.expression)) return false;
-    return LOG_OBJECTS.has(callee.expression.text);
-  });
+
+// src/rules/cross-file/repeated-return-shape.ts
+import * as ts10 from "typescript";
+
+// src/rules/cross-file/object-shape.ts
+import * as ts9 from "typescript";
+function extractPropertyNames(node) {
+  const names = [];
+  for (const prop of node.properties) {
+    if (ts9.isSpreadAssignment(prop)) return null;
+    if (ts9.isPropertyAssignment(prop)) {
+      if (ts9.isIdentifier(prop.name)) names.push(prop.name.text);
+      else if (ts9.isStringLiteral(prop.name)) names.push(prop.name.text);
+      else return null;
+    } else if (ts9.isShorthandPropertyAssignment(prop)) {
+      names.push(prop.name.text);
+    } else if (ts9.isMethodDeclaration(prop)) {
+      if (ts9.isIdentifier(prop.name)) names.push(prop.name.text);
+      else return null;
+    } else if (ts9.isGetAccessorDeclaration(prop) || ts9.isSetAccessorDeclaration(prop)) {
+      if (ts9.isIdentifier(prop.name)) names.push(prop.name.text);
+      else return null;
+    }
+  }
+  return names;
+}
+function getShapeGroup(map, props) {
+  const sorted = [...props].sort();
+  const key = sorted.join("\0");
+  let list = map.get(key);
+  if (!list) {
+    list = [];
+    map.set(key, list);
+  }
+  return { sorted, list };
 }
 
-// src/rules/ts/no-error-rewrap.ts
-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 (!ts22.isCatchClause(node)) return;
-    if (!node.variableDeclaration) return;
-    const param = node.variableDeclaration.name;
-    if (!ts22.isIdentifier(param)) return;
-    const catchName = param.text;
-    findRewraps(node.block, catchName, ctx);
+// src/rules/cross-file/repeated-return-shape.ts
+var repeatedReturnShape = {
+  id: "repeated-return-shape",
+  severity: "warning",
+  message: "Multiple functions return the same object shape; consider a shared return type",
+  analyze(project) {
+    const diagnostics = [];
+    const THRESHOLD = 3;
+    const shapeMap = /* @__PURE__ */ new Map();
+    for (const [file, { sourceFile }] of project.files) {
+      let visit2 = function(node) {
+        if (isFunctionLike(node)) {
+          const functionName = deriveFunctionName(node, sourceFile);
+          const line = ts10.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+          collectReturnShapes(node, file, line, functionName, sourceFile, shapeMap);
+        }
+        ts10.forEachChild(node, visit2);
+      };
+      var visit = visit2;
+      ts10.forEachChild(sourceFile, visit2);
+    }
+    for (const [, entries] of shapeMap) {
+      const byFunction = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const key = `${entry.file}:${entry.line}`;
+        if (!byFunction.has(key)) {
+          byFunction.set(key, entry);
+        }
+      }
+      const unique = [...byFunction.values()];
+      if (unique.length < THRESHOLD) continue;
+      const sorted = unique.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+      for (const entry of sorted) {
+        const others = sorted.filter((e) => e !== entry).map((e) => `${e.functionName} (${e.file}:${e.line})`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `${unique.length} functions return shape {${entry.props.join(", ")}}; consider a shared return type (${others})`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
+    }
+    return diagnostics;
   }
 };
-function findRewraps(block, catchName, ctx) {
-  function visit(node) {
-    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;
-    }
-    ts22.forEachChild(node, visit);
-  }
-  ts22.forEachChild(block, visit);
+function isFunctionLike(node) {
+  return ts10.isFunctionDeclaration(node) || ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isMethodDeclaration(node);
 }
-function referencesName(args, name) {
-  for (const arg of args) {
-    if (containsIdentifier(arg, name)) return true;
-  }
-  return false;
+function unwrapExpression(node) {
+  if (ts10.isParenthesizedExpression(node)) return unwrapExpression(node.expression);
+  if (ts10.isAsExpression(node)) return unwrapExpression(node.expression);
+  return node;
 }
-function containsIdentifier(node, name) {
-  if (ts22.isIdentifier(node) && node.text === name) return true;
-  return ts22.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+function getBody(node) {
+  if (ts10.isFunctionDeclaration(node) && node.body) return node.body;
+  if (ts10.isFunctionExpression(node) && node.body) return node.body;
+  if (ts10.isArrowFunction(node) && ts10.isBlock(node.body)) return node.body;
+  if (ts10.isMethodDeclaration(node) && node.body) return node.body;
+  return void 0;
 }
-function hasCauseArg(args) {
-  for (const arg of args) {
-    if (ts22.isObjectLiteralExpression(arg)) {
-      for (const prop of arg.properties) {
-        if (ts22.isPropertyAssignment(prop) && ts22.isIdentifier(prop.name) && prop.name.text === "cause") return true;
-        if (ts22.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
+function collectReturnShapes(funcNode, file, funcLine, functionName, sourceFile, shapeMap) {
+  if (ts10.isArrowFunction(funcNode) && !ts10.isBlock(funcNode.body)) {
+    const expr = unwrapExpression(funcNode.body);
+    if (ts10.isObjectLiteralExpression(expr)) {
+      addShape(expr, file, funcLine, functionName, sourceFile, shapeMap);
+    }
+    return;
+  }
+  const body = getBody(funcNode);
+  if (!body) return;
+  function walkForReturns(node) {
+    if (ts10.isReturnStatement(node) && node.expression) {
+      const expr = unwrapExpression(node.expression);
+      if (ts10.isObjectLiteralExpression(expr)) {
+        addShape(expr, file, funcLine, functionName, sourceFile, shapeMap);
       }
     }
+    if (isFunctionLike(node)) return;
+    ts10.forEachChild(node, walkForReturns);
   }
-  return false;
+  ts10.forEachChild(body, walkForReturns);
 }
-
-// src/rules/cross-file/explicit-null-arg.ts
-import * as ts23 from "typescript";
-var explicitNullArg = {
-  id: "explicit-null-arg",
-  severity: "warning",
-  message: "Explicit null/undefined passed to a project function; consider redesigning the interface to not accept nullish values",
-  analyze(project) {
-    const diagnostics = [];
-    const projectFnNames = /* @__PURE__ */ new Set();
-    const projectFnSymbols = /* @__PURE__ */ new Set();
-    for (const fn of project.functions.getAll()) {
-      projectFnNames.add(fn.name);
-      if (fn.symbol) projectFnSymbols.add(fn.symbol);
-    }
-    for (const site of project.callSites) {
-      const isProjectFn = site.symbol ? projectFnSymbols.has(site.symbol) : projectFnNames.has(site.calleeName);
-      if (!isProjectFn) continue;
-      for (let i = 0; i < site.node.arguments.length; i++) {
-        const arg = site.node.arguments[i];
-        if (arg === void 0) continue;
-        if (isNullishLiteral(arg)) {
-          const val = arg.kind === ts23.SyntaxKind.NullKeyword ? "null" : "undefined";
-          diagnostics.push({
-            ruleId: this.id,
-            severity: this.severity,
-            message: `Passing explicit ${val} to "${site.calleeName}" at argument ${i + 1}; consider redesigning the interface to not accept nullish values`,
-            file: site.file,
-            line: site.line,
-            column: 1
-          });
-          break;
-        }
-      }
-    }
-    return diagnostics;
-  }
-};
-
-// src/rules/cross-file/duplicate-function-name.ts
-import { dirname, resolve } from "path";
-var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-var duplicateFunctionName = {
-  id: "duplicate-function-name",
-  severity: "warning",
-  message: "Same function name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.functions.getNameCollisionGroups()) {
-      const hashes = new Set(group.map((e) => e.hash));
-      if (hashes.size === 1) continue;
-      const groupFiles = new Set(group.map((e) => e.file));
-      const first = group[0];
-      if (first === void 0) continue;
-      const funcName = first.name;
-      const hasImportLink = project.imports.some((imp) => {
-        if (!groupFiles.has(imp.file)) return false;
-        if (imp.importedName !== funcName && imp.localName !== funcName) return false;
-        if (!imp.source.startsWith(".")) return false;
-        const candidates = resolveCandidates(imp.file, imp.source);
-        if (candidates.some((c) => groupFiles.has(c))) return true;
-        return candidates.some(
-          (c) => project.imports.some((reExp) => {
-            if (reExp.file !== c) return false;
-            if (reExp.importedName !== funcName && reExp.localName !== funcName) return false;
-            if (!reExp.source.startsWith(".")) return false;
-            const innerCandidates = resolveCandidates(reExp.file, reExp.source);
-            return innerCandidates.some((ic) => groupFiles.has(ic));
-          })
-        );
-      });
-      if (hasImportLink) continue;
-      reportDuplicateGroup(
-        group,
-        this.id,
-        this.severity,
-        (e) => `${e.file}:${e.line}`,
-        (e, others) => `Exported function "${e.name}" also defined in: ${others}`,
-        diagnostics
-      );
-    }
-    return diagnostics;
-  }
-};
-function resolveCandidates(fromFile, specifier) {
-  const base = resolve(dirname(fromFile), specifier);
-  const candidates = [base];
-  for (const ext of EXTENSIONS) {
-    candidates.push(base + ext);
-    candidates.push(resolve(base, `index${ext}`));
-  }
-  return candidates;
+function addShape(objLiteral, file, funcLine, functionName, sourceFile, shapeMap) {
+  const props = extractPropertyNames(objLiteral);
+  if (props === null || props.length === 0) return;
+  const { sorted, list } = getShapeGroup(shapeMap, props);
+  list.push({ file, line: funcLine, functionName, props: sorted });
 }
-
-// src/rules/cross-file/duplicate-type-name.ts
-import * as ts24 from "typescript";
-var duplicateTypeName = {
-  id: "duplicate-type-name",
-  severity: "warning",
-  message: "Same type name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.types.getNameCollisionGroups()) {
-      const hashes = new Set(group.map((e) => e.hash));
-      if (hashes.size === 1) continue;
-      const hasInferredType = group.some(
-        (e) => !ts24.isTypeLiteralNode(e.node) && !ts24.isInterfaceDeclaration(e.node)
-      );
-      if (hasInferredType) continue;
-      reportDuplicateGroup(
-        group,
-        this.id,
-        this.severity,
-        (e) => `${e.file}:${e.line}`,
-        (e, others) => `Exported type "${e.name}" also defined in: ${others}`,
-        diagnostics
-      );
-    }
-    return diagnostics;
+function deriveFunctionName(node, sourceFile) {
+  if (ts10.isFunctionDeclaration(node) && node.name) {
+    return node.name.text;
   }
-};
-
-// src/rules/cross-file/duplicate-constant-declaration.ts
-var duplicateConstantDeclaration = {
-  id: "duplicate-constant-declaration",
-  severity: "warning",
-  message: "Identical constant value declared in multiple files; consolidate to a single definition",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.constants.getDuplicateGroups()) {
-      const files = new Set(group.map((e) => e.file));
-      if (files.size < 2) continue;
-      reportDuplicateGroup(
-        group,
-        this.id,
-        this.severity,
-        (e) => `${e.name} (${e.file}:${e.line})`,
-        (e, others) => `Constant "${e.name}" has identical value \`${e.valueText}\` to: ${others}`,
-        diagnostics
-      );
+  if (ts10.isMethodDeclaration(node) && ts10.isIdentifier(node.name)) {
+    const parent2 = node.parent;
+    if (ts10.isClassDeclaration(parent2) && parent2.name) {
+      return `${parent2.name.text}.${node.name.text}`;
     }
-    return diagnostics;
-  }
-};
-
-// src/rules/ts/no-dynamic-import.ts
-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 (!ts25.isCallExpression(node)) return;
-    if (node.expression.kind !== ts25.SyntaxKind.ImportKeyword) return;
-    ctx.report(node);
+    return node.name.text;
   }
-};
-
-// src/rules/cross-file/near-duplicate-function.ts
-import * as ts26 from "typescript";
-var nearDuplicateFunction = {
-  id: "near-duplicate-function",
-  severity: "warning",
-  message: "Near-duplicate function bodies across files; consider parameterizing",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.functions.getNearDuplicateGroups()) {
-      const MIN_NORMALIZED_BODY = 32;
-      if (group.every((e) => e.normalizedBodyLength < MIN_NORMALIZED_BODY)) continue;
-      if (group.every(isSimpleStructure)) continue;
-      reportDuplicateGroup(
-        group,
-        this.id,
-        this.severity,
-        (e) => `${e.name} (${e.file}:${e.line})`,
-        (e, others) => `Function "${e.name}" is near-duplicate of: ${others}`,
-        diagnostics
-      );
-    }
-    return diagnostics;
+  const parent = node.parent;
+  if (ts10.isVariableDeclaration(parent) && ts10.isIdentifier(parent.name)) {
+    return parent.name.text;
   }
-};
-function getFunctionBody(node) {
-  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 (ts26.isBlock(body)) return body.statements.length;
-  return 1;
-}
-function hasControlFlow(node) {
-  let found = false;
-  function visit(current) {
-    if (found) return;
-    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;
-    }
-    ts26.forEachChild(current, visit);
+  if (ts10.isPropertyAssignment(parent) && ts10.isIdentifier(parent.name)) {
+    return parent.name.text;
   }
-  visit(node);
-  return found;
-}
-function isSimpleStructure(entry) {
-  const body = getFunctionBody(entry.node);
-  if (!body) return false;
-  if (hasControlFlow(body)) return false;
-  return getTopLevelStatementCount(body) <= 2;
+  const line = ts10.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  return `<anonymous>:${line}`;
 }
 
 // src/rules/cross-file/trivial-wrapper.ts
-import * as ts27 from "typescript";
+import * as ts11 from "typescript";
 function getFunctionBody2(node) {
-  if (ts27.isFunctionDeclaration(node) || ts27.isFunctionExpression(node)) {
+  if (ts11.isFunctionDeclaration(node) || ts11.isFunctionExpression(node)) {
     return node.body;
   }
-  if (ts27.isArrowFunction(node)) {
+  if (ts11.isArrowFunction(node)) {
     return node.body;
   }
-  if (ts27.isMethodDeclaration(node)) {
+  if (ts11.isMethodDeclaration(node)) {
     return node.body;
   }
   return void 0;
 }
 function getCalleeName(expr) {
-  if (ts27.isIdentifier(expr)) return expr.text;
-  if (ts27.isPropertyAccessExpression(expr)) return expr.name.text;
+  if (ts11.isIdentifier(expr)) return expr.text;
+  if (ts11.isPropertyAccessExpression(expr)) return expr.name.text;
   return void 0;
 }
 function getTrivialCallTarget(fn) {
   const body = getFunctionBody2(fn.node);
   if (!body) return null;
   let callExpr;
-  if (ts27.isBlock(body)) {
+  if (ts11.isBlock(body)) {
     if (body.statements.length !== 1) return null;
     const stmt = body.statements[0];
-    if (!stmt || !ts27.isReturnStatement(stmt) || !stmt.expression) return null;
-    if (!ts27.isCallExpression(stmt.expression)) return null;
+    if (!stmt || !ts11.isReturnStatement(stmt) || !stmt.expression) return null;
+    if (!ts11.isCallExpression(stmt.expression)) return null;
     callExpr = stmt.expression;
   } else {
-    if (!ts27.isCallExpression(body)) return null;
+    if (!ts11.isCallExpression(body)) return null;
     callExpr = body;
   }
   const calleeName = getCalleeName(callExpr.expression);
@@ -1134,7 +881,7 @@ function getTrivialCallTarget(fn) {
   const paramNames = fn.params.map((p) => p.name);
   const args = callExpr.arguments;
   for (const arg of args) {
-    if (!ts27.isIdentifier(arg)) return null;
+    if (!ts11.isIdentifier(arg)) return null;
     if (!paramNames.includes(arg.text)) return null;
   }
   return { calleeName };
@@ -1241,239 +988,886 @@ function isClassImported(className, declFile, importedNames) {
   return [...importers].some((f) => f !== declFile);
 }
 
-// src/rules/cross-file/duplicate-file.ts
-var duplicateFile = {
-  id: "duplicate-file",
+// src/rules/ts/no-any-cast.ts
+import * as ts12 from "typescript";
+var noAnyCast = {
+  kind: "ts",
+  id: "no-any-cast",
+  severity: "error",
+  message: "Casting to `any` erases type safety; use a specific type or generic instead",
+  visit(node, ctx) {
+    if (!ts12.isAsExpression(node)) return;
+    if (node.type.kind !== ts12.SyntaxKind.AnyKeyword) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-catch-return.ts
+import * as ts13 from "typescript";
+var noCatchReturn = {
+  kind: "ts",
+  id: "no-catch-return",
   severity: "warning",
-  message: "File has identical content to another file; one is likely dead code",
-  analyze(project) {
-    const diagnostics = [];
-    for (const files of project.fileHashes.values()) {
-      if (files.length < 2) continue;
-      const sorted = [...files].sort();
-      for (const file of sorted.slice(1)) {
-        const others = sorted.filter((f) => f !== file).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `File is identical to: ${others}`,
-          file,
-          line: 1,
-          column: 1
-        });
-      }
+  message: "Catch block silently returns a fallback value with no logging; rethrow, log the error, or let it propagate",
+  visit(node, ctx) {
+    if (!ts13.isCatchClause(node)) return;
+    const block = node.block;
+    if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
+      ctx.report(node);
     }
-    return diagnostics;
   }
 };
+function walkBlock(block, predicate) {
+  function visit(node) {
+    if (predicate(node)) return true;
+    if (ts13.isFunctionDeclaration(node) || ts13.isFunctionExpression(node) || ts13.isArrowFunction(node)) return false;
+    return ts13.forEachChild(node, visit) ?? false;
+  }
+  return ts13.forEachChild(block, visit) ?? false;
+}
+function hasReturn(block) {
+  return walkBlock(block, (n) => ts13.isReturnStatement(n));
+}
+function hasThrow(block) {
+  return walkBlock(block, (n) => ts13.isThrowStatement(n));
+}
+var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
+function hasLogging(block) {
+  return walkBlock(block, (n) => {
+    if (!ts13.isCallExpression(n)) return false;
+    const callee = n.expression;
+    if (!ts13.isPropertyAccessExpression(callee)) return false;
+    if (!ts13.isIdentifier(callee.expression)) return false;
+    return LOG_OBJECTS.has(callee.expression.text);
+  });
+}
 
-// src/rules/cross-file/duplicate-statement-sequence.ts
-var duplicateStatementSequence = {
-  id: "duplicate-statement-sequence",
+// src/rules/ts/no-double-negation-coercion.ts
+import * as ts14 from "typescript";
+var noDoubleNegationCoercion = {
+  kind: "ts",
+  id: "no-double-negation-coercion",
   severity: "info",
-  message: "Repeated statement sequence; consider extracting to a shared helper",
-  analyze(project) {
-    const diagnostics = [];
-    const MIN_NORMALIZED_BODY = 128;
-    for (const group of project.statementSequences.getNormalizedDuplicateGroups()) {
-      if (group.every((e) => e.normalizedBodyLength < MIN_NORMALIZED_BODY)) continue;
-      const byLocation = /* @__PURE__ */ new Map();
-      for (const entry of group) {
-        const key = `${entry.file}:${entry.line}`;
-        const existing = byLocation.get(key);
-        if (existing === void 0 || entry.statementCount > existing.statementCount) {
-          byLocation.set(key, entry);
-        }
+  message: "!! coercion hides intent; use an explicit check (!== null, !== undefined, .length > 0) so the condition documents what it tests",
+  visit(node, ctx) {
+    if (!ts14.isPrefixUnaryExpression(node)) return;
+    if (node.operator !== ts14.SyntaxKind.ExclamationToken) return;
+    const inner = node.operand;
+    if (!ts14.isPrefixUnaryExpression(inner)) return;
+    if (inner.operator !== ts14.SyntaxKind.ExclamationToken) return;
+    const operand = inner.operand;
+    const innerType = ctx.checker.getTypeAtLocation(operand);
+    if (includesBooleanType(innerType) && !(innerType.flags & ts14.TypeFlags.Union)) {
+      ctx.report(node, "!! on an already-boolean type is a no-op; remove the double negation");
+      return;
+    }
+    if (isBitwiseExpression(operand)) return;
+    ctx.report(node);
+  }
+};
+var BITWISE_OPS = /* @__PURE__ */ new Set([
+  ts14.SyntaxKind.AmpersandToken,
+  ts14.SyntaxKind.BarToken,
+  ts14.SyntaxKind.CaretToken,
+  ts14.SyntaxKind.LessThanLessThanToken,
+  ts14.SyntaxKind.GreaterThanGreaterThanToken,
+  ts14.SyntaxKind.GreaterThanGreaterThanGreaterThanToken
+]);
+function isBitwiseExpression(node) {
+  if (ts14.isBinaryExpression(node) && BITWISE_OPS.has(node.operatorToken.kind)) return true;
+  if (ts14.isParenthesizedExpression(node)) return isBitwiseExpression(node.expression);
+  return false;
+}
+
+// src/rules/ts/no-dynamic-import.ts
+import * as ts15 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 (!ts15.isCallExpression(node)) return;
+    if (node.expression.kind !== ts15.SyntaxKind.ImportKeyword) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-empty-catch.ts
+import * as ts16 from "typescript";
+var noEmptyCatch = {
+  kind: "ts",
+  id: "no-empty-catch",
+  severity: "error",
+  message: "Empty catch blocks hide failures; handle, annotate, or rethrow explicitly",
+  visit(node, ctx) {
+    if (!ts16.isCatchClause(node)) return;
+    const block = node.block;
+    if (block.statements.length > 0) return;
+    const blockStart = block.getStart(ctx.sourceFile);
+    const blockEnd = block.getEnd();
+    const inner = ctx.source.slice(blockStart + 1, blockEnd - 1);
+    if (inner.includes("//") || inner.includes("/*")) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-error-rewrap.ts
+import * as ts17 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 (!ts17.isCatchClause(node)) return;
+    if (!node.variableDeclaration) return;
+    const param = node.variableDeclaration.name;
+    if (!ts17.isIdentifier(param)) return;
+    const catchName = param.text;
+    findRewraps(node.block, catchName, ctx);
+  }
+};
+function findRewraps(block, catchName, ctx) {
+  function visit(node) {
+    if (ts17.isFunctionDeclaration(node) || ts17.isFunctionExpression(node) || ts17.isArrowFunction(node)) return;
+    if (ts17.isThrowStatement(node) && node.expression && ts17.isNewExpression(node.expression)) {
+      const args = node.expression.arguments;
+      if (args && args.length > 0 && referencesName(args, catchName) && !hasCauseArg(args)) {
+        ctx.report(node);
       }
-      const deduped = [...byLocation.values()];
-      if (deduped.length < 2) continue;
-      const sorted = deduped.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.file}:${e.line}`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Statement sequence (${entry.statementCount} statements) duplicated at: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
+      return;
+    }
+    ts17.forEachChild(node, visit);
+  }
+  ts17.forEachChild(block, visit);
+}
+function referencesName(args, name) {
+  for (const arg of args) {
+    if (containsIdentifier(arg, name)) return true;
+  }
+  return false;
+}
+function containsIdentifier(node, name) {
+  if (ts17.isIdentifier(node) && node.text === name) return true;
+  return ts17.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+}
+function hasCauseArg(args) {
+  for (const arg of args) {
+    if (ts17.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (ts17.isPropertyAssignment(prop) && ts17.isIdentifier(prop.name) && prop.name.text === "cause") return true;
+        if (ts17.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
       }
     }
-    return diagnostics;
+  }
+  return false;
+}
+
+// src/rules/ts/no-explicit-any-annotation.ts
+import * as ts18 from "typescript";
+var noExplicitAnyAnnotation = {
+  kind: "ts",
+  id: "no-explicit-any-annotation",
+  severity: "error",
+  message: "Explicit `any` annotation erases type safety; use a specific type, `unknown`, or a generic",
+  visit(node, ctx) {
+    if (node.kind !== ts18.SyntaxKind.AnyKeyword) return;
+    if (node.parent && ts18.isAsExpression(node.parent)) return;
+    ctx.report(node);
   }
 };
 
-// src/rules/cross-file/dead-overload.ts
-import * as ts28 from "typescript";
-var deadOverload = {
-  id: "dead-overload",
+// src/rules/ts/no-inline-param-type.ts
+var noInlineParamType = {
+  kind: "ts",
+  id: "no-inline-param-type",
   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
-          });
-        }
-      }
+  message: "Inline object type on parameter; extract to a named type",
+  visit(node, ctx) {
+    if (isInlineParamType(node)) ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-inline-type-assertion.ts
+import * as ts19 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 (ts19.isAsExpression(node) && ts19.isTypeLiteralNode(node.type)) {
+      ctx.report(node);
+      return;
+    }
+    if (ts19.isTypeAssertionExpression(node) && ts19.isTypeLiteralNode(node.type)) {
+      ctx.report(node);
     }
-    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;
+
+// src/rules/ts/no-logical-or-fallback.ts
+import * as ts20 from "typescript";
+var noLogicalOrFallback = {
+  kind: "ts",
+  id: "no-logical-or-fallback",
+  severity: "warning",
+  message: '|| fallback on a data-structure lookup swallows valid falsy values (0, ""); use ?? to only catch null/undefined',
+  visit(node, ctx) {
+    if (!ts20.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts20.SyntaxKind.BarBarToken) return;
+    const right = node.right;
+    if (!isLiteral(right)) return;
+    const left = node.left;
+    const lhsType = ctx.checker.getTypeAtLocation(left);
+    if (isNumericCoercionCall(left)) return;
+    if (isStringNotNullable(lhsType, ctx.checker)) return;
+    if (includesNumberType(lhsType) && !isZeroLiteral(right)) {
+      ctx.report(node, "|| on a numeric type swallows 0; use ?? to only catch null/undefined");
+      return;
+    }
+    if (isDataStructureLookup(left)) {
+      ctx.report(node);
+    }
   }
-  return `${base}; removing it may let you collapse to the remaining constrained signature and drop implementation casts`;
+};
+function isStringNotNullable(type, checker) {
+  if (isNullableType(checker, type)) return false;
+  if (type.isUnion()) {
+    return type.types.every((t) => (t.flags & ts20.TypeFlags.StringLike) !== 0);
+  }
+  return (type.flags & ts20.TypeFlags.StringLike) !== 0;
 }
-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 isLiteral(node) {
+  if (ts20.isStringLiteral(node) || ts20.isNumericLiteral(node) || ts20.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts20.isTemplateExpression(node)) return true;
+  if (ts20.isArrayLiteralExpression(node) || ts20.isObjectLiteralExpression(node)) return true;
+  if (ts20.isIdentifier(node) && node.text === "undefined") return true;
+  if (node.kind === ts20.SyntaxKind.NullKeyword) return true;
+  if (node.kind === ts20.SyntaxKind.TrueKeyword || node.kind === ts20.SyntaxKind.FalseKeyword) return true;
+  return false;
 }
-function hasIntersectionCast(body, sourceFile, paramName, constraintText) {
-  let found = false;
+function isNumericCoercionCall(node) {
+  if (!ts20.isCallExpression(node)) return false;
+  if (!ts20.isIdentifier(node.expression)) return false;
+  const name = node.expression.text;
+  return name === "Number" || name === "parseInt" || name === "parseFloat";
+}
+function isZeroLiteral(node) {
+  return ts20.isNumericLiteral(node) && node.text === "0";
+}
+function isDataStructureLookup(left) {
+  if (ts20.isCallExpression(left)) {
+    const callee = left.expression;
+    if (ts20.isPropertyAccessExpression(callee)) {
+      const methodName = callee.name.text;
+      if (methodName === "find" || methodName === "getStore" || methodName === "get") return true;
+    }
+  }
+  if (ts20.isElementAccessExpression(left)) return true;
+  if (hasOptionalChaining(left)) return true;
+  return false;
+}
+function hasOptionalChaining(node) {
+  if (ts20.isPropertyAccessExpression(node) && node.questionDotToken) return true;
+  if (ts20.isElementAccessExpression(node) && node.questionDotToken) return true;
+  if (ts20.isCallExpression(node) && node.questionDotToken) return true;
+  if (ts20.isPropertyAccessExpression(node)) return hasOptionalChaining(node.expression);
+  if (ts20.isCallExpression(node)) return hasOptionalChaining(node.expression);
+  if (ts20.isElementAccessExpression(node)) return hasOptionalChaining(node.expression);
+  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";
+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;
+    const inner = node.expression;
+    if (!ctx.isNullable(inner)) return;
+    if (ctx.isExternal(inner)) return;
+    if (isSplitElementAccess(inner)) return;
+    if (isFilterElementAccess(inner)) return;
+    if (isLengthGuardedAccess(inner)) return;
+    ctx.report(node);
+  }
+};
+function isSplitElementAccess(node) {
+  if (!ts22.isElementAccessExpression(node)) return false;
+  const obj = node.expression;
+  if (!ts22.isCallExpression(obj)) return false;
+  const callee = obj.expression;
+  if (!ts22.isPropertyAccessExpression(callee)) return false;
+  return callee.name.text === "split";
+}
+function isFilterElementAccess(node) {
+  if (ts22.isElementAccessExpression(node)) {
+    const obj = node.expression;
+    if (ts22.isCallExpression(obj)) {
+      const callee = obj.expression;
+      if (ts22.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+    }
+    if (ts22.isIdentifier(obj)) {
+      const init = findVariableInit(obj);
+      if (init && ts22.isCallExpression(init)) {
+        const callee = init.expression;
+        if (ts22.isPropertyAccessExpression(callee) && callee.name.text === "filter") return true;
+      }
+    }
+  }
+  return false;
+}
+function isLengthGuardedAccess(node) {
+  if (!ts22.isElementAccessExpression(node)) return false;
+  const arr = node.expression;
+  const arrName = getIdentifierName(arr);
+  if (!arrName) return false;
+  if (isInsideForLoopBoundedBy(node, arrName)) return true;
+  return hasPrecedingLengthGuard(node, arrName);
+}
+function isInsideForLoopBoundedBy(node, arrName) {
+  let current = node;
+  while (current.parent) {
+    current = current.parent;
+    if (ts22.isForStatement(current) && current.condition) {
+      if (isLengthBoundCondition(current.condition, arrName)) return true;
+    }
+  }
+  return false;
+}
+function isLengthBoundCondition(cond, arrName) {
+  if (!ts22.isBinaryExpression(cond)) return false;
+  const op = cond.operatorToken.kind;
+  if (op === ts22.SyntaxKind.LessThanToken || op === ts22.SyntaxKind.LessThanEqualsToken) {
+    return isLengthAccess(cond.right, arrName);
+  }
+  if (op === ts22.SyntaxKind.GreaterThanToken || op === ts22.SyntaxKind.GreaterThanEqualsToken) {
+    return isLengthAccess(cond.left, arrName);
+  }
+  return false;
+}
+function isLengthAccess(node, arrName) {
+  if (!ts22.isPropertyAccessExpression(node)) return false;
+  if (node.name.text !== "length") return false;
+  return getIdentifierName(node.expression) === arrName;
+}
+function hasPrecedingLengthGuard(node, arrName) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (ts22.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 (ts22.isIfStatement(parent) && parent.thenStatement === current) {
+      if (isPositiveLengthCheck(parent.expression, arrName)) return true;
+    }
+    if (ts22.isBlock(current) && ts22.isIfStatement(parent) && parent.thenStatement === current) {
+      if (isPositiveLengthCheck(parent.expression, arrName)) return true;
+    }
+    current = parent;
+  }
+  return false;
+}
+function isLengthGuardWithEarlyExit(stmt, arrName) {
+  if (!isEarlyExit(stmt.thenStatement)) return false;
+  return isZeroLengthCheck(stmt.expression, arrName);
+}
+function isZeroLengthCheck(expr, arrName) {
+  if (!ts22.isBinaryExpression(expr)) return false;
+  const op = expr.operatorToken.kind;
+  if (op === ts22.SyntaxKind.EqualsEqualsEqualsToken || op === ts22.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 (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
+  }
+  if (op === ts22.SyntaxKind.ExclamationEqualsEqualsToken || op === ts22.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;
+  const op = expr.operatorToken.kind;
+  if (op === ts22.SyntaxKind.GreaterThanToken) {
+    if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
+  }
+  if (op === ts22.SyntaxKind.GreaterThanEqualsToken) {
+    if (isLengthAccess(expr.left, arrName) && isNumericLiteralGte(expr.right, 1)) return true;
+  }
+  if (op === ts22.SyntaxKind.ExclamationEqualsEqualsToken || op === ts22.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) {
+    const inner = stmt.statements[0];
+    if (inner === void 0) return false;
+    return ts22.isReturnStatement(inner) || ts22.isThrowStatement(inner);
+  }
+  return false;
+}
+function isNumericLiteralValue(node, value) {
+  return ts22.isNumericLiteral(node) && node.text === String(value);
+}
+function isNumericLiteralGte(node, min) {
+  return ts22.isNumericLiteral(node) && Number(node.text) >= min;
+}
+function getIdentifierName(node) {
+  if (ts22.isIdentifier(node)) return node.text;
+  return null;
+}
+function findVariableInit(id) {
+  const sourceFile = id.getSourceFile();
+  let result;
   function visit(node) {
-    if (found) return;
-    if (ts28.isAsExpression(node) || ts28.isTypeAssertionExpression(node)) {
-      if (isConstraintIntersection(node.type, sourceFile, paramName, constraintText)) {
-        found = true;
+    if (ts22.isVariableDeclaration(node) && ts22.isIdentifier(node.name) && node.name.text === id.text && node.initializer) {
+      result = node.initializer;
+    }
+    if (!result) ts22.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+
+// src/rules/ts/no-null-ternary-normalization.ts
+import * as ts23 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;
+    const test = node.condition;
+    if (!ts23.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;
+    const hasNullishComparand = isNullish(test.left) || isNullish(test.right);
+    if (!hasNullishComparand) return;
+    if (isNullish(node.whenTrue) || isNullish(node.whenFalse)) {
+      const tested = isNullish(test.left) ? test.right : test.left;
+      if (!ctx.isNullable(tested)) {
+        ctx.report(node, "Ternary null-normalization on a non-nullable type is dead code; remove the ternary");
         return;
       }
+      ctx.report(node);
+    }
+  }
+};
+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;
+  return false;
+}
+
+// src/rules/ts/no-nullish-coalescing.ts
+import * as ts24 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 (isPossiblyMissingArrayBindingValue(node.left, ctx)) return;
+    if (ctx.isNullable(node.left)) return;
+    ctx.report(node);
+  }
+};
+function isPossiblyMissingArrayBindingValue(node, ctx) {
+  if (!ts24.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 (declaration.initializer || declaration.dotDotDotToken) continue;
+    if (!ts24.isArrayBindingPattern(declaration.parent)) continue;
+    const pattern = declaration.parent;
+    const index = pattern.elements.indexOf(declaration);
+    if (index < 0) continue;
+    if (!isTupleSlotDefinitelyPresent(ctx.checker.getTypeAtLocation(pattern), index, ctx.checker)) {
+      return true;
     }
-    ts28.forEachChild(node, visit);
   }
-  visit(body);
-  return found;
+  return false;
 }
-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;
+function isTupleSlotDefinitelyPresent(type, index, checker) {
+  if (type.isUnion()) {
+    return type.types.every((member) => isTupleSlotDefinitelyPresent(member, index, checker));
   }
-  return hasParam && hasConstraint;
+  const apparent = checker.getApparentType(type);
+  if (!isTupleTypeReference(apparent, checker)) return false;
+  return index < apparent.target.minLength;
 }
-function unwrapParenthesizedType(typeNode) {
-  let current = typeNode;
-  while (ts28.isParenthesizedTypeNode(current)) {
-    current = current.type;
-  }
-  return current;
+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";
 }
-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);
+
+// src/rules/ts/no-optional-call.ts
+import * as ts25 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 (!node.questionDotToken) return;
+    if (ctx.isNullable(node.expression)) return;
+    ctx.report(node);
   }
-  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++;
+};
+
+// src/rules/ts/no-optional-element-access.ts
+import * as ts26 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 (!node.questionDotToken) return;
+    if (ctx.isNullable(node.expression)) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-optional-property-access.ts
+import * as ts27 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 (!node.questionDotToken) return;
+    if (ctx.isNullable(node.expression)) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-redundant-existence-guard.ts
+import * as ts28 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;
+    const left = node.left;
+    const right = node.right;
+    if (ts28.isIdentifier(left) && accessesIdentifier(right, left.text)) {
+      if (ctx.isNullable(left)) return;
+      ctx.report(node);
+      return;
     }
-    const family = toOverloadFamily(run, name, file, sourceFile);
-    if (family !== null) {
-      families.push(family);
+    if (ts28.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)) {
+          ctx.report(node);
+        }
+      }
     }
-    index = nextIndex - 1;
   }
+};
+function accessesIdentifier(expr, name) {
+  const root = getExpressionRoot(expr);
+  return ts28.isIdentifier(root) && root.text === name;
 }
-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 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);
+  return node;
 }
-function asOverloadDeclaration(node) {
-  if (node === void 0) return null;
-  if (ts28.isFunctionDeclaration(node)) return node;
-  if (ts28.isMethodDeclaration(node)) return node;
+function isNullCheck(expr) {
+  const op = expr.operatorToken.kind;
+  if (op !== ts28.SyntaxKind.ExclamationEqualsToken && op !== ts28.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;
   return null;
 }
-function getDeclarationName(node) {
-  if (ts28.isFunctionDeclaration(node)) {
-    return node.name?.text ?? null;
+
+// src/rules/ts/no-ts-ignore.ts
+import * as ts29 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());
+    if (!ranges) return;
+    for (const range of ranges) {
+      const text = ctx.source.slice(range.pos, range.end);
+      if (text.includes("@ts-ignore") || text.includes("@ts-expect-error")) {
+        ctx.reportAtOffset(range.pos);
+      }
+    }
   }
-  if (ts28.isIdentifier(node.name) || ts28.isStringLiteral(node.name) || ts28.isNumericLiteral(node.name)) {
-    return node.name.text;
+};
+
+// src/rules/ts/no-type-assertion.ts
+import * as ts30 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;
+    ctx.report(node);
   }
-  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/ts/prefer-default-param-value.ts
+import * as ts31 from "typescript";
+var preferDefaultParamValue = {
+  kind: "ts",
+  id: "prefer-default-param-value",
+  severity: "info",
+  message: "Use a default parameter value instead of reassigning from nullish coalescing inside the body",
+  visit(node, ctx) {
+    const result = getFirstFunctionStatement(node);
+    if (result === null) return;
+    const { firstStmt, fn } = result;
+    if (!ts31.isExpressionStatement(firstStmt)) return;
+    const expr = firstStmt.expression;
+    if (!ts31.isBinaryExpression(expr) || expr.operatorToken.kind !== ts31.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 (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);
+    if (isParam) ctx.report(firstStmt);
+  }
+};
+
+// src/rules/ts/prefer-required-param-with-guard.ts
+import * as ts32 from "typescript";
+var preferRequiredParamWithGuard = {
+  kind: "ts",
+  id: "prefer-required-param-with-guard",
+  severity: "info",
+  message: "Optional param with immediate guard (if (!param) return/throw); make it required instead",
+  visit(node, ctx) {
+    const result = getFirstFunctionStatement(node);
+    if (result === null) return;
+    const { firstStmt, fn } = result;
+    if (!ts32.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 (ts32.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") {
+          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]));
+    if (!isGuard) return;
+    const isOptional = fn.parameters.some(
+      (p) => ts32.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
+    );
+    if (isOptional) ctx.report(firstStmt);
+  }
+};
 
 // src/rules/index.ts
 var allRules = [
@@ -1495,6 +1889,8 @@ var allRules = [
   noRedundantExistenceGuard,
   preferDefaultParamValue,
   preferRequiredParamWithGuard,
+  noInlineParamType,
+  noModuleStateWrite,
   duplicateTypeDeclaration,
   duplicateFunctionDeclaration,
   optionalArgAlwaysUsed,
@@ -1510,7 +1906,10 @@ var allRules = [
   unusedExport,
   duplicateFile,
   duplicateStatementSequence,
-  deadOverload
+  deadOverload,
+  repeatedLiteralProperty,
+  // repeatedObjectShape — disabled: too noisy on single-property shapes, needs rethinking
+  repeatedReturnShape
 ];
 var ruleMetadata = {
   "no-any-cast": { category: "type-evasion", tags: ["safety"] },
@@ -1533,6 +1932,8 @@ var ruleMetadata = {
   "duplicate-inline-type-in-params": { category: "cross-file", tags: ["duplicate", "api"] },
   "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"] },
@@ -1546,7 +1947,10 @@ var ruleMetadata = {
   "unused-export": { category: "cross-file", tags: ["api"] },
   "duplicate-file": { category: "cross-file", tags: ["duplicate"] },
   "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] },
-  "dead-overload": { category: "cross-file", tags: ["api", "type-evasion"] }
+  "dead-overload": { category: "cross-file", tags: ["api", "type-evasion"] },
+  "repeated-literal-property": { category: "interface-design", tags: ["duplicate", "readability"] },
+  "repeated-object-shape": { category: "interface-design", tags: ["duplicate", "readability"] },
+  "repeated-return-shape": { category: "interface-design", tags: ["duplicate", "readability"] }
 };
 function getRuleMetadata(ruleId) {
   const metadata = ruleMetadata[ruleId];
@@ -1606,32 +2010,32 @@ function isFailOn(value) {
 }
 
 // src/collect/index.ts
-import * as ts31 from "typescript";
+import * as ts35 from "typescript";
 import { createHash as createHash2 } from "crypto";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import * as ts29 from "typescript";
+import * as ts33 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 (ts29.isTypeLiteralNode(node)) {
+  if (ts33.isTypeLiteralNode(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts29.isInterfaceDeclaration(node)) {
+  if (ts33.isInterfaceDeclaration(node)) {
     const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
     return `{${normalized}}`;
   }
-  if (ts29.isPropertySignature(node)) {
+  if (ts33.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 (ts29.isTypeAliasDeclaration(node)) {
+  if (ts33.isTypeAliasDeclaration(node)) {
     return normalizeTypeNode(node.type, sourceFile);
   }
   return node.getText(sourceFile).replace(/\s+/g, " ").trim();
@@ -1797,7 +2201,7 @@ var InlineParamTypeRegistry = class extends BaseRegistry {
 };
 
 // src/typecheck/walk.ts
-import * as ts30 from "typescript";
+import * as ts34 from "typescript";
 function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
   return {
     filename,
@@ -1805,7 +2209,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
     sourceFile,
     checker,
     report(node, message) {
-      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      const { line, character } = ts34.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1816,7 +2220,7 @@ function buildContext(rule, sourceFile, checker, source, filename, diagnostics)
       });
     },
     reportAtOffset(offset, message) {
-      const { line, character } = ts30.getLineAndCharacterOfPosition(sourceFile, offset);
+      const { line, character } = ts34.getLineAndCharacterOfPosition(sourceFile, offset);
       diagnostics.push({
         ruleId: rule.id,
         severity: rule.severity,
@@ -1867,7 +2271,7 @@ function collectProject(program, tsRules, allowedFiles) {
           rule.visit(node, ctx);
         }
       }
-      ts31.forEachChild(node, visit2);
+      ts35.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
@@ -1881,7 +2285,7 @@ function collectProject(program, tsRules, allowedFiles) {
       rule,
       ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
     }));
-    ts31.forEachChild(sourceFile, visit2);
+    ts35.forEachChild(sourceFile, visit2);
   }
   const fileHashes = /* @__PURE__ */ new Map();
   for (const [file, { source }] of fileMap) {
@@ -1897,52 +2301,52 @@ function collectProject(program, tsRules, allowedFiles) {
   return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
 }
 function hasNonPublicModifier(node) {
-  if (!ts31.canHaveModifiers(node)) return false;
-  const mods = ts31.getModifiers(node);
+  if (!ts35.canHaveModifiers(node)) return false;
+  const mods = ts35.getModifiers(node);
   if (mods === void 0) return false;
   return mods.some(
-    (m) => m.kind === ts31.SyntaxKind.PrivateKeyword || m.kind === ts31.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === ts35.SyntaxKind.PrivateKeyword || m.kind === ts35.SyntaxKind.ProtectedKeyword
   );
 }
 function isExported(node) {
-  if (!ts31.canHaveModifiers(node)) return false;
-  const mods = ts31.getModifiers(node);
+  if (!ts35.canHaveModifiers(node)) return false;
+  const mods = ts35.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts31.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts35.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts31.isTypeAliasDeclaration(node)) {
-    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts35.isTypeAliasDeclaration(node)) {
+    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
   }
-  if (ts31.isInterfaceDeclaration(node)) {
-    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts35.isInterfaceDeclaration(node)) {
+    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
 function isConstantValue(node) {
-  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);
+  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);
   return false;
 }
 function collectConstants(node, file, sourceFile, registry) {
-  if (!ts31.isVariableStatement(node)) return;
-  if (!(node.declarationList.flags & ts31.NodeFlags.Const)) return;
+  if (!ts35.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts35.NodeFlags.Const)) return;
   const exported = isExported(node);
   for (const decl of node.declarationList.declarations) {
-    if (!decl.initializer || !ts31.isIdentifier(decl.name)) continue;
+    if (!decl.initializer || !ts35.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 = ts31.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+    const line = ts35.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 = ts31.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const line = ts35.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
   const params = extractParams(parameters, sourceFile);
   const paramNames = params.map((p) => p.name);
   const hash = hashFunctionBody(body, sourceFile);
@@ -1964,17 +2368,17 @@ function buildFunctionEntry(body, parameters, sourceFile, file, lineNode, name,
   };
 }
 function collectFunctions(node, file, sourceFile, checker, registry) {
-  if (ts31.isFunctionDeclaration(node) && node.name && node.body) {
+  if (ts35.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 (ts31.isVariableStatement(node)) {
+  if (ts35.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts31.isArrowFunction(decl.initializer) && ts31.isIdentifier(decl.name)) {
+      if (decl.initializer && ts35.isArrowFunction(decl.initializer) && ts35.isIdentifier(decl.name)) {
         const arrow = decl.initializer;
         registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
           exported,
@@ -1982,7 +2386,7 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
           node: arrow
         }));
       }
-      if (decl.initializer && ts31.isFunctionExpression(decl.initializer) && ts31.isIdentifier(decl.name)) {
+      if (decl.initializer && ts35.isFunctionExpression(decl.initializer) && ts35.isIdentifier(decl.name)) {
         const fn = decl.initializer;
         if (fn.body) {
           registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
@@ -1994,22 +2398,22 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts31.isPropertyAssignment(node) && (ts31.isIdentifier(node.name) || ts31.isStringLiteral(node.name))) {
+  if (ts35.isPropertyAssignment(node) && (ts35.isIdentifier(node.name) || ts35.isStringLiteral(node.name))) {
     const init = node.initializer;
     const propName = node.name.text;
-    if (ts31.isArrowFunction(init)) {
+    if (ts35.isArrowFunction(init)) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
-    if (ts31.isFunctionExpression(init) && init.body) {
+    if (ts35.isFunctionExpression(init) && init.body) {
       registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
     }
   }
-  if (ts31.isArrowFunction(node) || ts31.isFunctionExpression(node)) {
+  if (ts35.isArrowFunction(node) || ts35.isFunctionExpression(node)) {
     const parent = node.parent;
-    if (ts31.isVariableDeclaration(parent) && ts31.isIdentifier(parent.name)) {
-    } else if (ts31.isPropertyAssignment(parent)) {
+    if (ts35.isVariableDeclaration(parent) && ts35.isIdentifier(parent.name)) {
+    } else if (ts35.isPropertyAssignment(parent)) {
     } else {
-      const body = ts31.isArrowFunction(node) ? node.body : node.body;
+      const body = ts35.isArrowFunction(node) ? node.body : node.body;
       if (body) {
         const MIN_ANON_BODY = 64;
         if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
@@ -2019,14 +2423,14 @@ function collectFunctions(node, file, sourceFile, checker, registry) {
       }
     }
   }
-  if (ts31.isMethodDeclaration(node) && node.body && ts31.isIdentifier(node.name)) {
+  if (ts35.isMethodDeclaration(node) && node.body && ts35.isIdentifier(node.name)) {
     const parent = node.parent;
-    if (ts31.isClassDeclaration(parent)) {
+    if (ts35.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 === ts31.SyntaxKind.ImplementsKeyword
+        (c) => c.token === ts35.SyntaxKind.ImplementsKeyword
       ) ?? false;
       registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
         exported: isExported(parent),
@@ -2049,16 +2453,16 @@ function extractParams(parameters, sourceFile) {
 }
 function deriveAnonymousName(node, sourceFile) {
   const parent = node.parent;
-  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
-  if (ts31.isCallExpression(parent)) {
+  const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts35.isCallExpression(parent)) {
     const grandparent = parent.parent;
-    if (ts31.isPropertyAssignment(grandparent) && ts31.isIdentifier(grandparent.name)) {
+    if (ts35.isPropertyAssignment(grandparent) && ts35.isIdentifier(grandparent.name)) {
       return grandparent.name.text;
     }
     let calleeName = null;
-    if (ts31.isIdentifier(parent.expression)) {
+    if (ts35.isIdentifier(parent.expression)) {
       calleeName = parent.expression.text;
-    } else if (ts31.isPropertyAccessExpression(parent.expression)) {
+    } else if (ts35.isPropertyAccessExpression(parent.expression)) {
       calleeName = parent.expression.name.text;
     }
     if (calleeName) {
@@ -2069,7 +2473,7 @@ function deriveAnonymousName(node, sourceFile) {
   return `<anonymous>:${line}`;
 }
 function collectImports(node, file, imports) {
-  if (ts31.isImportDeclaration(node) && ts31.isStringLiteral(node.moduleSpecifier)) {
+  if (ts35.isImportDeclaration(node) && ts35.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -2081,7 +2485,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts31.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts35.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -2092,9 +2496,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts31.isExportDeclaration(node) && node.moduleSpecifier && ts31.isStringLiteral(node.moduleSpecifier)) {
+  if (ts35.isExportDeclaration(node) && node.moduleSpecifier && ts35.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts31.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts35.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -2107,7 +2511,7 @@ function collectImports(node, file, imports) {
   }
 }
 function collectStatementSequences(node, file, sourceFile, registry) {
-  if (!ts31.isBlock(node)) return;
+  if (!ts35.isBlock(node)) return;
   const stmts = node.statements;
   const n = stmts.length;
   if (n < 3) return;
@@ -2124,35 +2528,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 = ts31.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
-      const endLine = ts31.getLineAndCharacterOfPosition(sourceFile, lastStmt.getEnd()).line + 1;
+      const line = ts35.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts35.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 (!ts31.isTypeLiteralNode(node)) return;
-  const parent = node.parent;
-  if (!parent || !ts31.isParameter(parent)) return;
-  if (parent.type !== node) return;
-  const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (!isInlineParamType(node)) return;
+  const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
   registry.add(file, line, node, sourceFile);
 }
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts31.isCallExpression(node)) return;
+  if (!ts35.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts31.isIdentifier(node.expression)) {
+  if (ts35.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts31.isPropertyAccessExpression(node.expression)) {
+  } else if (ts35.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts31.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts35.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
     let resolvedDeclaration;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts31.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts35.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
       const signature = checker.getResolvedSignature(node);
@@ -2174,63 +2575,51 @@ function collectAllComments(sourceFile) {
   const comments = [];
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
-  function visit(node) {
-    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 === ts31.SyntaxKind.SingleLineCommentTrivia;
-        comments.push({
-          type: isLine ? "Line" : "Block",
-          value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
-          start: r.pos,
-          end: r.end
-        });
-      }
-    }
-    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 === ts31.SyntaxKind.SingleLineCommentTrivia;
-        comments.push({
-          type: isLine ? "Line" : "Block",
-          value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
-          start: r.pos,
-          end: r.end
-        });
-      }
+  function addRanges(ranges) {
+    if (!ranges) return;
+    for (const r of ranges) {
+      if (seen.has(r.pos)) continue;
+      seen.add(r.pos);
+      const isLine = r.kind === ts35.SyntaxKind.SingleLineCommentTrivia;
+      comments.push({
+        type: isLine ? "Line" : "Block",
+        value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
+        start: r.pos,
+        end: r.end
+      });
     }
-    ts31.forEachChild(node, visit);
+  }
+  function visit(node) {
+    addRanges(ts35.getLeadingCommentRanges(source, node.getFullStart()));
+    addRanges(ts35.getTrailingCommentRanges(source, node.getEnd()));
+    ts35.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts32 from "typescript";
+import * as ts36 from "typescript";
 import { dirname as dirname2 } from "path";
 function createProgramFromFiles(files) {
   let configPath;
   if (files.length > 0) {
-    configPath = ts32.findConfigFile(dirname2(files[0]), ts32.sys.fileExists, "tsconfig.json");
+    configPath = ts36.findConfigFile(dirname2(files[0]), ts36.sys.fileExists, "tsconfig.json");
   }
   if (configPath) {
-    const configFile = ts32.readConfigFile(configPath, ts32.sys.readFile);
-    const parsed = ts32.parseJsonConfigFileContent(configFile.config, ts32.sys, dirname2(configPath));
-    return ts32.createProgram({
+    const configFile = ts36.readConfigFile(configPath, ts36.sys.readFile);
+    const parsed = ts36.parseJsonConfigFileContent(configFile.config, ts36.sys, dirname2(configPath));
+    return ts36.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts32.createProgram({
+  return ts36.createProgram({
     rootNames: files,
     options: {
-      target: ts32.ScriptTarget.ESNext,
-      module: ts32.ModuleKind.ESNext,
-      moduleResolution: ts32.ModuleResolutionKind.Bundler,
+      target: ts36.ScriptTarget.ESNext,
+      module: ts36.ModuleKind.ESNext,
+      moduleResolution: ts36.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -2247,14 +2636,9 @@ function analyzeFiles(files, rules) {
   const allowedFiles = new Set(files);
   const { index, diagnostics } = collectProject(program, tsRules, allowedFiles);
   for (const rule of crossFileRules) {
-    const crossDiagnostics = rule.analyze(index);
-    for (const diagnostic of crossDiagnostics) {
-      const fileData = index.files.get(diagnostic.file);
-      if (fileData !== void 0) annotate([diagnostic], fileData.comments, fileData.source);
-    }
-    diagnostics.push(...crossDiagnostics);
+    diagnostics.push(...rule.analyze(index));
   }
-  return dedupeDiagnostics(diagnostics);
+  return finalizeDiagnostics(diagnostics, index.files);
 }
 function dedupeDiagnostics(diagnostics) {
   const seen = /* @__PURE__ */ new Set();
@@ -2267,8 +2651,30 @@ function dedupeDiagnostics(diagnostics) {
   }
   return deduped;
 }
-function annotate(diagnostics, comments, source) {
-  if (comments.length === 0 || diagnostics.length === 0) return;
+function finalizeDiagnostics(diagnostics, files) {
+  const diagnosticsByFile = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    let list = diagnosticsByFile.get(diagnostic.file);
+    if (list === void 0) {
+      list = [];
+      diagnosticsByFile.set(diagnostic.file, list);
+    }
+    list.push(diagnostic);
+  }
+  const finalized = [];
+  for (const [file, fileDiagnostics] of diagnosticsByFile) {
+    const fileData = files.get(file);
+    if (fileData === void 0) {
+      finalized.push(...fileDiagnostics);
+      continue;
+    }
+    finalized.push(...annotateAndFilter(fileDiagnostics, fileData.comments, fileData.source));
+  }
+  return dedupeDiagnostics(finalized);
+}
+function annotateAndFilter(diagnostics, comments, source) {
+  if (diagnostics.length === 0) return diagnostics;
+  if (comments.length === 0) return diagnostics;
   const byEndLine = /* @__PURE__ */ new Map();
   for (const comment of comments) {
     const endLine = lineAt(source, comment.end);
@@ -2279,15 +2685,20 @@ function annotate(diagnostics, comments, source) {
     }
     list.push(comment);
   }
+  const kept = [];
   for (const diagnostic of diagnostics) {
+    if (isSatisfiedByComment(diagnostic, byEndLine, source)) continue;
     const inline = findInlineComment(diagnostic.line, byEndLine);
     if (inline !== null) {
       diagnostic.annotation = inline;
+      kept.push(diagnostic);
       continue;
     }
     const above = collectAnnotation(diagnostic.line - 1, byEndLine, source);
     if (above !== null) diagnostic.annotation = above;
+    kept.push(diagnostic);
   }
+  return kept;
 }
 function lastCommentOnLine(line, byEndLine) {
   const commentsOnLine = byEndLine.get(line);
@@ -2298,14 +2709,33 @@ function findInlineComment(diagLine, byEndLine) {
   const comment = lastCommentOnLine(diagLine, byEndLine);
   if (comment === null || comment.type !== "Line") return null;
   const text = comment.value.trim();
-  if (text.startsWith("@expect")) return null;
+  if (isDirectiveComment(text)) return null;
   return text;
 }
 function collectAnnotation(commentEndLine, byEndLine, source) {
+  const comments = collectCommentsAbove(commentEndLine, byEndLine, source);
+  if (comments.length === 0) return null;
+  const first = comments[0];
+  if (comments.length === 1 && first !== void 0 && first.type === "Block") {
+    return cleanBlockComment(first.value);
+  }
+  return comments.map((c) => c.value.trim()).join("\n");
+}
+function isSatisfiedByComment(diagnostic, byEndLine, source) {
+  if (diagnostic.severity === "error") return false;
+  const candidates = getCommentCandidates(diagnostic.line, byEndLine, source);
+  return candidates.some((comment) => commentSatisfiesRule(comment, diagnostic.ruleId));
+}
+function getCommentCandidates(diagLine, byEndLine, source) {
+  const inline = byEndLine.get(diagLine) ?? [];
+  const above = collectCommentsAbove(diagLine - 1, byEndLine, source);
+  return [...inline, ...above];
+}
+function collectCommentsAbove(commentEndLine, byEndLine, source) {
   const comment = lastCommentOnLine(commentEndLine, byEndLine);
-  if (comment === null) return null;
-  if (comment.type === "Block") return cleanBlockComment(comment.value);
-  const lines = [comment.value.trim()];
+  if (comment === null) return [];
+  if (comment.type === "Block") return [comment];
+  const lines = [comment];
   let prevLine = commentEndLine - 1;
   for (; ; ) {
     const prev = byEndLine.get(prevLine);
@@ -2313,10 +2743,28 @@ function collectAnnotation(commentEndLine, byEndLine, source) {
     const prevComment = prev.at(-1);
     if (prevComment === void 0 || prevComment.type !== "Line") break;
     if (lineAt(source, prevComment.start) !== prevLine) break;
-    lines.unshift(prevComment.value.trim());
+    lines.unshift(prevComment);
     prevLine--;
   }
-  return lines.join("\n");
+  return lines;
+}
+function commentSatisfiesRule(comment, ruleId) {
+  for (const line of commentLines(comment)) {
+    const match = line.match(/^@unguard\s+([^\s]+)\b/);
+    if (match?.[1] === ruleId) return true;
+  }
+  return false;
+}
+function commentLines(comment) {
+  if (comment.type === "Block") {
+    const cleaned = cleanBlockComment(comment.value);
+    if (cleaned.length === 0) return [];
+    return cleaned.split("\n");
+  }
+  return [comment.value.trim()];
+}
+function isDirectiveComment(text) {
+  return text.startsWith("@expect") || text.startsWith("@unguard");
 }
 function cleanBlockComment(value) {
   return value.split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter((line) => line.length > 0).join("\n");
@@ -2470,4 +2918,4 @@ export {
   executeScan,
   scan
 };
-//# sourceMappingURL=chunk-HE647T6E.js.map
+//# sourceMappingURL=chunk-KNKWDZ6H.js.map