oxlint-plugin-arch 0.7.0 → 0.9.0

package/dist/rules/dillon-anti-slop/index.js

@@ -594,7 +594,1039 @@ var noKnownValueWideningRule = defineRule3({
 
 // src/rules/dillon-anti-slop/rules/no-module-mocking.ts
 import { defineRule as defineRule4 } from "@oxlint/plugins";
+
+// src/utils/helpers/ast.ts
+var astVisitSkip = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
+function astIsNode(value) {
+  return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
+}
+function astVisit(node, ancestors, callback) {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      astVisit(child, ancestors, callback);
+    }
+    return;
+  }
+  if (!astIsNode(node)) {
+    return;
+  }
+  callback(node, ancestors);
+  ancestors.push(node);
+  for (const key in node) {
+    if (Object.hasOwn(node, key) && !astVisitSkip.has(key)) {
+      astVisit(Reflect.get(node, key), ancestors, callback);
+    }
+  }
+  ancestors.pop();
+}
+function astContainsJsx(node) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "JSXElement" || candidate.type === "JSXFragment") {
+      found = true;
+    }
+  });
+  return found;
+}
+function astNearestFunction(ancestors) {
+  return [...ancestors].reverse().find((node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+function astDirectReturnExpressions(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return [node.body];
+  }
+  const expressions = [];
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === "ReturnStatement" && candidate.argument && astNearestFunction(ancestors) === node) {
+      expressions.push(candidate.argument);
+    }
+  });
+  return expressions;
+}
+function astStaticMemberName(node) {
+  return !node.computed && node.property.type === "Identifier" ? node.property.name : undefined;
+}
+function astDottedName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type !== "MemberExpression") {
+    return;
+  }
+  const object = astDottedName(node.object);
+  const property = astStaticMemberName(node);
+  return object && property ? `${object}.${property}` : undefined;
+}
+function astCallName(node) {
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return node.callee.type === "MemberExpression" ? astStaticMemberName(node.callee) : undefined;
+}
+function astImportedCallAliases(program) {
+  const aliases = new Map;
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration") {
+      continue;
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier") {
+        continue;
+      }
+      const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+      if (imported !== specifier.local.name) {
+        aliases.set(specifier.local.name, imported);
+      }
+    }
+  }
+  return aliases;
+}
+function astResolvedCallName(node, aliases) {
+  const name = astCallName(node);
+  return name ? aliases.get(name) ?? name : undefined;
+}
+// src/utils/helpers/comments.ts
+var COMMENTS_DIRECTIVE = /^\s*(?:\/\s*<(?:reference\b|amd-[\w-]+\b)|@ts-(?:check|ignore|expect-error|nocheck)\b|(?:#|@)__(?:PURE|NO_SIDE_EFFECTS)__\b|@jsx(?:ImportSource|Runtime|Frag)?\b|@vite-ignore\b|(?:[#@]\s*)?sourceMappingURL=|(?:es|ox)lint-(?:disable|enable)|prettier-ignore|biome-ignore|[cv]8 ignore|istanbul ignore|webpack[A-Z])/;
+var COMMENTS_DISABLE_NEXT_LINE = /^(?:eslint|oxlint)-disable-next-line\b/;
+var COMMENTS_LEGAL_BLOCK = "\x00legal-block\x00";
+function commentsNormalizedValue(comment) {
+  const value = (comment.type === "Block" ? comment.value.replace(/^\s*\* ?/gm, "") : comment.value).trimStart();
+  return comment.type === "Block" && comment.value.startsWith("!") ? COMMENTS_LEGAL_BLOCK + value : value;
+}
+function commentsIsDirective(value) {
+  return value.startsWith(COMMENTS_LEGAL_BLOCK) || COMMENTS_DIRECTIVE.test(value);
+}
+function commentsIsDisableNextLine(value) {
+  return COMMENTS_DISABLE_NEXT_LINE.test(value);
+}
+function commentsIsWhy(value) {
+  return value.startsWith("Why: ");
+}
+function commentsIsJsdoc(source, comment) {
+  return comment.type === "Block" && source.startsWith("/**", comment.range[0]);
+}
+// src/utils/helpers/trivial.ts
+function trivialExpression(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return node.body;
+  }
+  if (!node.body || node.body.type !== "BlockStatement")
+    return null;
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
+  if (statements.length !== 1)
+    return null;
+  const statement = statements[0];
+  if (statement.type === "ReturnStatement")
+    return statement.argument;
+  return statement.type === "ExpressionStatement" ? statement.expression : null;
+}
+function trivialUnwrap(expression) {
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "ChainExpression") {
+    return trivialUnwrap(expression.expression);
+  }
+  return expression.type === "AwaitExpression" ? trivialUnwrap(expression.argument) : expression;
+}
+function trivialCallRoot(expression) {
+  if (expression.type === "Identifier")
+    return expression.name;
+  if (expression.type === "MemberExpression" && !expression.computed && !expression.optional) {
+    return trivialCallRoot(expression.object);
+  }
+  return;
+}
+function trivialIsForwarder(node, expression) {
+  const value = trivialUnwrap(expression);
+  if (value.type === "Literal")
+    return !("regex" in value);
+  if (value.type === "TemplateLiteral")
+    return value.expressions.length === 0;
+  if (value.type === "Identifier")
+    return true;
+  if (value.type !== "CallExpression" || value.optional)
+    return false;
+  const root = trivialCallRoot(value.callee);
+  if (!root || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const parameters = node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : []);
+  const arguments_ = value.arguments;
+  const receiver = value.callee.type === "MemberExpression" ? root : undefined;
+  const forwarded = parameters.filter((name) => name !== receiver);
+  return arguments_.length === forwarded.length && arguments_.every((argument, index) => argument.type === "Identifier" && argument.name === forwarded[index]);
+}
+
+// src/utils/helpers/declarations.ts
+function declarationsTopLevelUnexportedFunctions(program) {
+  return program.body.flatMap((statement) => {
+    if (statement.type === "FunctionDeclaration") {
+      return [{ name: statement.id?.name ?? "<anonymous>", node: statement }];
+    }
+    if (statement.type !== "VariableDeclaration") {
+      return [];
+    }
+    return statement.declarations.flatMap((item) => item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression" ? [{ name: item.id.type === "Identifier" ? item.id.name : "<anonymous>", node: item.init }] : []);
+  });
+}
+function declarationsFileLevelFunctionCandidates(program) {
+  const result = [];
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "FunctionDeclaration") {
+      result.push({ name: declaration.id?.name ?? "<anonymous>", node: declaration });
+      continue;
+    }
+    if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") {
+      continue;
+    }
+    for (const item of declaration.declarations) {
+      if (item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") {
+        result.push({
+          name: item.id.type === "Identifier" ? item.id.name : "<anonymous>",
+          node: declaration,
+          initializer: item.init
+        });
+      }
+    }
+  }
+  return result;
+}
+function declarationsIsObjectParam(node) {
+  if (node.type === "ObjectPattern") {
+    return true;
+  }
+  if (node.type === "TSParameterProperty") {
+    return declarationsIsObjectParam(node.parameter);
+  }
+  const annotation = node.typeAnnotation?.typeAnnotation;
+  return !annotation || annotation.type === "TSTypeReference" || annotation.type === "TSTypeLiteral" || annotation.type === "TSIntersectionType";
+}
+function declarationsFunctionName(node) {
+  if (node.type === "VariableDeclarator") {
+    return node.id.type === "Identifier" ? node.id.name : "<anonymous>";
+  }
+  return node.id?.name ?? "<anonymous>";
+}
+function declarationsIsRuntime(node) {
+  return node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration";
+}
+function declarationsRuntimeName(node) {
+  if (node.type === "VariableDeclaration") {
+    return node.declarations.map((item) => item.id.type === "Identifier" ? item.id.name : "<anonymous>").join(", ");
+  }
+  return node.id?.name ?? "<anonymous>";
+}
+function declarationsRuntimeKind(node) {
+  if (node.type === "ClassDeclaration") {
+    return "class";
+  }
+  if (node.type === "TSEnumDeclaration") {
+    return "enum";
+  }
+  if (node.type === "FunctionDeclaration") {
+    return "function";
+  }
+  return "variable";
+}
+function declarationsUnwrapExpression(node) {
+  if (node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression") {
+    return declarationsUnwrapExpression(node.expression);
+  }
+  if (node.type === "ChainExpression") {
+    return declarationsUnwrapExpression(node.expression);
+  }
+  return node.type === "AwaitExpression" && node.argument ? declarationsUnwrapExpression(node.argument) : node;
+}
+function declarationsIsTrivialExpression(node) {
+  const value = declarationsUnwrapExpression(node);
+  if (value.type === "Identifier" || value.type === "ThisExpression" || value.type === "MetaProperty" || value.type.endsWith("Literal")) {
+    return true;
+  }
+  if (value.type === "TemplateLiteral") {
+    return value.expressions.length === 0;
+  }
+  if (value.type === "MemberExpression" || value.type === "CallExpression" || value.type === "NewExpression" || value.type === "TaggedTemplateExpression") {
+    return true;
+  }
+  return value.type === "LogicalExpression" && declarationsIsTrivialExpression(value.left) && declarationsIsTrivialExpression(value.right);
+}
+function declarationsIsTrivialFunction(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return declarationsIsTrivialExpression(node.body);
+  }
+  if (!node.body || node.body.type !== "BlockStatement") {
+    return false;
+  }
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
+  if (statements.length === 0) {
+    return true;
+  }
+  if (statements.length > 1) {
+    return false;
+  }
+  const statement = statements[0];
+  if (statement.type === "ReturnStatement") {
+    return !statement.argument || declarationsIsTrivialExpression(statement.argument);
+  }
+  return statement.type === "ExpressionStatement" && declarationsIsTrivialExpression(statement.expression);
+}
+var declarationsKinds = ["function", "const", "let", "var", "class", "type", "interface", "enum"];
+function declarationsNamedKind(node, ancestors) {
+  if (node.type === "FunctionDeclaration") {
+    return "function";
+  }
+  if (node.type === "ClassDeclaration") {
+    return "class";
+  }
+  if (node.type === "TSTypeAliasDeclaration") {
+    return "type";
+  }
+  if (node.type === "TSInterfaceDeclaration") {
+    return "interface";
+  }
+  if (node.type === "TSEnumDeclaration") {
+    return "enum";
+  }
+  if (node.type !== "VariableDeclarator") {
+    return;
+  }
+  const declaration = ancestors.findLast((ancestor) => ancestor.type === "VariableDeclaration");
+  return declaration?.type === "VariableDeclaration" && (declaration.kind === "const" || declaration.kind === "let" || declaration.kind === "var") ? declaration.kind : undefined;
+}
+function declarationsCollectNamed(root, kinds) {
+  const allowed = kinds && kinds.length > 0 ? new Set(kinds) : null;
+  const result = [];
+  astVisit(root, [], (node, ancestors) => {
+    const kind = declarationsNamedKind(node, ancestors);
+    const name = node.type === "VariableDeclarator" && node.id.type === "Identifier" ? node.id.name : ("id" in node) && node.id && ("name" in node.id) ? node.id.name : undefined;
+    if (!kind || !name || allowed && !allowed.has(kind)) {
+      return;
+    }
+    if (node.type === "VariableDeclarator" && ancestors.some((ancestor) => ancestor.type === "ForStatement" || ancestor.type === "ForInStatement" || ancestor.type === "ForOfStatement")) {
+      return;
+    }
+    result.push({ name, node, kind });
+  });
+  return result;
+}
+function declarationsInsideForLoop(node) {
+  for (let current = node.parent;current; current = current.parent) {
+    if (current.type === "ForStatement" || current.type === "ForInStatement" || current.type === "ForOfStatement") {
+      return true;
+    }
+  }
+  return false;
+}
+function declarationsNamedFromNode(node) {
+  if (node.type === "VariableDeclarator") {
+    const kind2 = declarationsNamedKind(node, [node.parent]);
+    return kind2 && node.id.type === "Identifier" && !declarationsInsideForLoop(node) ? { name: node.id.name, node, kind: kind2 } : undefined;
+  }
+  const kind = declarationsNamedKind(node, []);
+  const name = "id" in node && node.id && "name" in node.id ? node.id.name : undefined;
+  return kind && name ? { name, node, kind } : undefined;
+}
+function declarationsCollectFunctions(root) {
+  return declarationsCollectNamed(root).flatMap((item) => {
+    if (item.node.type === "FunctionDeclaration") {
+      return [{ name: item.name, node: item.node }];
+    }
+    if (item.node.type === "VariableDeclarator" && (item.node.init?.type === "FunctionExpression" || item.node.init?.type === "ArrowFunctionExpression")) {
+      return [{ name: item.name, node: item.node.init }];
+    }
+    return [];
+  });
+}
+function declarationsPublicServiceMethods(program) {
+  return program.body.flatMap((statement) => {
+    if (statement.type !== "ExportNamedDeclaration" || statement.declaration?.type !== "VariableDeclaration" || statement.declaration.kind !== "const")
+      return [];
+    return statement.declaration.declarations.flatMap((binding) => {
+      if (binding.id.type !== "Identifier" || !binding.init)
+        return [];
+      const value = trivialUnwrap(binding.init);
+      if (value.type !== "ObjectExpression" || value.properties.length === 0)
+        return [];
+      const methods = value.properties.flatMap((property) => property.type === "Property" && property.method && property.kind === "init" && !property.computed && property.key.type === "Identifier" && property.value.type === "FunctionExpression" ? [{ name: property.key.name, node: property.value, binding }] : []);
+      return methods.length === value.properties.length ? methods : [];
+    });
+  });
+}
+// src/utils/helpers/exports.ts
+function moduleExportName(node) {
+  return node.type === "Identifier" ? node.name : node.value;
+}
+function declarationBindings(declaration) {
+  if (!declaration || declaration.type === "TSModuleDeclaration") {
+    return [];
+  }
+  if (declaration.type === "VariableDeclaration") {
+    return declaration.declarations.map((item) => ({
+      exportedName: item.id.type === "Identifier" ? item.id.name : "<anonymous>",
+      localName: item.id.type === "Identifier" ? item.id.name : undefined,
+      node: declaration,
+      declaration,
+      initializer: item.init,
+      typeOnly: false,
+      default: false,
+      reExport: false
+    }));
+  }
+  const name = declaration.id?.name ?? "<anonymous>";
+  return [
+    {
+      exportedName: name,
+      localName: declaration.id?.name,
+      node: declaration,
+      declaration,
+      typeOnly: declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSDeclareFunction",
+      default: false,
+      reExport: false
+    }
+  ];
+}
+function localBindings(program) {
+  const result = new Map;
+  for (const statement of program.body) {
+    if (statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration") {
+      continue;
+    }
+    if (statement.type.endsWith("Declaration")) {
+      for (const binding of declarationBindings(statement)) {
+        if (binding.localName) {
+          result.set(binding.localName, binding);
+        }
+      }
+    }
+  }
+  return result;
+}
+function exportsCollect(program) {
+  const locals = localBindings(program);
+  return program.body.flatMap((statement) => {
+    if (statement.type === "ExportAllDeclaration") {
+      return [
+        {
+          exportedName: "*",
+          node: statement,
+          typeOnly: statement.exportKind === "type",
+          default: false,
+          reExport: true
+        }
+      ];
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      if (statement.declaration.type === "Identifier") {
+        const local = locals.get(statement.declaration.name);
+        return [
+          {
+            ...local ?? {
+              exportedName: "default",
+              node: statement,
+              typeOnly: false,
+              default: true,
+              reExport: false
+            },
+            exportedName: "default",
+            localName: local?.localName ?? statement.declaration.name,
+            default: true
+          }
+        ];
+      }
+      if (statement.declaration.type.endsWith("Declaration")) {
+        const bindings = declarationBindings(statement.declaration);
+        return bindings.length > 0 ? bindings.map((binding) => ({ ...binding, exportedName: "default", default: true })) : [{ exportedName: "default", node: statement, typeOnly: false, default: true, reExport: false }];
+      }
+      return [{ exportedName: "default", node: statement, typeOnly: false, default: true, reExport: false }];
+    }
+    if (statement.type !== "ExportNamedDeclaration") {
+      return [];
+    }
+    return [
+      ...declarationBindings(statement.declaration),
+      ...statement.specifiers.map((specifier) => {
+        const localName = moduleExportName(specifier.local);
+        const local = locals.get(localName);
+        return {
+          ...local ?? {
+            exportedName: moduleExportName(specifier.exported),
+            node: specifier,
+            typeOnly: false,
+            default: false,
+            reExport: Boolean(statement.source)
+          },
+          exportedName: moduleExportName(specifier.exported),
+          localName,
+          node: local?.node ?? specifier,
+          typeOnly: specifier.exportKind === "type" || statement.exportKind === "type" || Boolean(local?.typeOnly),
+          default: moduleExportName(specifier.exported) === "default",
+          reExport: Boolean(statement.source)
+        };
+      })
+    ];
+  });
+}
+function exportsCollectFunctions(program) {
+  return exportsCollect(program).flatMap((binding) => {
+    const name = binding.localName ?? binding.exportedName;
+    if (binding.declaration?.type === "FunctionDeclaration") {
+      return [{ name, node: binding.declaration }];
+    }
+    return binding.initializer?.type === "FunctionExpression" || binding.initializer?.type === "ArrowFunctionExpression" ? [{ name, node: binding.initializer }] : [];
+  });
+}
+// src/utils/helpers/naming.ts
+function namingPosixPath(filePath) {
+  return filePath.replaceAll("\\", "/");
+}
+function namingFileBasename(filePath) {
+  const normalized = namingPosixPath(filePath);
+  const slash = normalized.lastIndexOf("/");
+  return slash === -1 ? normalized : normalized.slice(slash + 1);
+}
+function namingDirSegments(filePath) {
+  const parts = namingPosixPath(filePath).split("/").filter(Boolean);
+  return parts.slice(0, -1);
+}
+function namingSegmentsAfter(filePath, after) {
+  const dirs = namingDirSegments(filePath);
+  const marker = after.split("/").filter(Boolean);
+  if (marker.length === 0) {
+    return;
+  }
+  for (let index = dirs.length - marker.length;index >= 0; index -= 1) {
+    if (marker.every((part, offset) => dirs[index + offset] === part)) {
+      return dirs.slice(index + marker.length);
+    }
+  }
+}
+function namingFolderPrefixes(folders, separator, singularize) {
+  const joined = folders.join(separator);
+  const last = folders.at(-1) ?? "";
+  const prefixes = [joined];
+  if (singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
+    prefixes.push([...folders.slice(0, -1), last.slice(0, -1)].join(separator));
+  }
+  return prefixes.filter(Boolean);
+}
+function namingPascalCase(value) {
+  return value.split(/[-_\s.]+/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+function namingCamelCase(value) {
+  const next = namingPascalCase(value);
+  return `${next.charAt(0).toLowerCase()}${next.slice(1)}`;
+}
+function namingMatchTemplate(basename, template, placeholderPattern = "[a-z0-9-]+") {
+  let pattern = "";
+  let index = 0;
+  while (index < template.length) {
+    const char = template[index];
+    if (char === "{") {
+      const end = template.indexOf("}", index);
+      if (end === -1) {
+        return null;
+      }
+      const key = template.slice(index + 1, end);
+      pattern += `(?<${key}>${placeholderPattern})`;
+      index = end + 1;
+      continue;
+    }
+    pattern += /[.+^${}()|[\]\\]/.test(char) ? `\\${char}` : char;
+    index += 1;
+  }
+  return new RegExp(`^${pattern}$`).exec(basename)?.groups ?? null;
+}
+var namingStemModes = ["before-first-dot", "full-basename"];
+function namingNormalized(value, normalize) {
+  return normalize === "none" ? value : value.replaceAll(/[-_.]/g, "").toLowerCase();
+}
+function namingFileStem(basename, mode = "before-first-dot", trailingRoles = [], roleSeparators = [".", "-"]) {
+  const stem = mode === "full-basename" ? basename : basename.split(".")[0] ?? "";
+  const roles = [...new Set(trailingRoles.filter(Boolean))].sort((left, right) => right.length - left.length);
+  const separators = [...new Set(roleSeparators.filter(Boolean))];
+  if (roles.length === 0 || separators.length === 0) {
+    return stem;
+  }
+  let remaining = stem;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const role of roles) {
+      for (const separator of separators) {
+        const suffix = `${separator}${role}`;
+        if (remaining.length > suffix.length && remaining.endsWith(suffix)) {
+          remaining = remaining.slice(0, -suffix.length);
+          changed = true;
+          break;
+        }
+      }
+      if (changed) {
+        break;
+      }
+    }
+  }
+  return remaining;
+}
+function namingFilePrefixes(stem, normalize = "remove-separators", singularize = "none") {
+  const prefixes = [namingNormalized(stem, normalize)];
+  const parts = stem.split(/[-_]+/).filter(Boolean);
+  const last = parts.at(-1) ?? "";
+  if (singularize === "trailing-s" && last.endsWith("s") && last.length > 1) {
+    prefixes.push(namingNormalized([...parts.slice(0, -1), last.slice(0, -1)].join("-"), normalize));
+  }
+  return [...new Set(prefixes.filter(Boolean))];
+}
+
+// src/utils/helpers/factories.ts
+function factoriesExpandTemplate(template, groups, camelCase = false) {
+  return template.replaceAll(/\{([^}]+)\}/g, (placeholder, key) => {
+    const group = groups[key.toLowerCase()];
+    if (!group) {
+      return placeholder;
+    }
+    if (/^[A-Z]/.test(key)) {
+      return namingPascalCase(group);
+    }
+    return camelCase ? namingCamelCase(group) : group;
+  });
+}
+function factoriesCollectTopLevel(program, pattern) {
+  return program.body.flatMap((statement) => {
+    const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "FunctionDeclaration") {
+      const name = declaration.id?.name ?? "<anonymous>";
+      return pattern.test(name) ? [{ name, node: declaration }] : [];
+    }
+    if (declaration?.type !== "VariableDeclaration") {
+      return [];
+    }
+    return declaration.declarations.flatMap((item) => item.id.type === "Identifier" && pattern.test(item.id.name) && (item.init?.type === "FunctionExpression" || item.init?.type === "ArrowFunctionExpression") ? [{ name: item.id.name, node: item.init }] : []);
+  });
+}
+function factoriesDirectlyReturnedObjects(factory) {
+  if (factory.node.type === "ArrowFunctionExpression" && factory.node.body.type === "ObjectExpression") {
+    return [factory.node.body];
+  }
+  const result = [];
+  astVisit(factory.node.body, [factory.node], (node, ancestors) => {
+    if (node.type === "ReturnStatement" && node.argument?.type === "ObjectExpression" && astNearestFunction(ancestors) === factory.node) {
+      result.push(node.argument);
+    }
+  });
+  return result;
+}
+function factoriesObjectPropertyName(property) {
+  if (property.type === "SpreadElement" || property.computed) {
+    return;
+  }
+  if (property.key.type === "Identifier") {
+    return property.key.name;
+  }
+  return property.key.type === "Literal" && typeof property.key.value === "string" ? property.key.value : undefined;
+}
+// src/utils/helpers/guards.ts
+var guardsPrimitiveNames = new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "undefined",
+  "bigint",
+  "symbol",
+  "function"
+]);
+function guardsValue(node, state) {
+  const value = trivialUnwrap(node);
+  if (value.type === "Identifier")
+    return state.values.has(value.name);
+  return value.type === "MemberExpression" && value.computed && value.object.type === "Identifier" && state.values.has(value.object.name) && value.property.type === "Identifier" && state.values.has(value.property.name);
+}
+function guardsFallback(node) {
+  return node.type === "Literal" && !("regex" in node) || node.type === "Identifier" && node.name === "undefined" || node.type === "ArrayExpression" && node.elements.length === 0 || node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function guardsPredicate(expression, state) {
+  const node = trivialUnwrap(expression);
+  if (node.type === "Identifier")
+    return state.predicates.has(node.name);
+  if (node.type === "UnaryExpression" && node.operator === "!")
+    return guardsPredicate(node.argument, state);
+  if (node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||")) {
+    return guardsPredicate(node.left, state) && guardsPredicate(node.right, state);
+  }
+  if (node.type === "BinaryExpression" && ["===", "!==", "==", "!="].includes(node.operator)) {
+    for (const [left, right] of [
+      [node.left, node.right],
+      [node.right, node.left]
+    ]) {
+      if (left.type === "UnaryExpression" && left.operator === "typeof" && right.type === "Literal" && typeof right.value === "string" && guardsPrimitiveNames.has(right.value) && guardsValue(left.argument, state)) {
+        state.primitive = true;
+        return true;
+      }
+      if (left.type !== "PrivateIdentifier" && guardsValue(left, state) && (right.type === "Literal" && right.value === null || right.type === "Identifier" && right.name === "undefined"))
+        return true;
+    }
+  }
+  if (node.type === "CallExpression" && !node.optional && node.arguments.length === 1 && node.arguments[0].type !== "SpreadElement" && guardsValue(node.arguments[0], state) && node.callee.type === "MemberExpression" && !node.callee.computed && !node.callee.optional && node.callee.object.type === "Identifier" && node.callee.object.name === "Array" && node.callee.property.type === "Identifier" && node.callee.property.name === "isArray" && state.globalArray(node.callee.object)) {
+    state.primitive = true;
+    return true;
+  }
+  return false;
+}
+function guardsResult(node, state) {
+  const value = trivialUnwrap(node);
+  if (guardsValue(value, state) || guardsFallback(value) || guardsPredicate(value, state))
+    return true;
+  return value.type === "ConditionalExpression" && guardsPredicate(value.test, state) && guardsResult(value.consequent, state) && guardsResult(value.alternate, state);
+}
+function guardsStatement(node, state) {
+  if (node.type === "EmptyStatement" || node.type === "ExpressionStatement" && Boolean(node.directive))
+    return true;
+  if (node.type === "ReturnStatement" && node.argument) {
+    state.returned = true;
+    return guardsResult(node.argument, state);
+  }
+  if (node.type === "BlockStatement")
+    return node.body.every((statement) => guardsStatement(statement, state));
+  if (node.type === "IfStatement") {
+    return guardsPredicate(node.test, state) && guardsStatement(node.consequent, state) && (!node.alternate || guardsStatement(node.alternate, state));
+  }
+  if (node.type === "VariableDeclaration" && node.kind === "const") {
+    return node.declarations.every((declaration) => {
+      if (declaration.id.type !== "Identifier" || !declaration.init)
+        return false;
+      if (guardsValue(declaration.init, state)) {
+        state.values.add(declaration.id.name);
+        return true;
+      }
+      if (guardsPredicate(declaration.init, state)) {
+        state.predicates.add(declaration.id.name);
+        return true;
+      }
+      return guardsFallback(declaration.init);
+    });
+  }
+  return false;
+}
+function guardsIsGenericHelper(node, globalArray) {
+  if (!node.body || node.params.length === 0 || node.params.some((param) => param.type !== "Identifier"))
+    return false;
+  const state = {
+    values: new Set(node.params.flatMap((param) => param.type === "Identifier" ? [param.name] : [])),
+    predicates: new Set,
+    primitive: false,
+    returned: false,
+    globalArray
+  };
+  if (node.body.type !== "BlockStatement")
+    return guardsResult(node.body, state) && state.primitive;
+  return node.body.body.every((statement) => guardsStatement(statement, state)) && state.primitive && state.returned;
+}
+// src/utils/helpers/layout.ts
+var layoutIndentSchema = {
+  anyOf: [
+    { type: "integer", minimum: 0 },
+    { type: "string", enum: ["tab"] }
+  ]
+};
+function layoutLineIndent(text, offset) {
+  const lineStart = text.lastIndexOf(`
+`, offset - 1) + 1;
+  return /^[\t ]*/.exec(text.slice(lineStart, offset))?.[0] ?? "";
+}
+function layoutIndentUnit(indent = 2) {
+  return indent === "tab" ? "\t" : " ".repeat(indent);
+}
+function layoutNewline(text) {
+  return text.includes(`\r
+`) ? `\r
+` : `
+`;
+}
+// src/utils/helpers/mocking.ts
+function mockingApiPatternsAssert(patterns) {
+  if (patterns.some((pattern) => !/^(?:\*|(?:vi|jest|\*)\.(?:[A-Za-z_$][\w$]*|\*))$/.test(pattern)))
+    throw new Error("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
+}
+// src/utils/helpers/options.ts
+function optionsFirst(context, fallback) {
+  return context.options[0] ?? fallback;
+}
+var optionsPatternSchema = {
+  anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, minItems: 1 }]
+};
+function optionsPatterns(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
+}
+function optionsOptionalPatterns(pattern, flags) {
+  return optionsPatterns(pattern === undefined ? undefined : [pattern].flat().filter((source) => source !== ""), flags);
+}
+function optionsPatternLabel(pattern) {
+  return pattern === undefined ? "" : [pattern].flat().join(" | ");
+}
+function optionsPatternsTest(patterns, value) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+// src/utils/helpers/orpc.ts
+function orpcFindChainCall(expression, method) {
+  if (expression.type === "CallExpression") {
+    if (expression.callee.type === "MemberExpression" && astStaticMemberName(expression.callee) === method) {
+      return expression;
+    }
+    if (expression.callee.type === "MemberExpression") {
+      return orpcFindChainCall(expression.callee.object, method);
+    }
+  }
+  if (expression.type === "MemberExpression") {
+    return orpcFindChainCall(expression.object, method);
+  }
+  if (expression.type === "ChainExpression") {
+    return orpcFindChainCall(expression.expression, method);
+  }
+}
+function orpcIsNamedOrComposedArgument(argument, composers) {
+  if (argument?.type === "Identifier") {
+    return true;
+  }
+  return argument?.type === "CallExpression" && argument.callee.type === "Identifier" && composers.has(argument.callee.name) && argument.arguments[0]?.type === "Identifier";
+}
+// src/utils/helpers/react-components.ts
+function reactComponentsExportCandidates(program) {
+  return exportsCollect(program).map((binding) => ({
+    ...binding,
+    name: binding.localName ?? binding.exportedName
+  }));
+}
+function importedPropsWithChildren(program) {
+  return new Set(program.body.flatMap((statement) => statement.type === "ImportDeclaration" && statement.source.value === "react" ? statement.specifiers.flatMap((specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "PropsWithChildren" ? [specifier.local.name] : []) : []));
+}
+function containsNamedTypeReference(node, names) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "TSTypeReference" && candidate.typeName.type === "Identifier" && names.has(candidate.typeName.name)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function returnsReactChildren(program, node, expressions) {
+  const returnedNames = new Set(expressions.flatMap((expression) => expression.type === "Identifier" ? [expression.name] : []));
+  const propsWithChildren = importedPropsWithChildren(program);
+  return node.params.some((param) => {
+    if (param.type !== "ObjectPattern") {
+      return false;
+    }
+    const returnsChild = param.properties.some((property) => property.type === "Property" && property.value.type === "Identifier" && returnedNames.has(property.value.name));
+    return returnsChild && containsNamedTypeReference(param.typeAnnotation, propsWithChildren);
+  });
+}
+function reactComponentsFunctionReturnsOutput(program, node) {
+  const expressions = astDirectReturnExpressions(node);
+  return expressions.some((expression) => astContainsJsx(expression) || expression.type === "Literal" && expression.value === null) || returnsReactChildren(program, node, expressions);
+}
+function functionReturnsLocalComponent(program, node) {
+  const componentNames = new Set;
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === "FunctionDeclaration" && candidate !== node && candidate.id?.name && /^[A-Z]/.test(candidate.id.name) && astNearestFunction(ancestors) === node && reactComponentsFunctionReturnsOutput(program, candidate)) {
+      componentNames.add(candidate.id.name);
+    }
+  });
+  return astDirectReturnExpressions(node).some((expression) => expression.type === "Identifier" && componentNames.has(expression.name));
+}
+function componentFactoryNames(program) {
+  return new Set(program.body.flatMap((statement) => statement.type === "FunctionDeclaration" && statement.id?.name && functionReturnsLocalComponent(program, statement) ? [statement.id.name] : []));
+}
+function isComponentInitializer(program, initializer) {
+  if (!initializer) {
+    return false;
+  }
+  if (initializer.type === "ArrowFunctionExpression" || initializer.type === "FunctionExpression") {
+    return reactComponentsFunctionReturnsOutput(program, initializer);
+  }
+  if (initializer.type !== "CallExpression") {
+    return false;
+  }
+  const name = astCallName(initializer);
+  if (name === "forwardRef" || name === "memo") {
+    return initializer.arguments.some((argument) => argument.type !== "SpreadElement" && isComponentInitializer(program, argument));
+  }
+  if (name === "lazy") {
+    return initializer.arguments.some((argument) => argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression");
+  }
+  return Boolean(name?.startsWith("create") && componentFactoryNames(program).has(name));
+}
+function reactComponentsIsLike(program, candidate) {
+  if (!/^[A-Z]/.test(candidate.name)) {
+    return false;
+  }
+  const declaration = candidate.declaration ?? candidate.node;
+  if (declaration.type === "FunctionDeclaration") {
+    return reactComponentsFunctionReturnsOutput(program, declaration);
+  }
+  return declaration.type === "VariableDeclaration" && isComponentInitializer(program, candidate.initializer);
+}
+function reactComponentsPascalFromBasename(basename) {
+  return basename.replace(/\.(tsx?|jsx?)$/, "").split(/[-.]/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+}
+// src/utils/helpers/routes.ts
+function routesInspectFunction(context, item, bannedHooks, banIntrinsicJsx) {
+  astVisit(item.node.body, [item.node], (node) => {
+    if (banIntrinsicJsx && node.type === "JSXOpeningElement" && node.name.type === "JSXIdentifier" && /^[a-z]/.test(node.name.name)) {
+      context.report({
+        node,
+        messageId: "hostJsx",
+        data: { name: item.name }
+      });
+    }
+    if (node.type === "CallExpression") {
+      const name = astCallName(node);
+      if (name && bannedHooks.has(name)) {
+        context.report({
+          node,
+          messageId: "bannedHook",
+          data: { hook: name, name: item.name }
+        });
+      }
+    }
+  });
+}
+// src/utils/helpers/runtime.ts
+import { builtinModules } from "node:module";
+var runtimeServerGlobals = ["process", "Bun", "Deno", "Buffer", "__dirname", "__filename", "require"];
+var runtimeBrowserGlobals = [
+  "window",
+  "document",
+  "navigator",
+  "localStorage",
+  "sessionStorage",
+  "location",
+  "history",
+  "screen",
+  "HTMLElement",
+  "Element",
+  "HTMLInputElement",
+  "ResizeObserver",
+  "MutationObserver",
+  "IntersectionObserver",
+  "FileReader",
+  "matchMedia",
+  "getComputedStyle",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "alert",
+  "confirm",
+  "prompt"
+];
+function runtimeMatchesImport(values, source) {
+  return Boolean(values?.some((value) => source === value || source.startsWith(value + "/")));
+}
+function runtimeIsBackendImport(options, target, source) {
+  return options.backend.some((path) => target.startsWith(path + "/")) || options.backendPackages.some((name) => source === name || source.startsWith(name + "/") && /\/(?:server|rpc)(?:\/|$)/.test(source.slice(name.length)));
+}
+function runtimeIsServerPlatformImport(source) {
+  return builtinModules.includes(source) || source === "@orpc/server" || /^(?:node:|bun(?::|$)|cloudflare:)/.test(source) || /^react-dom\/server(?:\.|\/|$)/.test(source);
+}
+function runtimeMemberName(node) {
+  if (node?.type !== "MemberExpression")
+    return null;
+  if (!node.computed && node.property.type === "Identifier")
+    return node.property.name;
+  return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+}
+// src/utils/helpers/sanitizers.ts
+function sanitizersCallsConfigured(node, names) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "CallExpression" && candidate.callee.type === "Identifier" && names.has(candidate.callee.name)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function sanitizersConfiguredBindings(program, names) {
+  const result = new Set;
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+    if (declaration?.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const item of declaration.declarations) {
+      if (item.id.type === "Identifier" && sanitizersCallsConfigured(item.init, names)) {
+        result.add(item.id.name);
+      }
+    }
+  }
+  return result;
+}
+// src/utils/helpers/schemas.ts
+function schemasIsRuntimeSpecifier(specifier) {
+  return specifier.type !== "ImportSpecifier" || specifier.importKind !== "type";
+}
+function schemasMemberRootName(node) {
+  if (node.object.type === "Identifier") {
+    return node.object.name;
+  }
+  return node.object.type === "MemberExpression" ? schemasMemberRootName(node.object) : undefined;
+}
+function schemasIsPackage(source, packages) {
+  return packages.has(source) || [...packages].some((pkg) => source.startsWith(`${pkg}/`));
+}
+function schemasIsCall(node, namespaces) {
+  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && namespaces.has(node.callee.object.name);
+}
+function schemasRuntimeImportLocals(node) {
+  return node.importKind === "type" ? [] : node.specifiers.flatMap((specifier) => schemasIsRuntimeSpecifier(specifier) ? [specifier.local.name] : []);
+}
+function schemasIsRuntimeImport(node, packages) {
+  return schemasIsPackage(node.source.value, packages) && (node.specifiers.length === 0 ? node.importKind !== "type" : schemasRuntimeImportLocals(node).length > 0);
+}
+function schemasIsRuntimeReexport(node, packages) {
+  if (!node.source || !schemasIsPackage(node.source.value, packages) || node.exportKind === "type") {
+    return false;
+  }
+  return node.type === "ExportAllDeclaration" || node.specifiers.length === 0 || node.specifiers.some((specifier) => specifier.exportKind !== "type");
+}
+function schemasIsConstruction(node, constructors) {
+  if (node.callee.type === "Identifier") {
+    return constructors.has(node.callee.name);
+  }
+  if (node.callee.type !== "MemberExpression") {
+    return false;
+  }
+  const root = schemasMemberRootName(node.callee);
+  return Boolean(root && constructors.has(root));
+}
+function schemasElements(node) {
+  return node.arguments.flatMap((argument) => argument.type === "ArrayExpression" ? argument.elements.filter((element) => element !== null) : [argument]);
+}
+function schemasIsAllowedElement(node, allowScalars, namespaces, structuralMethods) {
+  if (node.type === "Identifier") {
+    return true;
+  }
+  if (!allowScalars || node.type !== "CallExpression" || !schemasIsCall(node, namespaces)) {
+    return false;
+  }
+  const name = node.callee.type === "MemberExpression" ? astStaticMemberName(node.callee) : undefined;
+  return Boolean(name && !structuralMethods.has(name));
+}
+function schemasTypeOperator(node, namespaces, operators) {
+  return node.typeName.type === "TSQualifiedName" && node.typeName.left.type === "Identifier" && namespaces.has(node.typeName.left.name) && operators.has(node.typeName.right.name) ? node.typeName.right.name : undefined;
+}
+// src/utils/helpers/boundaries.ts
+import { resolve, dirname } from "node:path";
+function boundaryResolveTarget(options, file, source) {
+  const owner = [...options.web, ...options.backend].sort((a, b) => b.length - a.length).find((root) => file.startsWith(root + "/"));
+  const web = owner && options.web.includes(owner) ? owner : undefined;
+  const alias = Object.entries(options.aliases).sort(([a], [b]) => b.length - a.length).find(([prefix]) => source === prefix || source.startsWith(`${prefix}/`));
+  return alias ? resolve(alias[1], source.slice(alias[0].length).replace(/^\//, "")).replaceAll("\\", "/") : source.startsWith(".") ? resolve(dirname(file), source).replaceAll("\\", "/") : source.startsWith("@/") && web ? `${web}/${source.slice(2)}` : source.startsWith("#/") && owner ? `${owner}/${source.slice(2)}` : source.startsWith("#services/") && owner ? `${owner}/services/${source.slice(10)}` : source;
+}
+// src/rules/dillon-anti-slop/rules/no-module-mocking.ts
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+var defaultDeny = [
+  { api: "*.mock" },
+  { api: "*.doMock" },
+  { api: "*.unstable_mockModule" }
+];
 function resolveVariable2(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
   while (scope !== null) {
@@ -610,33 +1642,75 @@ function importedName(node) {
     return null;
   return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
 }
-function isTestFrameworkObject(sourceCode, expression) {
+function testFramework(sourceCode, expression) {
   if (expression.type !== "Identifier")
-    return false;
-  if ((expression.name === "vi" || expression.name === "jest") && sourceCode.isGlobalReference(expression)) {
-    return true;
-  }
+    return null;
+  const name = expression.name === "vi" || expression.name === "jest" ? expression.name : null;
+  if (name !== null && sourceCode.isGlobalReference(expression))
+    return name;
   const variable = resolveVariable2(sourceCode, expression);
-  if (variable === null || variable.defs.length === 0) {
-    return expression.name === "vi" || expression.name === "jest";
-  }
-  return variable.defs.some((definition) => {
+  if (variable === null || variable.defs.length === 0)
+    return name;
+  for (const definition of variable.defs) {
     if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
-      return false;
+      continue;
     }
     const source = definition.parent.source.value;
-    const name = importedName(definition.node);
-    return source === "vitest" && name === "vi" || source === "@jest/globals" && name === "jest";
-  });
+    const imported = importedName(definition.node);
+    if (source === "vitest" && imported === "vi")
+      return "vi";
+    if (source === "@jest/globals" && imported === "jest")
+      return "jest";
+  }
+  return null;
 }
-function moduleMockCall(sourceCode, callee) {
-  if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
-    return false;
-  if (!isTestFrameworkObject(sourceCode, callee.object))
-    return false;
-  const property = callee.property;
-  const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
-  return method !== null && moduleMockMethods.has(method);
+function propertyName(key, computed) {
+  if (key.type === "Literal" && typeof key.value === "string")
+    return key.value;
+  return !computed && key.type === "Identifier" ? key.name : null;
+}
+function calledApi(sourceCode, callee) {
+  if (callee.type !== "MemberExpression")
+    return null;
+  const framework = testFramework(sourceCode, callee.object);
+  if (framework === null)
+    return null;
+  const method = propertyName(callee.property, callee.computed);
+  return method === null ? null : `${framework}.${method}`;
+}
+function destructuredApi(sourceCode, callee) {
+  if (callee.type !== "Identifier")
+    return null;
+  const definition = resolveVariable2(sourceCode, callee)?.defs[0];
+  if (definition?.parent?.type !== "VariableDeclaration" || definition.parent.kind !== "const")
+    return null;
+  const declarator = definition.node;
+  if (declarator?.type !== "VariableDeclarator" || declarator.id.type !== "ObjectPattern" || declarator.init === null)
+    return null;
+  const framework = testFramework(sourceCode, declarator.init);
+  if (framework === null)
+    return null;
+  for (const property of declarator.id.properties) {
+    if (property.type !== "Property")
+      continue;
+    const binding = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+    if (binding.type !== "Identifier" || binding.name !== callee.name)
+      continue;
+    const method = propertyName(property.key, property.computed);
+    return method === null ? null : `${framework}.${method}`;
+  }
+  return null;
+}
+function apiParts(api) {
+  const dot = api.indexOf(".");
+  return [api.slice(0, dot), api.slice(dot + 1)];
+}
+function apiMatches(pattern, api) {
+  if (pattern === "*")
+    return true;
+  const [patternFramework, patternMethod] = apiParts(pattern);
+  const [framework, method] = apiParts(api);
+  return (patternFramework === "*" || patternFramework === framework) && (patternMethod === "*" || patternMethod === method);
 }
 var noModuleMockingRule = defineRule4({
   meta: {
@@ -644,18 +1718,75 @@ var noModuleMockingRule = defineRule4({
     docs: {
       description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces."
     },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          deny: {
+            type: "array",
+            items: {
+              anyOf: [
+                { type: "string" },
+                {
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    api: { type: "string" },
+                    message: { type: "string" }
+                  },
+                  required: ["api"]
+                }
+              ]
+            }
+          },
+          allow: { type: "array", items: { type: "string" } },
+          checkDestructured: { type: "boolean" }
+        }
+      }
+    ],
     messages: {
-      moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation."
+      moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+      testDouble: "Replace {{api}} with dependency injection through a real interface, service layer, or faithful test implementation.",
+      custom: "{{message}}"
     }
   },
   createOnce(context) {
+    let deny = [];
+    let allow = [];
+    let checkDestructured = false;
     return {
+      before() {
+        const options2 = optionsFirst(context, {});
+        deny = (options2.deny ?? defaultDeny).map((entry) => typeof entry === "string" ? { api: entry } : entry);
+        allow = options2.allow ?? [];
+        checkDestructured = options2.checkDestructured ?? false;
+        mockingApiPatternsAssert([...deny.map((entry) => entry.api), ...allow]);
+      },
       CallExpression(node) {
         if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
           return;
-        if (moduleMockCall(context.sourceCode, node.callee)) {
-          context.report({ node, messageId: "moduleMock" });
+        const api = calledApi(context.sourceCode, node.callee) ?? (checkDestructured ? destructuredApi(context.sourceCode, node.callee) : null);
+        if (api === null)
+          return;
+        if (allow.some((pattern) => apiMatches(pattern, api)))
+          return;
+        const denied = deny.find((entry) => apiMatches(entry.api, api));
+        if (denied === undefined)
+          return;
+        if (denied.message !== undefined) {
+          context.report({
+            node,
+            messageId: "custom",
+            data: { message: denied.message }
+          });
+          return;
         }
+        context.report({
+          node,
+          messageId: moduleMockMethods.has(apiParts(api)[1]) ? "moduleMock" : "testDouble",
+          data: { api }
+        });
       }
     };
   }