unguard 0.7.0 → 0.8.0

package/dist/chunk-YYX4R25B.js

@@ -0,0 +1,1519 @@
+// src/rules/ts/no-empty-catch.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",
+  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;
+      }
+    }
+  }
+  return false;
+}
+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 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;
+    }
+  }
+  return false;
+}
+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);
+  }
+  return false;
+}
+function isLengthAccess(node, arrName) {
+  if (!ts2.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 (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;
+      }
+    }
+    if (ts2.isIfStatement(parent) && parent.thenStatement === current) {
+      if (isPositiveLengthCheck(parent.expression, arrName)) return true;
+    }
+    if (ts2.isBlock(current) && ts2.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 (!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 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;
+  }
+  if (op === ts2.SyntaxKind.ExclamationEqualsEqualsToken || op === ts2.SyntaxKind.ExclamationEqualsToken) {
+    if (isLengthAccess(expr.left, arrName) && isNumericLiteralValue(expr.right, 0)) return true;
+  }
+  return false;
+}
+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 isNumericLiteralValue(node, value) {
+  return ts2.isNumericLiteral(node) && node.text === String(value);
+}
+function isNumericLiteralGte(node, min) {
+  return ts2.isNumericLiteral(node) && Number(node.text) >= min;
+}
+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;
+}
+
+// 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;
+    }
+    if (isBitwiseExpression(operand)) return;
+    ctx.report(node);
+  }
+};
+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/ts/no-nullish-coalescing.ts
+import * as ts6 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 (!ts6.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts6.SyntaxKind.QuestionQuestionToken) return;
+    if (ctx.isNullable(node.left)) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-optional-call.ts
+import * as ts7 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 (!ts7.isCallExpression(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 ts8 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 (!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);
+  }
+};
+
+// 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);
+    }
+  }
+};
+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",
+  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);
+    }
+  }
+};
+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;
+  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/ts/no-inline-type-in-params.ts
+import * as ts14 from "typescript";
+function isTopLevelFunctionParam(source, offset) {
+  let depth = 0;
+  for (let i = offset - 1; i >= 0; i--) {
+    if (source[i] === "}") depth++;
+    if (source[i] === "{") {
+      if (depth === 0) {
+        const before = source.slice(Math.max(0, i - 150), i).trimEnd();
+        if (/(\)|\bfunction\b.*\))\s*$/.test(before)) {
+          depth--;
+          continue;
+        }
+        return false;
+      }
+      depth--;
+    }
+  }
+  return true;
+}
+var noInlineTypeInParams = {
+  kind: "ts",
+  id: "no-inline-type-in-params",
+  severity: "info",
+  message: "Inline type literal in annotation; extract to a named type for reuse and clarity",
+  visit(node, ctx) {
+    if (!ts14.isTypeLiteralNode(node)) return;
+    const parent = node.parent;
+    if (!parent || !ts14.isParameter(parent)) return;
+    if (parent.type !== node) return;
+    const offset = node.getStart(ctx.sourceFile);
+    if (!isTopLevelFunctionParam(ctx.source, offset)) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-type-assertion.ts
+import * as ts15 from "typescript";
+var noTypeAssertion = {
+  kind: "ts",
+  id: "no-type-assertion",
+  severity: "error",
+  message: "Double type assertion (`as unknown as T`) circumvents the type system; fix the upstream type or use a type guard",
+  visit(node, ctx) {
+    if (!ts15.isAsExpression(node)) return;
+    if (!ts15.isAsExpression(node.expression)) return;
+    if (node.expression.type.kind !== ts15.SyntaxKind.UnknownKeyword) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/ts/no-redundant-existence-guard.ts
+import * as 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);
+        }
+      }
+    }
+  }
+};
+function accessesIdentifier(expr, name) {
+  const root = getExpressionRoot(expr);
+  return ts16.isIdentifier(root) && root.text === name;
+}
+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 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 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;
+}
+
+// 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) {
+    if (!ts17.isFunctionDeclaration(node) && !ts17.isArrowFunction(node)) return;
+    if (!node.body || !ts17.isBlock(node.body)) return;
+    const stmts = node.body.statements;
+    if (stmts.length === 0) return;
+    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 = node.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) {
+    if (!ts18.isFunctionDeclaration(node) && !ts18.isArrowFunction(node)) return;
+    if (!node.body || !ts18.isBlock(node.body)) return;
+    const stmts = node.body.statements;
+    if (stmts.length === 0) return;
+    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 = node.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
+var duplicateTypeDeclaration = {
+  id: "duplicate-type-declaration",
+  severity: "error",
+  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;
+      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((e) => `${e.name} (${e.file}:${e.line})`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `Type "${entry.name}" has identical shape to: ${others}`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+
+// src/rules/cross-file/duplicate-function-declaration.ts
+import * as ts19 from "typescript";
+var duplicateFunctionDeclaration = {
+  id: "duplicate-function-declaration",
+  severity: "error",
+  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 files = new Set(group.map((e) => e.file));
+      if (files.size < 2) continue;
+      const first = group[0];
+      if (first !== void 0 && isSetter(first.node)) continue;
+      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((e) => `${e.name} (${e.file}:${e.line})`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `Function "${entry.name}" has identical body to: ${others}`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+function isSetter(node) {
+  let body;
+  if (ts19.isFunctionDeclaration(node) || ts19.isFunctionExpression(node)) {
+    body = node.body;
+  } else if (ts19.isArrowFunction(node)) {
+    body = ts19.isBlock(node.body) ? node.body : void 0;
+  }
+  if (!body || body.statements.length !== 1) return false;
+  const stmt = body.statements[0];
+  if (stmt === void 0 || !ts19.isExpressionStatement(stmt)) return false;
+  return ts19.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts19.SyntaxKind.EqualsToken;
+}
+
+// src/rules/cross-file/optional-arg-always-used.ts
+var optionalArgAlwaysUsed = {
+  id: "optional-arg-always-used",
+  severity: "warning",
+  message: "Optional parameter is always provided at every call site; make it required",
+  analyze(project) {
+    const diagnostics = [];
+    for (const fn of project.functions.getAll()) {
+      for (let i = 0; i < fn.params.length; i++) {
+        const param = fn.params[i];
+        if (param === void 0) continue;
+        if (!param.optional && !param.hasDefault) continue;
+        const callSites = fn.symbol ? project.callSites.filter((c) => c.symbol === fn.symbol) : project.callSites.filter((c) => c.calleeName === fn.name);
+        if (callSites.length < 2) continue;
+        const allProvide = callSites.every((c) => c.argCount > i);
+        if (allProvide) {
+          diagnostics.push({
+            ruleId: this.id,
+            severity: this.severity,
+            message: `Optional parameter "${param.name}" is always provided at all ${callSites.length} call sites; make it required`,
+            file: fn.file,
+            line: fn.line,
+            column: 1
+          });
+        }
+      }
+    }
+    return diagnostics;
+  }
+};
+
+// src/rules/ts/no-catch-return.ts
+import * as ts20 from "typescript";
+var noCatchReturn = {
+  kind: "ts",
+  id: "no-catch-return",
+  severity: "warning",
+  message: "Catch block silently returns a fallback value with no logging; rethrow, log the error, or let it propagate",
+  visit(node, ctx) {
+    if (!ts20.isCatchClause(node)) return;
+    const block = node.block;
+    if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
+      ctx.report(node);
+    }
+  }
+};
+function walkBlock(block, predicate) {
+  function visit(node) {
+    if (predicate(node)) return true;
+    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return false;
+    return ts20.forEachChild(node, visit) ?? false;
+  }
+  return ts20.forEachChild(block, visit) ?? false;
+}
+function hasReturn(block) {
+  return walkBlock(block, (n) => ts20.isReturnStatement(n));
+}
+function hasThrow(block) {
+  return walkBlock(block, (n) => ts20.isThrowStatement(n));
+}
+var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
+function hasLogging(block) {
+  return walkBlock(block, (n) => {
+    if (!ts20.isCallExpression(n)) return false;
+    const callee = n.expression;
+    if (!ts20.isPropertyAccessExpression(callee)) return false;
+    if (!ts20.isIdentifier(callee.expression)) return false;
+    return LOG_OBJECTS.has(callee.expression.text);
+  });
+}
+
+// src/rules/ts/no-error-rewrap.ts
+import * as ts21 from "typescript";
+var noErrorRewrap = {
+  kind: "ts",
+  id: "no-error-rewrap",
+  severity: "error",
+  message: "Re-wrapped error loses the original stack trace and type; use { cause: originalError } to preserve the error chain",
+  visit(node, ctx) {
+    if (!ts21.isCatchClause(node)) return;
+    if (!node.variableDeclaration) return;
+    const param = node.variableDeclaration.name;
+    if (!ts21.isIdentifier(param)) return;
+    const catchName = param.text;
+    findRewraps(node.block, catchName, ctx);
+  }
+};
+function findRewraps(block, catchName, ctx) {
+  function visit(node) {
+    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return;
+    if (ts21.isThrowStatement(node) && node.expression && ts21.isNewExpression(node.expression)) {
+      const args = node.expression.arguments;
+      if (args && args.length > 0 && referencesName(args, catchName) && !hasCauseArg(args)) {
+        ctx.report(node);
+      }
+      return;
+    }
+    ts21.forEachChild(node, visit);
+  }
+  ts21.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 (ts21.isIdentifier(node) && node.text === name) return true;
+  return ts21.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+}
+function hasCauseArg(args) {
+  for (const arg of args) {
+    if (ts21.isObjectLiteralExpression(arg)) {
+      for (const prop of arg.properties) {
+        if (ts21.isPropertyAssignment(prop) && ts21.isIdentifier(prop.name) && prop.name.text === "cause") return true;
+        if (ts21.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/rules/cross-file/explicit-null-arg.ts
+import * as ts22 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 === ts22.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: "error",
+  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;
+      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((e) => `${e.file}:${e.line}`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `Exported function "${entry.name}" also defined in: ${others}`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
+    }
+    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/cross-file/duplicate-type-name.ts
+import * as ts23 from "typescript";
+var duplicateTypeName = {
+  id: "duplicate-type-name",
+  severity: "error",
+  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) => !ts23.isTypeLiteralNode(e.node) && !ts23.isInterfaceDeclaration(e.node)
+      );
+      if (hasInferredType) continue;
+      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((e) => `${e.file}:${e.line}`).join(", ");
+        diagnostics.push({
+          ruleId: this.id,
+          severity: this.severity,
+          message: `Exported type "${entry.name}" also defined in: ${others}`,
+          file: entry.file,
+          line: entry.line,
+          column: 1
+        });
+      }
+    }
+    return diagnostics;
+  }
+};
+
+// src/rules/ts/no-dynamic-import.ts
+import * as ts24 from "typescript";
+var noDynamicImport = {
+  kind: "ts",
+  id: "no-dynamic-import",
+  severity: "error",
+  message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
+  visit(node, ctx) {
+    if (!ts24.isCallExpression(node)) return;
+    if (node.expression.kind !== ts24.SyntaxKind.ImportKeyword) return;
+    ctx.report(node);
+  }
+};
+
+// src/rules/index.ts
+var allRules = [
+  noEmptyCatch,
+  noNonNullAssertion,
+  noDoubleNegationCoercion,
+  noTsIgnore,
+  noNullishCoalescing,
+  noOptionalCall,
+  noOptionalPropertyAccess,
+  noOptionalElementAccess,
+  noLogicalOrFallback,
+  noNullTernaryNormalization,
+  noAnyCast,
+  noExplicitAnyAnnotation,
+  noInlineTypeInParams,
+  noTypeAssertion,
+  noRedundantExistenceGuard,
+  preferDefaultParamValue,
+  preferRequiredParamWithGuard,
+  duplicateTypeDeclaration,
+  duplicateFunctionDeclaration,
+  optionalArgAlwaysUsed,
+  noCatchReturn,
+  noErrorRewrap,
+  explicitNullArg,
+  duplicateFunctionName,
+  duplicateTypeName,
+  noDynamicImport
+];
+
+// src/engine.ts
+import fg from "fast-glob";
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/rules/types.ts
+function isTSRule(r) {
+  return "kind" in r && r.kind === "ts";
+}
+
+// src/collect/index.ts
+import * as ts26 from "typescript";
+import "fs";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import * as ts25 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 (ts25.isTypeLiteralNode(node)) {
+    const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
+    return `{${normalized}}`;
+  }
+  if (ts25.isInterfaceDeclaration(node)) {
+    const normalized = node.members.map((m) => normalizeTypeNode(m, sourceFile)).sort().join(";");
+    return `{${normalized}}`;
+  }
+  if (ts25.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 (ts25.isTypeAliasDeclaration(node)) {
+    return normalizeTypeNode(node.type, sourceFile);
+  }
+  return node.getText(sourceFile).replace(/\s+/g, " ").trim();
+}
+function hashFunctionBody(node, sourceFile) {
+  const bodyText = node.getText(sourceFile);
+  const normalized = bodyText.replace(/\s+/g, " ").trim();
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+
+// src/collect/type-registry.ts
+var TypeRegistry = class {
+  entries = [];
+  byHash = /* @__PURE__ */ new Map();
+  add(name, file, line, typeNode, sourceFile, exported) {
+    const hash = hashTypeShape(typeNode, sourceFile);
+    const entry = { name, file, line, hash, node: typeNode, exported };
+    this.entries.push(entry);
+    let list = this.byHash.get(hash);
+    if (list === void 0) {
+      list = [];
+      this.byHash.set(hash, list);
+    }
+    list.push(entry);
+  }
+  getDuplicateGroups() {
+    return [...this.byHash.values()].filter((group) => group.length > 1);
+  }
+  getAll() {
+    return this.entries;
+  }
+  getNameCollisionGroups() {
+    const byName = /* @__PURE__ */ new Map();
+    for (const entry of this.entries) {
+      if (!entry.exported) continue;
+      let list = byName.get(entry.name);
+      if (list === void 0) {
+        list = [];
+        byName.set(entry.name, list);
+      }
+      list.push(entry);
+    }
+    return [...byName.values()].filter((group) => {
+      if (group.length < 2) return false;
+      const files = new Set(group.map((e) => e.file));
+      return files.size > 1;
+    });
+  }
+};
+
+// src/collect/function-registry.ts
+var FunctionRegistry = class {
+  entries = [];
+  byHash = /* @__PURE__ */ new Map();
+  add(entry) {
+    this.entries.push(entry);
+    let list = this.byHash.get(entry.hash);
+    if (list === void 0) {
+      list = [];
+      this.byHash.set(entry.hash, list);
+    }
+    list.push(entry);
+  }
+  getDuplicateGroups() {
+    return [...this.byHash.values()].filter((group) => group.length > 1);
+  }
+  getAll() {
+    return this.entries;
+  }
+  getByName(name) {
+    return this.entries.filter((e) => e.name === name);
+  }
+  getNameCollisionGroups() {
+    const byName = /* @__PURE__ */ new Map();
+    for (const entry of this.entries) {
+      if (!entry.exported) continue;
+      let list = byName.get(entry.name);
+      if (list === void 0) {
+        list = [];
+        byName.set(entry.name, list);
+      }
+      list.push(entry);
+    }
+    return [...byName.values()].filter((group) => {
+      if (group.length < 2) return false;
+      const files = new Set(group.map((e) => e.file));
+      return files.size > 1;
+    });
+  }
+};
+
+// src/collect/index.ts
+function collectProject(program) {
+  const checker = program.getTypeChecker();
+  const types = new TypeRegistry();
+  const functions = new FunctionRegistry();
+  const callSites = [];
+  const imports = [];
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const sourceFile of program.getSourceFiles()) {
+    let visit2 = function(node) {
+      collectTypes(node, file, sourceFile, types);
+      collectFunctions(node, file, sourceFile, checker, functions);
+      collectCallSites(node, file, sourceFile, checker, callSites);
+      collectImports(node, file, imports);
+      ts26.forEachChild(node, visit2);
+    };
+    var visit = visit2;
+    const file = sourceFile.fileName;
+    if (sourceFile.isDeclarationFile) continue;
+    if (file.includes("node_modules")) continue;
+    const source = sourceFile.getFullText();
+    const comments = collectAllComments(sourceFile);
+    fileMap.set(file, { source, sourceFile, comments });
+    ts26.forEachChild(sourceFile, visit2);
+  }
+  return { types, functions, callSites, imports, files: fileMap };
+}
+function isExported(node) {
+  if (!ts26.canHaveModifiers(node)) return false;
+  const mods = ts26.getModifiers(node);
+  if (mods === void 0) return false;
+  return mods.some((m) => m.kind === ts26.SyntaxKind.ExportKeyword);
+}
+function collectTypes(node, file, sourceFile, registry) {
+  if (ts26.isTypeAliasDeclaration(node)) {
+    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    registry.add(node.name.text, file, line, node.type, sourceFile, isExported(node));
+  }
+  if (ts26.isInterfaceDeclaration(node)) {
+    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
+  }
+}
+function collectFunctions(node, file, sourceFile, checker, registry) {
+  if (ts26.isFunctionDeclaration(node) && node.name && node.body) {
+    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const params = extractParams(node.parameters, sourceFile);
+    const hash = hashFunctionBody(node.body, sourceFile);
+    const symbol = checker.getSymbolAtLocation(node.name);
+    registry.add({ name: node.name.text, file, line, hash, params, node, exported: isExported(node), symbol });
+  }
+  if (ts26.isVariableStatement(node)) {
+    const exported = isExported(node);
+    for (const decl of node.declarationList.declarations) {
+      if (decl.initializer && ts26.isArrowFunction(decl.initializer) && ts26.isIdentifier(decl.name)) {
+        const arrow = decl.initializer;
+        const body = ts26.isBlock(arrow.body) ? arrow.body : arrow.body;
+        const line = ts26.getLineAndCharacterOfPosition(sourceFile, decl.getStart(sourceFile)).line + 1;
+        const params = extractParams(arrow.parameters, sourceFile);
+        const hash = hashFunctionBody(body, sourceFile);
+        const symbol = checker.getSymbolAtLocation(decl.name);
+        registry.add({ name: decl.name.text, file, line, hash, params, node: arrow, exported, symbol });
+      }
+    }
+  }
+}
+function extractParams(parameters, sourceFile) {
+  return parameters.map((p) => {
+    const name = p.name.getText(sourceFile);
+    const optional = p.questionToken !== void 0;
+    const hasDefault = p.initializer !== void 0;
+    const typeText = p.type ? p.type.getText(sourceFile) : null;
+    return { name, optional, hasDefault, typeText };
+  });
+}
+function collectImports(node, file, imports) {
+  if (ts26.isImportDeclaration(node) && ts26.isStringLiteral(node.moduleSpecifier)) {
+    const moduleSource = node.moduleSpecifier.text;
+    const clause = node.importClause;
+    if (!clause) return;
+    if (clause.name) {
+      imports.push({
+        file,
+        localName: clause.name.text,
+        importedName: "default",
+        source: moduleSource
+      });
+    }
+    if (clause.namedBindings && ts26.isNamedImports(clause.namedBindings)) {
+      for (const el of clause.namedBindings.elements) {
+        imports.push({
+          file,
+          localName: el.name.text,
+          importedName: el.propertyName ? el.propertyName.text : el.name.text,
+          source: moduleSource
+        });
+      }
+    }
+  }
+  if (ts26.isExportDeclaration(node) && node.moduleSpecifier && ts26.isStringLiteral(node.moduleSpecifier)) {
+    const moduleSource = node.moduleSpecifier.text;
+    if (node.exportClause && ts26.isNamedExports(node.exportClause)) {
+      for (const el of node.exportClause.elements) {
+        imports.push({
+          file,
+          localName: el.name.text,
+          importedName: el.propertyName ? el.propertyName.text : el.name.text,
+          source: moduleSource
+        });
+      }
+    }
+  }
+}
+function collectCallSites(node, file, sourceFile, checker, sites) {
+  if (!ts26.isCallExpression(node)) return;
+  let calleeName = null;
+  if (ts26.isIdentifier(node.expression)) {
+    calleeName = node.expression.text;
+  } else if (ts26.isPropertyAccessExpression(node.expression)) {
+    calleeName = node.expression.name.text;
+  }
+  if (calleeName) {
+    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    let symbol;
+    try {
+      symbol = checker.getSymbolAtLocation(node.expression);
+      if (symbol && symbol.flags & ts26.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+      }
+    } catch {
+    }
+    sites.push({
+      calleeName,
+      file,
+      line,
+      argCount: node.arguments.length,
+      node,
+      symbol
+    });
+  }
+}
+function collectAllComments(sourceFile) {
+  const comments = [];
+  const source = sourceFile.getFullText();
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    const leading = ts26.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 === ts26.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 = ts26.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 === ts26.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
+        });
+      }
+    }
+    ts26.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return comments;
+}
+
+// src/typecheck/program.ts
+import * as ts27 from "typescript";
+import { dirname as dirname2 } from "path";
+function createProgramFromFiles(files) {
+  let configPath;
+  if (files.length > 0) {
+    configPath = ts27.findConfigFile(dirname2(files[0]), ts27.sys.fileExists, "tsconfig.json");
+  }
+  if (configPath) {
+    const configFile = ts27.readConfigFile(configPath, ts27.sys.readFile);
+    const parsed = ts27.parseJsonConfigFileContent(configFile.config, ts27.sys, dirname2(configPath));
+    return ts27.createProgram({
+      rootNames: files,
+      options: { ...parsed.options, skipLibCheck: true }
+    });
+  }
+  return ts27.createProgram({
+    rootNames: files,
+    options: {
+      target: ts27.ScriptTarget.ESNext,
+      module: ts27.ModuleKind.ESNext,
+      moduleResolution: ts27.ModuleResolutionKind.Bundler,
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true
+    }
+  });
+}
+
+// src/typecheck/walk.ts
+import * as ts28 from "typescript";
+function runTSRules(rules, sourceFile, checker, source, filename) {
+  const diagnostics = [];
+  const contexts = rules.map((rule) => ({
+    rule,
+    ctx: buildContext(rule, sourceFile, checker, source, filename, diagnostics)
+  }));
+  function visit(node) {
+    for (const { rule, ctx } of contexts) {
+      rule.visit(node, ctx);
+    }
+    ts28.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return diagnostics;
+}
+function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
+  return {
+    filename,
+    source,
+    sourceFile,
+    checker,
+    report(node, message) {
+      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile));
+      diagnostics.push({
+        ruleId: rule.id,
+        severity: rule.severity,
+        message: message ?? rule.message,
+        file: filename,
+        line: line + 1,
+        column: character + 1
+      });
+    },
+    reportAtOffset(offset, message) {
+      const { line, character } = ts28.getLineAndCharacterOfPosition(sourceFile, offset);
+      diagnostics.push({
+        ruleId: rule.id,
+        severity: rule.severity,
+        message: message ?? rule.message,
+        file: filename,
+        line: line + 1,
+        column: character + 1
+      });
+    },
+    isNullable(node) {
+      const type = checker.getTypeAtLocation(node);
+      return isNullableType(checker, type);
+    },
+    isExternal(node) {
+      const type = checker.getTypeAtLocation(node);
+      const symbol = type.getSymbol();
+      if (!symbol) return false;
+      const declarations = symbol.getDeclarations();
+      if (!declarations || declarations.length === 0) return false;
+      return declarations.some((d) => isFromNodeModules(d));
+    }
+  };
+}
+
+// src/engine.ts
+async function scan(options) {
+  const patterns = options.paths.length > 0 ? options.paths : ["."];
+  const globs = patterns.map((p) => {
+    if (p === ".") return `./**/*.{ts,cts,mts,tsx}`;
+    if (p.endsWith("/")) return `${p}**/*.{ts,cts,mts,tsx}`;
+    if (!p.includes("*") && !p.endsWith(".ts") && !p.endsWith(".tsx") && !p.endsWith(".cts") && !p.endsWith(".mts")) {
+      return `${p}/**/*.{ts,cts,mts,tsx}`;
+    }
+    return p;
+  });
+  const files = await fg(globs, {
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/*.d.ts", "**/*.d.cts", "**/*.d.mts"],
+    absolute: true
+  });
+  const activeRules = allRules.filter((r) => {
+    if (options.rules && !options.rules.includes(r.id)) return false;
+    return true;
+  });
+  const tsRules = activeRules.filter(isTSRule);
+  const crossFileRules = activeRules.filter((r) => !isTSRule(r));
+  const diagnostics = [];
+  const program = files.length > 0 ? createProgramFromFiles(files) : null;
+  if (tsRules.length > 0 && program) {
+    const checker = program.getTypeChecker();
+    for (const file of files) {
+      const source = readFileSync2(file, "utf8");
+      const sourceFile = program.getSourceFile(file);
+      if (sourceFile) {
+        const tsDiags = runTSRules(tsRules, sourceFile, checker, source, file);
+        diagnostics.push(...tsDiags);
+      }
+    }
+  }
+  if (crossFileRules.length > 0 && program) {
+    const projectIndex = collectProject(program);
+    for (const rule of crossFileRules) {
+      const crossDiags = rule.analyze(projectIndex);
+      for (const d of crossDiags) {
+        const fileData = projectIndex.files.get(d.file);
+        if (fileData !== void 0) annotate([d], fileData.comments, fileData.source);
+      }
+      diagnostics.push(...crossDiags);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const d of diagnostics) {
+    const key = `${d.file}:${d.line}:${d.ruleId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(d);
+  }
+  if (options.strict) {
+    for (const d of deduped) {
+      d.severity = "error";
+    }
+  }
+  return { diagnostics: deduped, fileCount: files.length };
+}
+function annotate(diagnostics, comments, source) {
+  if (comments.length === 0 || diagnostics.length === 0) return;
+  const byEndLine = /* @__PURE__ */ new Map();
+  for (const c of comments) {
+    const endLine = lineAt(source, c.end);
+    let list = byEndLine.get(endLine);
+    if (list === void 0) {
+      list = [];
+      byEndLine.set(endLine, list);
+    }
+    list.push(c);
+  }
+  for (const d of diagnostics) {
+    const inline = findInlineComment(d.line, byEndLine);
+    if (inline !== null) {
+      d.annotation = inline;
+      continue;
+    }
+    const above = collectAnnotation(d.line - 1, byEndLine, source);
+    if (above !== null) d.annotation = above;
+  }
+}
+function findInlineComment(diagLine, byEndLine) {
+  const commentsOnLine = byEndLine.get(diagLine);
+  if (commentsOnLine === void 0 || commentsOnLine.length === 0) return null;
+  const comment = commentsOnLine.at(-1);
+  if (comment === void 0) return null;
+  if (comment.type !== "Line") return null;
+  const text = comment.value.trim();
+  if (text.startsWith("@expect")) return null;
+  return text;
+}
+function collectAnnotation(commentEndLine, byEndLine, source) {
+  const commentsOnLine = byEndLine.get(commentEndLine);
+  if (commentsOnLine === void 0 || commentsOnLine.length === 0) return null;
+  const comment = commentsOnLine.at(-1);
+  if (comment === void 0) return null;
+  if (comment.type === "Block") {
+    return cleanBlockComment(comment.value);
+  }
+  const lines = [comment.value.trim()];
+  let prevLine = commentEndLine - 1;
+  for (; ; ) {
+    const prev = byEndLine.get(prevLine);
+    if (prev === void 0 || prev.length === 0) break;
+    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());
+    prevLine--;
+  }
+  return lines.join("\n");
+}
+function cleanBlockComment(value) {
+  return value.split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter((line) => line.length > 0).join("\n");
+}
+function lineAt(source, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source[i] === "\n") line++;
+  }
+  return line;
+}
+
+export {
+  allRules,
+  scan
+};
+//# sourceMappingURL=chunk-YYX4R25B.js.map