unguard 0.8.0 → 0.10.0

package/dist/{chunk-YYX4R25B.js → chunk-5GVEUYZF.js}

@@ -215,6 +215,12 @@ function isNullishLiteral(node) {
   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 };
+}
 
 // src/rules/ts/no-double-negation-coercion.ts
 var noDoubleNegationCoercion = {
@@ -463,79 +469,83 @@ var noExplicitAnyAnnotation = {
   }
 };
 
-// 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--;
-    }
+// 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
+    });
   }
-  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/cross-file/duplicate-inline-type-in-params.ts
+var duplicateInlineTypeInParams = {
+  id: "duplicate-inline-type-in-params",
+  severity: "warning",
+  message: "Same inline param type shape appears in multiple places; extract to a shared named type",
+  analyze(project) {
+    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-type-assertion.ts
-import * as ts15 from "typescript";
+import * as ts14 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;
+    if (!ts14.isAsExpression(node)) return;
+    if (!ts14.isAsExpression(node.expression)) return;
+    if (node.expression.type.kind !== ts14.SyntaxKind.UnknownKeyword) return;
     ctx.report(node);
   }
 };
 
 // src/rules/ts/no-redundant-existence-guard.ts
-import * as ts16 from "typescript";
+import * as ts15 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;
+    if (!ts15.isBinaryExpression(node)) return;
+    if (node.operatorToken.kind !== ts15.SyntaxKind.AmpersandAmpersandToken) return;
     const left = node.left;
     const right = node.right;
-    if (ts16.isIdentifier(left) && accessesIdentifier(right, left.text)) {
+    if (ts15.isIdentifier(left) && accessesIdentifier(right, left.text)) {
       if (ctx.isNullable(left)) return;
       ctx.report(node);
       return;
     }
-    if (ts16.isBinaryExpression(left) && isNullCheck(left)) {
+    if (ts15.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)) {
+        const identNode = ts15.isIdentifier(left.left) ? left.left : left.right;
+        if (ts15.isIdentifier(identNode) && identNode.text === checked && !ctx.isNullable(identNode)) {
           ctx.report(node);
         }
       }
@@ -544,84 +554,82 @@ var noRedundantExistenceGuard = {
 };
 function accessesIdentifier(expr, name) {
   const root = getExpressionRoot(expr);
-  return ts16.isIdentifier(root) && root.text === name;
+  return ts15.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);
+  if (ts15.isPropertyAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts15.isElementAccessExpression(node)) return getExpressionRoot(node.expression);
+  if (ts15.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;
+  if (op !== ts15.SyntaxKind.ExclamationEqualsToken && op !== ts15.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;
+  if (ts15.isIdentifier(expr.left) && isNullishLiteral(expr.right)) return expr.left.text;
+  if (ts15.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";
+import * as ts16 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 result = getFunctionBodyStatements(node);
+    if (result === null) return;
+    const { statements: stmts, fn } = result;
     const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts17.isExpressionStatement(firstStmt)) return;
+    if (firstStmt === void 0 || !ts16.isExpressionStatement(firstStmt)) return;
     const expr = firstStmt.expression;
-    if (!ts17.isBinaryExpression(expr) || expr.operatorToken.kind !== ts17.SyntaxKind.EqualsToken) return;
+    if (!ts16.isBinaryExpression(expr) || expr.operatorToken.kind !== ts16.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 (!ts16.isBinaryExpression(right) || right.operatorToken.kind !== ts16.SyntaxKind.QuestionQuestionToken) return;
+    if (!ts16.isIdentifier(expr.left) || !ts16.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);
+    const isParam = fn.parameters.some((p) => ts16.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";
+import * as ts17 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 result = getFunctionBodyStatements(node);
+    if (result === null) return;
+    const { statements: stmts, fn } = result;
     const firstStmt = stmts[0];
-    if (firstStmt === void 0 || !ts18.isIfStatement(firstStmt)) return;
+    if (firstStmt === void 0 || !ts17.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 (ts17.isPrefixUnaryExpression(test) && test.operator === ts17.SyntaxKind.ExclamationToken) {
+      if (ts17.isIdentifier(test.operand)) guardedName = test.operand.text;
     }
-    if (ts18.isBinaryExpression(test)) {
+    if (ts17.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") {
+      if (op === ts17.SyntaxKind.EqualsEqualsEqualsToken || op === ts17.SyntaxKind.EqualsEqualsToken) {
+        if (ts17.isIdentifier(test.left) && ts17.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]));
+    const isGuard = ts17.isReturnStatement(consequent) || ts17.isThrowStatement(consequent) || ts17.isBlock(consequent) && consequent.statements.length === 1 && consequent.statements[0] !== void 0 && (ts17.isReturnStatement(consequent.statements[0]) || ts17.isThrowStatement(consequent.statements[0]));
     if (!isGuard) return;
-    const isOptional = node.parameters.some(
-      (p) => ts18.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
+    const isOptional = fn.parameters.some(
+      (p) => ts17.isIdentifier(p.name) && p.name.text === guardedName && p.questionToken !== void 0
     );
     if (isOptional) ctx.report(firstStmt);
   }
@@ -630,70 +638,67 @@ var preferRequiredParamWithGuard = {
 // src/rules/cross-file/duplicate-type-declaration.ts
 var duplicateTypeDeclaration = {
   id: "duplicate-type-declaration",
-  severity: "error",
+  severity: "warning",
   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
-        });
-      }
+      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;
   }
 };
 
 // src/rules/cross-file/duplicate-function-declaration.ts
-import * as ts19 from "typescript";
+import * as ts18 from "typescript";
 var duplicateFunctionDeclaration = {
   id: "duplicate-function-declaration",
-  severity: "error",
+  severity: "warning",
   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
-        });
-      }
+      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;
   }
 };
+function getBodyBlock(node) {
+  if (ts18.isFunctionDeclaration(node) || ts18.isFunctionExpression(node)) return node.body;
+  if (ts18.isArrowFunction(node)) return ts18.isBlock(node.body) ? node.body : void 0;
+  if (ts18.isMethodDeclaration(node)) return node.body;
+  return void 0;
+}
+function isSingleStatement(node) {
+  const body = getBodyBlock(node);
+  return body !== void 0 && body.statements.length <= 1;
+}
 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;
-  }
+  const body = getBodyBlock(node);
   if (!body || body.statements.length !== 1) return false;
   const stmt = body.statements[0];
-  if (stmt === void 0 || !ts19.isExpressionStatement(stmt)) return false;
-  return ts19.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts19.SyntaxKind.EqualsToken;
+  if (stmt === void 0 || !ts18.isExpressionStatement(stmt)) return false;
+  return ts18.isBinaryExpression(stmt.expression) && stmt.expression.operatorToken.kind === ts18.SyntaxKind.EqualsToken;
 }
 
 // src/rules/cross-file/optional-arg-always-used.ts
@@ -728,14 +733,14 @@ var optionalArgAlwaysUsed = {
 };
 
 // src/rules/ts/no-catch-return.ts
-import * as ts20 from "typescript";
+import * as ts19 from "typescript";
 var noCatchReturn = {
   kind: "ts",
   id: "no-catch-return",
   severity: "warning",
   message: "Catch block silently returns a fallback value with no logging; rethrow, log the error, or let it propagate",
   visit(node, ctx) {
-    if (!ts20.isCatchClause(node)) return;
+    if (!ts19.isCatchClause(node)) return;
     const block = node.block;
     if (hasReturn(block) && !hasThrow(block) && !hasLogging(block)) {
       ctx.report(node);
@@ -745,57 +750,57 @@ var noCatchReturn = {
 function walkBlock(block, predicate) {
   function visit(node) {
     if (predicate(node)) return true;
-    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return false;
-    return ts20.forEachChild(node, visit) ?? false;
+    if (ts19.isFunctionDeclaration(node) || ts19.isFunctionExpression(node) || ts19.isArrowFunction(node)) return false;
+    return ts19.forEachChild(node, visit) ?? false;
   }
-  return ts20.forEachChild(block, visit) ?? false;
+  return ts19.forEachChild(block, visit) ?? false;
 }
 function hasReturn(block) {
-  return walkBlock(block, (n) => ts20.isReturnStatement(n));
+  return walkBlock(block, (n) => ts19.isReturnStatement(n));
 }
 function hasThrow(block) {
-  return walkBlock(block, (n) => ts20.isThrowStatement(n));
+  return walkBlock(block, (n) => ts19.isThrowStatement(n));
 }
 var LOG_OBJECTS = /* @__PURE__ */ new Set(["console", "logger", "log"]);
 function hasLogging(block) {
   return walkBlock(block, (n) => {
-    if (!ts20.isCallExpression(n)) return false;
+    if (!ts19.isCallExpression(n)) return false;
     const callee = n.expression;
-    if (!ts20.isPropertyAccessExpression(callee)) return false;
-    if (!ts20.isIdentifier(callee.expression)) return false;
+    if (!ts19.isPropertyAccessExpression(callee)) return false;
+    if (!ts19.isIdentifier(callee.expression)) return false;
     return LOG_OBJECTS.has(callee.expression.text);
   });
 }
 
 // src/rules/ts/no-error-rewrap.ts
-import * as ts21 from "typescript";
+import * as ts20 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 (!ts20.isCatchClause(node)) return;
     if (!node.variableDeclaration) return;
     const param = node.variableDeclaration.name;
-    if (!ts21.isIdentifier(param)) return;
+    if (!ts20.isIdentifier(param)) return;
     const catchName = param.text;
     findRewraps(node.block, catchName, ctx);
   }
 };
 function findRewraps(block, catchName, ctx) {
   function visit(node) {
-    if (ts21.isFunctionDeclaration(node) || ts21.isFunctionExpression(node) || ts21.isArrowFunction(node)) return;
-    if (ts21.isThrowStatement(node) && node.expression && ts21.isNewExpression(node.expression)) {
+    if (ts20.isFunctionDeclaration(node) || ts20.isFunctionExpression(node) || ts20.isArrowFunction(node)) return;
+    if (ts20.isThrowStatement(node) && node.expression && ts20.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);
+    ts20.forEachChild(node, visit);
   }
-  ts21.forEachChild(block, visit);
+  ts20.forEachChild(block, visit);
 }
 function referencesName(args, name) {
   for (const arg of args) {
@@ -804,15 +809,15 @@ function referencesName(args, name) {
   return false;
 }
 function containsIdentifier(node, name) {
-  if (ts21.isIdentifier(node) && node.text === name) return true;
-  return ts21.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
+  if (ts20.isIdentifier(node) && node.text === name) return true;
+  return ts20.forEachChild(node, (child) => containsIdentifier(child, name) || void 0) ?? false;
 }
 function hasCauseArg(args) {
   for (const arg of args) {
-    if (ts21.isObjectLiteralExpression(arg)) {
+    if (ts20.isObjectLiteralExpression(arg)) {
       for (const prop of arg.properties) {
-        if (ts21.isPropertyAssignment(prop) && ts21.isIdentifier(prop.name) && prop.name.text === "cause") return true;
-        if (ts21.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
+        if (ts20.isPropertyAssignment(prop) && ts20.isIdentifier(prop.name) && prop.name.text === "cause") return true;
+        if (ts20.isShorthandPropertyAssignment(prop) && prop.name.text === "cause") return true;
       }
     }
   }
@@ -820,7 +825,7 @@ function hasCauseArg(args) {
 }
 
 // src/rules/cross-file/explicit-null-arg.ts
-import * as ts22 from "typescript";
+import * as ts21 from "typescript";
 var explicitNullArg = {
   id: "explicit-null-arg",
   severity: "warning",
@@ -840,7 +845,7 @@ var explicitNullArg = {
         const arg = site.node.arguments[i];
         if (arg === void 0) continue;
         if (isNullishLiteral(arg)) {
-          const val = arg.kind === ts22.SyntaxKind.NullKeyword ? "null" : "undefined";
+          const val = arg.kind === ts21.SyntaxKind.NullKeyword ? "null" : "undefined";
           diagnostics.push({
             ruleId: this.id,
             severity: this.severity,
@@ -862,7 +867,7 @@ import { dirname, resolve } from "path";
 var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var duplicateFunctionName = {
   id: "duplicate-function-name",
-  severity: "error",
+  severity: "warning",
   message: "Same function name exported from multiple files; consolidate or rename to avoid ambiguity",
   analyze(project) {
     const diagnostics = [];
@@ -890,18 +895,14 @@ var duplicateFunctionName = {
         );
       });
       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
-        });
-      }
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.file}:${e.line}`,
+        (e, others) => `Exported function "${e.name}" also defined in: ${others}`,
+        diagnostics
+      );
     }
     return diagnostics;
   }
@@ -911,16 +912,16 @@ function resolveCandidates(fromFile, specifier) {
   const candidates = [base];
   for (const ext of EXTENSIONS) {
     candidates.push(base + ext);
-    candidates.push(resolve(base, "index" + ext));
+    candidates.push(resolve(base, `index${ext}`));
   }
   return candidates;
 }
 
 // src/rules/cross-file/duplicate-type-name.ts
-import * as ts23 from "typescript";
+import * as ts22 from "typescript";
 var duplicateTypeName = {
   id: "duplicate-type-name",
-  severity: "error",
+  severity: "warning",
   message: "Same type name exported from multiple files; consolidate or rename to avoid ambiguity",
   analyze(project) {
     const diagnostics = [];
@@ -928,40 +929,290 @@ var duplicateTypeName = {
       const hashes = new Set(group.map((e) => e.hash));
       if (hashes.size === 1) continue;
       const hasInferredType = group.some(
-        (e) => !ts23.isTypeLiteralNode(e.node) && !ts23.isInterfaceDeclaration(e.node)
+        (e) => !ts22.isTypeLiteralNode(e.node) && !ts22.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
-        });
-      }
+      reportDuplicateGroup(
+        group,
+        this.id,
+        this.severity,
+        (e) => `${e.file}:${e.line}`,
+        (e, others) => `Exported type "${e.name}" also defined in: ${others}`,
+        diagnostics
+      );
+    }
+    return diagnostics;
+  }
+};
+
+// 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
+      );
     }
     return diagnostics;
   }
 };
 
 // src/rules/ts/no-dynamic-import.ts
-import * as ts24 from "typescript";
+import * as ts23 from "typescript";
 var noDynamicImport = {
   kind: "ts",
   id: "no-dynamic-import",
   severity: "error",
   message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
   visit(node, ctx) {
-    if (!ts24.isCallExpression(node)) return;
-    if (node.expression.kind !== ts24.SyntaxKind.ImportKeyword) return;
+    if (!ts23.isCallExpression(node)) return;
+    if (node.expression.kind !== ts23.SyntaxKind.ImportKeyword) return;
     ctx.report(node);
   }
 };
 
+// src/rules/cross-file/near-duplicate-function.ts
+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;
+      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;
+  }
+};
+
+// src/rules/cross-file/trivial-wrapper.ts
+import * as ts24 from "typescript";
+function getFunctionBody(node) {
+  if (ts24.isFunctionDeclaration(node) || ts24.isFunctionExpression(node)) {
+    return node.body;
+  }
+  if (ts24.isArrowFunction(node)) {
+    return node.body;
+  }
+  if (ts24.isMethodDeclaration(node)) {
+    return node.body;
+  }
+  return void 0;
+}
+function getCalleeName(expr) {
+  if (ts24.isIdentifier(expr)) return expr.text;
+  if (ts24.isPropertyAccessExpression(expr)) return expr.name.text;
+  return void 0;
+}
+function getTrivialCallTarget(fn) {
+  const body = getFunctionBody(fn.node);
+  if (!body) return null;
+  let callExpr;
+  if (ts24.isBlock(body)) {
+    if (body.statements.length !== 1) return null;
+    const stmt = body.statements[0];
+    if (!stmt || !ts24.isReturnStatement(stmt) || !stmt.expression) return null;
+    if (!ts24.isCallExpression(stmt.expression)) return null;
+    callExpr = stmt.expression;
+  } else {
+    if (!ts24.isCallExpression(body)) return null;
+    callExpr = body;
+  }
+  const calleeName = getCalleeName(callExpr.expression);
+  if (!calleeName) return null;
+  const paramNames = fn.params.map((p) => p.name);
+  const args = callExpr.arguments;
+  for (const arg of args) {
+    if (!ts24.isIdentifier(arg)) return null;
+    if (!paramNames.includes(arg.text)) return null;
+  }
+  return { calleeName };
+}
+var trivialWrapper = {
+  id: "trivial-wrapper",
+  severity: "info",
+  message: "Function is a trivial wrapper that delegates without transformation; consider using the target directly",
+  analyze(project) {
+    const diagnostics = [];
+    const knownFunctions = new Set(
+      project.functions.getAll().map((f) => f.name)
+    );
+    for (const fn of project.functions.getAll()) {
+      const target = getTrivialCallTarget(fn);
+      if (!target) continue;
+      if (!knownFunctions.has(target.calleeName)) continue;
+      if (fn.name === target.calleeName) continue;
+      diagnostics.push({
+        ruleId: this.id,
+        severity: this.severity,
+        message: `Function "${fn.name}" trivially wraps "${target.calleeName}" without transformation`,
+        file: fn.file,
+        line: fn.line,
+        column: 1
+      });
+    }
+    return diagnostics;
+  }
+};
+
+// src/rules/cross-file/unused-export.ts
+var unusedExport = {
+  id: "unused-export",
+  severity: "info",
+  message: "Exported function has no usages within the project",
+  analyze(project) {
+    const diagnostics = [];
+    const usedDeclarations = /* @__PURE__ */ new Set();
+    const usedNamesByFile = /* @__PURE__ */ new Map();
+    for (const site of project.callSites) {
+      if (site.symbol?.valueDeclaration) {
+        usedDeclarations.add(site.symbol.valueDeclaration);
+      }
+      let files = usedNamesByFile.get(site.calleeName);
+      if (!files) {
+        files = /* @__PURE__ */ new Set();
+        usedNamesByFile.set(site.calleeName, files);
+      }
+      files.add(site.file);
+    }
+    for (const imp of project.imports) {
+      let files = usedNamesByFile.get(imp.importedName);
+      if (!files) {
+        files = /* @__PURE__ */ new Set();
+        usedNamesByFile.set(imp.importedName, files);
+      }
+      files.add(imp.file);
+    }
+    const importedClassNames = buildImportedClassNames(project);
+    for (const fn of project.functions.getAll()) {
+      if (!fn.exported) continue;
+      if (isEntryPoint(fn.file)) continue;
+      if (fn.implementsInterface) continue;
+      if (fn.className && isClassImported(fn.className, fn.file, importedClassNames)) continue;
+      if (fn.symbol?.valueDeclaration && usedDeclarations.has(fn.symbol.valueDeclaration)) continue;
+      const nameUsers = usedNamesByFile.get(fn.name);
+      if (nameUsers) {
+        const hasExternalUser = [...nameUsers].some((f) => f !== fn.file);
+        if (hasExternalUser) continue;
+      }
+      diagnostics.push({
+        ruleId: this.id,
+        severity: this.severity,
+        message: `Exported function "${fn.name}" has no usages in the project`,
+        file: fn.file,
+        line: fn.line,
+        column: 1
+      });
+    }
+    return diagnostics;
+  }
+};
+function isEntryPoint(file) {
+  if (/\/index\.[cm]?[jt]sx?$/.test(file)) return true;
+  if (/\/bin\//.test(file)) return true;
+  return false;
+}
+function buildImportedClassNames(project) {
+  const map = /* @__PURE__ */ new Map();
+  for (const imp of project.imports) {
+    let files = map.get(imp.importedName);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      map.set(imp.importedName, files);
+    }
+    files.add(imp.file);
+  }
+  return map;
+}
+function isClassImported(className, declFile, importedNames) {
+  const importers = importedNames.get(className);
+  if (!importers) return false;
+  return [...importers].some((f) => f !== declFile);
+}
+
+// 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/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;
+  }
+};
+
 // src/rules/index.ts
 var allRules = [
   noEmptyCatch,
@@ -976,7 +1227,7 @@ var allRules = [
   noNullTernaryNormalization,
   noAnyCast,
   noExplicitAnyAnnotation,
-  noInlineTypeInParams,
+  duplicateInlineTypeInParams,
   noTypeAssertion,
   noRedundantExistenceGuard,
   preferDefaultParamValue,
@@ -989,21 +1240,108 @@ var allRules = [
   explicitNullArg,
   duplicateFunctionName,
   duplicateTypeName,
-  noDynamicImport
+  duplicateConstantDeclaration,
+  noDynamicImport,
+  nearDuplicateFunction,
+  trivialWrapper,
+  unusedExport,
+  duplicateFile,
+  duplicateStatementSequence
 ];
+var ruleMetadata = {
+  "no-any-cast": { category: "type-evasion", tags: ["safety"] },
+  "no-explicit-any-annotation": { category: "type-evasion", tags: ["safety"] },
+  "no-type-assertion": { category: "type-evasion", tags: ["safety"] },
+  "no-ts-ignore": { category: "type-evasion", tags: ["safety"] },
+  "no-optional-property-access": { category: "defensive-code", tags: ["type-aware"] },
+  "no-optional-element-access": { category: "defensive-code", tags: ["type-aware"] },
+  "no-optional-call": { category: "defensive-code", tags: ["type-aware"] },
+  "no-nullish-coalescing": { category: "defensive-code", tags: ["type-aware"] },
+  "no-logical-or-fallback": { category: "defensive-code", tags: ["type-aware"] },
+  "no-null-ternary-normalization": { category: "defensive-code", tags: ["type-aware"] },
+  "no-non-null-assertion": { category: "defensive-code", tags: ["type-aware"] },
+  "no-double-negation-coercion": { category: "defensive-code", tags: ["readability"] },
+  "no-redundant-existence-guard": { category: "defensive-code", tags: ["type-aware"] },
+  "no-empty-catch": { category: "error-handling", tags: ["safety"] },
+  "no-catch-return": { category: "error-handling", tags: ["safety"] },
+  "no-error-rewrap": { category: "error-handling", tags: ["safety"] },
+  "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"] },
+  "duplicate-type-declaration": { category: "cross-file", tags: ["duplicate"] },
+  "duplicate-type-name": { category: "cross-file", tags: ["duplicate"] },
+  "duplicate-function-declaration": { category: "cross-file", tags: ["duplicate"] },
+  "duplicate-function-name": { category: "cross-file", tags: ["duplicate"] },
+  "duplicate-constant-declaration": { category: "cross-file", tags: ["duplicate"] },
+  "optional-arg-always-used": { category: "cross-file", tags: ["api"] },
+  "explicit-null-arg": { category: "cross-file", tags: ["api"] },
+  "no-dynamic-import": { category: "imports", tags: ["safety"] },
+  "near-duplicate-function": { category: "cross-file", tags: ["duplicate"] },
+  "trivial-wrapper": { category: "cross-file", tags: ["duplicate"] },
+  "unused-export": { category: "cross-file", tags: ["api"] },
+  "duplicate-file": { category: "cross-file", tags: ["duplicate"] },
+  "duplicate-statement-sequence": { category: "cross-file", tags: ["duplicate"] }
+};
+function getRuleMetadata(ruleId) {
+  const metadata = ruleMetadata[ruleId];
+  if (metadata !== void 0) return metadata;
+  return { category: "cross-file", tags: [] };
+}
 
-// 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/scan/config.ts
+var BUILTIN_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/.git/**",
+  "**/*.d.ts",
+  "**/*.d.cts",
+  "**/*.d.mts"
+];
+var GENERATED_IGNORE = [
+  "**/*.gen.*",
+  "**/*.generated.*"
+];
+var DEFAULT_FAIL_ON = "info";
+function resolveScanConfig(options) {
+  const paths = options.paths.length > 0 ? options.paths : ["."];
+  const ignore2 = [...BUILTIN_IGNORE, ...GENERATED_IGNORE, ...options.ignore ?? []];
+  return {
+    paths,
+    strict: options.strict ?? false,
+    rules: options.rules ? [...options.rules] : null,
+    ignore: ignore2,
+    rulePolicy: toRulePolicyEntries(options.rulePolicy),
+    showSeverities: normalizeSeveritySet(options.showSeverities),
+    failOn: options.failOn ?? DEFAULT_FAIL_ON,
+    useGitIgnore: options.useGitIgnore ?? true
+  };
+}
+function toRulePolicyEntries(policy) {
+  if (policy === void 0) return [];
+  if (Array.isArray(policy)) return [...policy];
+  const entries = [];
+  for (const [selector, severity] of Object.entries(policy)) {
+    entries.push({ selector, severity });
+  }
+  return entries;
+}
+function normalizeSeveritySet(levels) {
+  if (levels === void 0 || levels.length === 0) return null;
+  return new Set(levels);
+}
+function isRulePolicySeverity(value) {
+  return value === "off" || value === "info" || value === "warning" || value === "error";
+}
+function isSeverity(value) {
+  return value === "info" || value === "warning" || value === "error";
+}
+function isFailOn(value) {
+  return value === "none" || isSeverity(value);
 }
 
 // src/collect/index.ts
-import * as ts26 from "typescript";
-import "fs";
+import * as ts27 from "typescript";
+import { createHash as createHash2 } from "crypto";
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
@@ -1033,18 +1371,60 @@ function normalizeTypeNode(node, 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();
+  const normalized = stripComments(node.getText(sourceFile));
   return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
 }
+function bodyTextLength(node, sourceFile) {
+  return stripComments(node.getText(sourceFile)).length;
+}
+function stripComments(text) {
+  return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+function normalizeBody(node, sourceFile, paramNames) {
+  let text = node.getText(sourceFile);
+  text = text.replace(/\/\/[^\n]*/g, "");
+  text = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  text = text.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
+  text = text.replace(/'(?:[^'\\]|\\.)*'/g, '"__STR__"');
+  text = text.replace(/`(?:[^`\\]|\\.)*`/g, '"__STR__"');
+  text = text.replace(/\b\d+(?:\.\d+)?\b/g, "__NUM__");
+  for (let i = 0; i < paramNames.length; i++) {
+    const name = paramNames[i];
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    text = text.replace(new RegExp(`\\b${escaped}\\b`, "g"), `$${i}`);
+  }
+  text = text.replace(/\bthis\./g, "$_.");
+  text = text.replace(/\$\d+\./g, "$_.");
+  text = text.replace(/\s+/g, " ").trim();
+  return text;
+}
+function normalizeText(text) {
+  let t = text.replace(/\/\/[^\n]*/g, "");
+  t = t.replace(/\/\*[\s\S]*?\*\//g, "");
+  t = t.replace(/"(?:[^"\\]|\\.)*"/g, '"__STR__"');
+  t = t.replace(/'(?:[^'\\]|\\.)*'/g, '"__STR__"');
+  t = t.replace(/`(?:[^`\\]|\\.)*`/g, '"__STR__"');
+  t = t.replace(/\b\d+(?:\.\d+)?\b/g, "__NUM__");
+  t = t.replace(/\bthis\./g, "$_.");
+  t = t.replace(/\s+/g, " ").trim();
+  return t;
+}
+function hashText(text) {
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function hashFunctionBodyNormalized(node, sourceFile, paramNames) {
+  const text = normalizeBody(node, sourceFile, paramNames);
+  return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function normalizedBodyTextLength(node, sourceFile, paramNames) {
+  return normalizeBody(node, sourceFile, paramNames).length;
+}
 
-// src/collect/type-registry.ts
-var TypeRegistry = class {
+// src/collect/base-registry.ts
+var BaseRegistry = 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 };
+  addEntry(entry, hash) {
     this.entries.push(entry);
     let list = this.byHash.get(hash);
     if (list === void 0) {
@@ -1059,81 +1439,169 @@ var TypeRegistry = class {
   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);
+};
+var DualHashRegistry = class extends BaseRegistry {
+  bySecondaryHash = /* @__PURE__ */ new Map();
+  addWithSecondary(entry, primaryHash, secondaryHash) {
+    this.addEntry(entry, primaryHash);
+    let list = this.bySecondaryHash.get(secondaryHash);
+    if (list === void 0) {
+      list = [];
+      this.bySecondaryHash.set(secondaryHash, list);
     }
-    return [...byName.values()].filter((group) => {
-      if (group.length < 2) return false;
-      const files = new Set(group.map((e) => e.file));
-      return files.size > 1;
-    });
+    list.push(entry);
+  }
+  getSecondaryDuplicateGroups() {
+    return [...this.bySecondaryHash.values()].filter((group) => group.length > 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);
+// src/collect/type-registry.ts
+var TypeRegistry = class extends BaseRegistry {
+  add(name, file, line, typeNode, sourceFile, exported) {
+    const hash = hashTypeShape(typeNode, sourceFile);
+    const entry = { name, file, line, hash, node: typeNode, exported };
+    this.addEntry(entry, hash);
+  }
+  getNameCollisionGroups() {
+    return getExportedNameCollisions(this.entries);
+  }
+};
+function getExportedNameCollisions(entries) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.exported) continue;
+    let list = byName.get(entry.name);
     if (list === void 0) {
       list = [];
-      this.byHash.set(entry.hash, list);
+      byName.set(entry.name, list);
     }
     list.push(entry);
   }
-  getDuplicateGroups() {
-    return [...this.byHash.values()].filter((group) => group.length > 1);
+  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 extends DualHashRegistry {
+  add(entry) {
+    this.addWithSecondary(entry, entry.hash, entry.normalizedHash);
   }
-  getAll() {
-    return this.entries;
+  getNearDuplicateGroups() {
+    return this.getSecondaryDuplicateGroups().filter((group) => {
+      const hashes = new Set(group.map((e) => e.hash));
+      return hashes.size > 1;
+    });
   }
   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;
-    });
+    return getExportedNameCollisions(this.entries);
   }
 };
 
+// src/collect/constant-registry.ts
+var ConstantRegistry = class extends BaseRegistry {
+  add(entry) {
+    this.addEntry(entry, entry.valueHash);
+  }
+};
+
+// src/collect/statement-sequence-registry.ts
+var StatementSequenceRegistry = class extends DualHashRegistry {
+  add(entry) {
+    this.addWithSecondary(entry, entry.hash, entry.normalizedHash);
+  }
+  getNormalizedDuplicateGroups() {
+    return this.getSecondaryDuplicateGroups();
+  }
+};
+
+// src/collect/inline-type-registry.ts
+var InlineParamTypeRegistry = class extends BaseRegistry {
+  add(file, line, typeNode, sourceFile) {
+    const hash = hashTypeShape(typeNode, sourceFile);
+    const typeText = typeNode.getText(sourceFile).replace(/\s+/g, " ").trim();
+    this.addEntry({ file, line, hash, typeText, node: typeNode }, hash);
+  }
+};
+
+// src/typecheck/walk.ts
+import * as ts26 from "typescript";
+function buildContext(rule, sourceFile, checker, source, filename, diagnostics) {
+  return {
+    filename,
+    source,
+    sourceFile,
+    checker,
+    report(node, message) {
+      const { line, character } = ts26.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 } = ts26.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/collect/index.ts
-function collectProject(program) {
+function collectProject(program, tsRules) {
   const checker = program.getTypeChecker();
   const types = new TypeRegistry();
   const functions = new FunctionRegistry();
+  const constants = new ConstantRegistry();
   const callSites = [];
   const imports = [];
+  const statementSequences = new StatementSequenceRegistry();
+  const inlineParamTypes = new InlineParamTypeRegistry();
   const fileMap = /* @__PURE__ */ new Map();
+  const diagnostics = [];
   for (const sourceFile of program.getSourceFiles()) {
     let visit2 = function(node) {
       collectTypes(node, file, sourceFile, types);
       collectFunctions(node, file, sourceFile, checker, functions);
+      collectConstants(node, file, sourceFile, constants);
       collectCallSites(node, file, sourceFile, checker, callSites);
+      collectStatementSequences(node, file, sourceFile, statementSequences);
+      collectInlineParamTypes(node, file, sourceFile, inlineParamTypes);
       collectImports(node, file, imports);
-      ts26.forEachChild(node, visit2);
+      if (ruleContexts) {
+        for (const { rule, ctx } of ruleContexts) {
+          rule.visit(node, ctx);
+        }
+      }
+      ts27.forEachChild(node, visit2);
     };
     var visit = visit2;
     const file = sourceFile.fileName;
@@ -1142,48 +1610,166 @@ function collectProject(program) {
     const source = sourceFile.getFullText();
     const comments = collectAllComments(sourceFile);
     fileMap.set(file, { source, sourceFile, comments });
-    ts26.forEachChild(sourceFile, visit2);
+    const ruleContexts = tsRules?.map((rule) => ({
+      rule,
+      ctx: buildContext(rule, sourceFile, checker, source, file, diagnostics)
+    }));
+    ts27.forEachChild(sourceFile, visit2);
+  }
+  const fileHashes = /* @__PURE__ */ new Map();
+  for (const [file, { source }] of fileMap) {
+    const normalized = source.replace(/\s+/g, " ").trim();
+    const hash = createHash2("sha256").update(normalized).digest("hex").slice(0, 16);
+    let list = fileHashes.get(hash);
+    if (list === void 0) {
+      list = [];
+      fileHashes.set(hash, list);
+    }
+    list.push(file);
   }
-  return { types, functions, callSites, imports, files: fileMap };
+  return { index: { types, functions, constants, callSites, imports, files: fileMap, fileHashes, statementSequences, inlineParamTypes }, diagnostics };
+}
+function hasNonPublicModifier(node) {
+  if (!ts27.canHaveModifiers(node)) return false;
+  const mods = ts27.getModifiers(node);
+  if (mods === void 0) return false;
+  return mods.some(
+    (m) => m.kind === ts27.SyntaxKind.PrivateKeyword || m.kind === ts27.SyntaxKind.ProtectedKeyword
+  );
 }
 function isExported(node) {
-  if (!ts26.canHaveModifiers(node)) return false;
-  const mods = ts26.getModifiers(node);
+  if (!ts27.canHaveModifiers(node)) return false;
+  const mods = ts27.getModifiers(node);
   if (mods === void 0) return false;
-  return mods.some((m) => m.kind === ts26.SyntaxKind.ExportKeyword);
+  return mods.some((m) => m.kind === ts27.SyntaxKind.ExportKeyword);
 }
 function collectTypes(node, file, sourceFile, registry) {
-  if (ts26.isTypeAliasDeclaration(node)) {
-    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts27.isTypeAliasDeclaration(node)) {
+    const line = ts27.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;
+  if (ts27.isInterfaceDeclaration(node)) {
+    const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     registry.add(node.name.text, file, line, node, sourceFile, isExported(node));
   }
 }
+function isConstantValue(node) {
+  if (ts27.isStringLiteral(node)) return true;
+  if (ts27.isNumericLiteral(node)) return true;
+  if (ts27.isNoSubstitutionTemplateLiteral(node)) return true;
+  if (ts27.isPrefixUnaryExpression(node)) return isConstantValue(node.operand);
+  if (ts27.isBinaryExpression(node)) return isConstantValue(node.left) && isConstantValue(node.right);
+  return false;
+}
+function collectConstants(node, file, sourceFile, registry) {
+  if (!ts27.isVariableStatement(node)) return;
+  if (!(node.declarationList.flags & ts27.NodeFlags.Const)) return;
+  const exported = isExported(node);
+  for (const decl of node.declarationList.declarations) {
+    if (!decl.initializer || !ts27.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 = ts27.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 = ts27.getLineAndCharacterOfPosition(sourceFile, lineNode.getStart(sourceFile)).line + 1;
+  const params = extractParams(parameters, sourceFile);
+  const paramNames = params.map((p) => p.name);
+  const hash = hashFunctionBody(body, sourceFile);
+  const normalizedHash = hashFunctionBodyNormalized(body, sourceFile, paramNames);
+  const bodyLength = bodyTextLength(body, sourceFile);
+  const normalizedBodyLength = normalizedBodyTextLength(body, sourceFile, paramNames);
+  return {
+    name,
+    file,
+    line,
+    hash,
+    normalizedHash,
+    params,
+    node: extra.node ?? body,
+    exported: extra.exported ?? false,
+    bodyLength,
+    normalizedBodyLength,
+    ...extra
+  };
+}
 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)) {
+  if (ts27.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 (ts27.isVariableStatement(node)) {
     const exported = isExported(node);
     for (const decl of node.declarationList.declarations) {
-      if (decl.initializer && ts26.isArrowFunction(decl.initializer) && ts26.isIdentifier(decl.name)) {
+      if (decl.initializer && ts27.isArrowFunction(decl.initializer) && ts27.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 });
+        registry.add(buildFunctionEntry(arrow.body, arrow.parameters, sourceFile, file, decl, decl.name.text, {
+          exported,
+          symbol: checker.getSymbolAtLocation(decl.name),
+          node: arrow
+        }));
+      }
+      if (decl.initializer && ts27.isFunctionExpression(decl.initializer) && ts27.isIdentifier(decl.name)) {
+        const fn = decl.initializer;
+        if (fn.body) {
+          registry.add(buildFunctionEntry(fn.body, fn.parameters, sourceFile, file, decl, decl.name.text, {
+            exported,
+            symbol: checker.getSymbolAtLocation(decl.name),
+            node: fn
+          }));
+        }
       }
     }
   }
+  if (ts27.isPropertyAssignment(node) && (ts27.isIdentifier(node.name) || ts27.isStringLiteral(node.name))) {
+    const init = node.initializer;
+    const propName = node.name.text;
+    if (ts27.isArrowFunction(init)) {
+      registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
+    }
+    if (ts27.isFunctionExpression(init) && init.body) {
+      registry.add(buildFunctionEntry(init.body, init.parameters, sourceFile, file, node, propName, { node: init }));
+    }
+  }
+  if (ts27.isArrowFunction(node) || ts27.isFunctionExpression(node)) {
+    const parent = node.parent;
+    if (ts27.isVariableDeclaration(parent) && ts27.isIdentifier(parent.name)) {
+    } else if (ts27.isPropertyAssignment(parent)) {
+    } else {
+      const body = ts27.isArrowFunction(node) ? node.body : node.body;
+      if (body) {
+        const MIN_ANON_BODY = 64;
+        if (bodyTextLength(body, sourceFile) >= MIN_ANON_BODY) {
+          const name = deriveAnonymousName(node, sourceFile);
+          registry.add(buildFunctionEntry(body, node.parameters, sourceFile, file, node, name, { node }));
+        }
+      }
+    }
+  }
+  if (ts27.isMethodDeclaration(node) && node.body && ts27.isIdentifier(node.name)) {
+    const parent = node.parent;
+    if (ts27.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 === ts27.SyntaxKind.ImplementsKeyword
+      ) ?? false;
+      registry.add(buildFunctionEntry(node.body, node.parameters, sourceFile, file, node, name, {
+        exported: isExported(parent),
+        symbol: checker.getSymbolAtLocation(node.name),
+        node,
+        className,
+        implementsInterface
+      }));
+    }
+  }
 }
 function extractParams(parameters, sourceFile) {
   return parameters.map((p) => {
@@ -1194,8 +1780,29 @@ function extractParams(parameters, sourceFile) {
     return { name, optional, hasDefault, typeText };
   });
 }
+function deriveAnonymousName(node, sourceFile) {
+  const parent = node.parent;
+  const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  if (ts27.isCallExpression(parent)) {
+    const grandparent = parent.parent;
+    if (ts27.isPropertyAssignment(grandparent) && ts27.isIdentifier(grandparent.name)) {
+      return grandparent.name.text;
+    }
+    let calleeName = null;
+    if (ts27.isIdentifier(parent.expression)) {
+      calleeName = parent.expression.text;
+    } else if (ts27.isPropertyAccessExpression(parent.expression)) {
+      calleeName = parent.expression.name.text;
+    }
+    if (calleeName) {
+      const argIndex = parent.arguments.indexOf(node);
+      if (argIndex >= 0) return `${calleeName}.$arg${argIndex}`;
+    }
+  }
+  return `<anonymous>:${line}`;
+}
 function collectImports(node, file, imports) {
-  if (ts26.isImportDeclaration(node) && ts26.isStringLiteral(node.moduleSpecifier)) {
+  if (ts27.isImportDeclaration(node) && ts27.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
     const clause = node.importClause;
     if (!clause) return;
@@ -1207,7 +1814,7 @@ function collectImports(node, file, imports) {
         source: moduleSource
       });
     }
-    if (clause.namedBindings && ts26.isNamedImports(clause.namedBindings)) {
+    if (clause.namedBindings && ts27.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         imports.push({
           file,
@@ -1218,9 +1825,9 @@ function collectImports(node, file, imports) {
       }
     }
   }
-  if (ts26.isExportDeclaration(node) && node.moduleSpecifier && ts26.isStringLiteral(node.moduleSpecifier)) {
+  if (ts27.isExportDeclaration(node) && node.moduleSpecifier && ts27.isStringLiteral(node.moduleSpecifier)) {
     const moduleSource = node.moduleSpecifier.text;
-    if (node.exportClause && ts26.isNamedExports(node.exportClause)) {
+    if (node.exportClause && ts27.isNamedExports(node.exportClause)) {
       for (const el of node.exportClause.elements) {
         imports.push({
           file,
@@ -1232,20 +1839,52 @@ function collectImports(node, file, imports) {
     }
   }
 }
+function collectStatementSequences(node, file, sourceFile, registry) {
+  if (!ts27.isBlock(node)) return;
+  const stmts = node.statements;
+  const n = stmts.length;
+  if (n < 3) return;
+  const MAX_WINDOW = Math.min(n, 5);
+  for (let size = 3; size <= MAX_WINDOW; size++) {
+    for (let start = 0; start + size <= n; start++) {
+      const window = stmts.slice(start, start + size);
+      const texts = window.map((s) => s.getText(sourceFile));
+      const joined = texts.join("\n");
+      const normalized = normalizeText(joined);
+      if (normalized.length < 128) continue;
+      const hash = hashText(joined.replace(/\s+/g, " ").trim());
+      const normalizedHash = hashText(normalized);
+      const firstStmt = window[0];
+      const lastStmt = window[window.length - 1];
+      if (firstStmt === void 0 || lastStmt === void 0) continue;
+      const line = ts27.getLineAndCharacterOfPosition(sourceFile, firstStmt.getStart(sourceFile)).line + 1;
+      const endLine = ts27.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 (!ts27.isTypeLiteralNode(node)) return;
+  const parent = node.parent;
+  if (!parent || !ts27.isParameter(parent)) return;
+  if (parent.type !== node) return;
+  const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+  registry.add(file, line, node, sourceFile);
+}
 function collectCallSites(node, file, sourceFile, checker, sites) {
-  if (!ts26.isCallExpression(node)) return;
+  if (!ts27.isCallExpression(node)) return;
   let calleeName = null;
-  if (ts26.isIdentifier(node.expression)) {
+  if (ts27.isIdentifier(node.expression)) {
     calleeName = node.expression.text;
-  } else if (ts26.isPropertyAccessExpression(node.expression)) {
+  } else if (ts27.isPropertyAccessExpression(node.expression)) {
     calleeName = node.expression.name.text;
   }
   if (calleeName) {
-    const line = ts26.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
+    const line = ts27.getLineAndCharacterOfPosition(sourceFile, node.getStart(sourceFile)).line + 1;
     let symbol;
     try {
       symbol = checker.getSymbolAtLocation(node.expression);
-      if (symbol && symbol.flags & ts26.SymbolFlags.Alias) {
+      if (symbol && symbol.flags & ts27.SymbolFlags.Alias) {
         symbol = checker.getAliasedSymbol(symbol);
       }
     } catch {
@@ -1265,12 +1904,12 @@ function collectAllComments(sourceFile) {
   const source = sourceFile.getFullText();
   const seen = /* @__PURE__ */ new Set();
   function visit(node) {
-    const leading = ts26.getLeadingCommentRanges(source, node.getFullStart());
+    const leading = ts27.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;
+        const isLine = r.kind === ts27.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1279,12 +1918,12 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    const trailing = ts26.getTrailingCommentRanges(source, node.getEnd());
+    const trailing = ts27.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;
+        const isLine = r.kind === ts27.SyntaxKind.SingleLineCommentTrivia;
         comments.push({
           type: isLine ? "Line" : "Block",
           value: source.slice(r.pos + 2, isLine ? r.end : r.end - 2),
@@ -1293,34 +1932,34 @@ function collectAllComments(sourceFile) {
         });
       }
     }
-    ts26.forEachChild(node, visit);
+    ts27.forEachChild(node, visit);
   }
   visit(sourceFile);
   return comments;
 }
 
 // src/typecheck/program.ts
-import * as ts27 from "typescript";
+import * as ts28 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");
+    configPath = ts28.findConfigFile(dirname2(files[0]), ts28.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({
+    const configFile = ts28.readConfigFile(configPath, ts28.sys.readFile);
+    const parsed = ts28.parseJsonConfigFileContent(configFile.config, ts28.sys, dirname2(configPath));
+    return ts28.createProgram({
       rootNames: files,
       options: { ...parsed.options, skipLibCheck: true }
     });
   }
-  return ts27.createProgram({
+  return ts28.createProgram({
     rootNames: files,
     options: {
-      target: ts27.ScriptTarget.ESNext,
-      module: ts27.ModuleKind.ESNext,
-      moduleResolution: ts27.ModuleResolutionKind.Bundler,
+      target: ts28.ScriptTarget.ESNext,
+      module: ts28.ModuleKind.ESNext,
+      moduleResolution: ts28.ModuleResolutionKind.Bundler,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -1328,166 +1967,72 @@ function createProgramFromFiles(files) {
   });
 }
 
-// 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 = [];
+// src/scan/analyze.ts
+function analyzeFiles(files, rules) {
+  const tsRules = rules.filter(isTSRule);
+  const crossFileRules = rules.filter((r) => !isTSRule(r));
   const program = files.length > 0 ? createProgramFromFiles(files) : null;
-  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);
+  if (!program) return [];
+  const { index, diagnostics } = collectProject(program, tsRules);
+  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);
   }
+  return dedupeDiagnostics(diagnostics);
+}
+function dedupeDiagnostics(diagnostics) {
   const seen = /* @__PURE__ */ new Set();
   const deduped = [];
-  for (const d of diagnostics) {
-    const key = `${d.file}:${d.line}:${d.ruleId}`;
+  for (const diagnostic of diagnostics) {
+    const key = `${diagnostic.file}:${diagnostic.line}:${diagnostic.ruleId}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    deduped.push(d);
-  }
-  if (options.strict) {
-    for (const d of deduped) {
-      d.severity = "error";
-    }
+    deduped.push(diagnostic);
   }
-  return { diagnostics: deduped, fileCount: files.length };
+  return deduped;
 }
 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);
+  for (const comment of comments) {
+    const endLine = lineAt(source, comment.end);
     let list = byEndLine.get(endLine);
     if (list === void 0) {
       list = [];
       byEndLine.set(endLine, list);
     }
-    list.push(c);
+    list.push(comment);
   }
-  for (const d of diagnostics) {
-    const inline = findInlineComment(d.line, byEndLine);
+  for (const diagnostic of diagnostics) {
+    const inline = findInlineComment(diagnostic.line, byEndLine);
     if (inline !== null) {
-      d.annotation = inline;
+      diagnostic.annotation = inline;
       continue;
     }
-    const above = collectAnnotation(d.line - 1, byEndLine, source);
-    if (above !== null) d.annotation = above;
+    const above = collectAnnotation(diagnostic.line - 1, byEndLine, source);
+    if (above !== null) diagnostic.annotation = above;
   }
 }
-function findInlineComment(diagLine, byEndLine) {
-  const commentsOnLine = byEndLine.get(diagLine);
+function lastCommentOnLine(line, byEndLine) {
+  const commentsOnLine = byEndLine.get(line);
   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;
+  return commentsOnLine.at(-1) ?? null;
+}
+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;
   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 comment = lastCommentOnLine(commentEndLine, byEndLine);
+  if (comment === null) return null;
+  if (comment.type === "Block") return cleanBlockComment(comment.value);
   const lines = [comment.value.trim()];
   let prevLine = commentEndLine - 1;
   for (; ; ) {
@@ -1512,8 +2057,145 @@ function lineAt(source, offset) {
   return line;
 }
 
+// src/scan/discover.ts
+import fg from "fast-glob";
+import ignore from "ignore";
+import { existsSync, readFileSync } from "fs";
+import { relative, resolve as resolve2, sep } from "path";
+async function discoverFiles(config) {
+  const globs = expandGlobs(config.paths);
+  const discoveredFiles = await fg(globs, {
+    ignore: config.ignore,
+    absolute: true
+  });
+  if (!config.useGitIgnore) return discoveredFiles;
+  return applyGitIgnore(discoveredFiles);
+}
+function expandGlobs(paths) {
+  return paths.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;
+  });
+}
+function applyGitIgnore(files) {
+  const gitIgnorePath = resolve2(process.cwd(), ".gitignore");
+  if (!existsSync(gitIgnorePath)) return files;
+  const matcher = ignore().add(readFileSync(gitIgnorePath, "utf8"));
+  return files.filter((file) => {
+    const rel = relative(process.cwd(), file);
+    if (rel.startsWith("..")) return true;
+    const normalized = rel.split(sep).join("/");
+    return !matcher.ignores(normalized);
+  });
+}
+
+// src/scan/policy.ts
+function buildRuleDescriptors(rules) {
+  return rules.map((rule) => {
+    const metadata = getRuleMetadata(rule.id);
+    return {
+      rule,
+      category: metadata.category,
+      tags: metadata.tags
+    };
+  });
+}
+function resolveActiveRules(descriptors, config) {
+  const selectedRules = config.rules ? new Set(config.rules) : null;
+  const active = [];
+  for (const descriptor of descriptors) {
+    if (selectedRules && !selectedRules.has(descriptor.rule.id)) continue;
+    const resolvedSeverity = resolveRuleSeverity(descriptor, config);
+    if (resolvedSeverity === "off") continue;
+    if (descriptor.rule.severity === resolvedSeverity) {
+      active.push(descriptor.rule);
+      continue;
+    }
+    active.push({ ...descriptor.rule, severity: resolvedSeverity });
+  }
+  return active;
+}
+function resolveRuleSeverity(descriptor, config) {
+  let severity = descriptor.rule.severity;
+  for (const entry of config.rulePolicy) {
+    if (!matchesSelector(descriptor, entry.selector)) continue;
+    severity = entry.severity;
+  }
+  if (severity === "off") return "off";
+  if (config.strict) return "error";
+  return severity;
+}
+function matchesSelector(descriptor, selector) {
+  if (selector.startsWith("category:")) {
+    return descriptor.category === selector.slice("category:".length);
+  }
+  if (selector.startsWith("tag:")) {
+    return descriptor.tags.includes(selector.slice("tag:".length));
+  }
+  if (selector === descriptor.rule.id) return true;
+  if (!selector.includes("*")) return false;
+  const regex = new RegExp(`^${escapeRegex(selector).replaceAll("\\*", ".*")}$`);
+  return regex.test(descriptor.rule.id);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function finalizeScanResult(diagnostics, fileCount, config) {
+  const visibleDiagnostics = config.showSeverities ? diagnostics.filter((d) => config.showSeverities?.has(d.severity)) : diagnostics;
+  return {
+    diagnostics,
+    visibleDiagnostics,
+    fileCount,
+    exitCode: computeExitCode(diagnostics, config.failOn)
+  };
+}
+function toScanResult(execution) {
+  return {
+    diagnostics: execution.diagnostics,
+    fileCount: execution.fileCount
+  };
+}
+function computeExitCode(diagnostics, failOn) {
+  if (failOn === "none") return 0;
+  const hasError = diagnostics.some((d) => d.severity === "error");
+  const hasWarning = diagnostics.some((d) => d.severity === "warning");
+  const hasInfo = diagnostics.some((d) => d.severity === "info");
+  if (failOn === "error") return hasError ? 2 : 0;
+  if (failOn === "warning") {
+    if (hasError) return 2;
+    return hasWarning ? 1 : 0;
+  }
+  if (hasError) return 2;
+  if (hasWarning || hasInfo) return 1;
+  return 0;
+}
+
+// src/engine.ts
+async function executeScan(options) {
+  const config = resolveScanConfig(options);
+  const files = await discoverFiles(config);
+  const descriptors = buildRuleDescriptors(allRules);
+  const activeRules = resolveActiveRules(descriptors, config);
+  const diagnostics = analyzeFiles(files, activeRules);
+  return finalizeScanResult(diagnostics, files.length, config);
+}
+async function scan(options) {
+  const execution = await executeScan(options);
+  return toScanResult(execution);
+}
+
 export {
   allRules,
+  getRuleMetadata,
+  toRulePolicyEntries,
+  isRulePolicySeverity,
+  isSeverity,
+  isFailOn,
+  executeScan,
   scan
 };
-//# sourceMappingURL=chunk-YYX4R25B.js.map
+//# sourceMappingURL=chunk-5GVEUYZF.js.map