oxlint-plugin-arch 0.11.0 → 0.12.1

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

@@ -1,2719 +0,0 @@
-// src/rules/dillon-anti-slop/index.ts
-import { eslintCompatPlugin } from "@oxlint/plugins";
-
-// src/rules/dillon-anti-slop/rules/no-chained-type-assertions.ts
-import { defineRule } from "@oxlint/plugins";
-function isTypeAssertionExpression(node) {
-  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
-}
-function unwrapParenthesizedExpression(expression) {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-function isConstAssertion(node) {
-  const { typeAnnotation } = node;
-  return typeAnnotation.type === "TSTypeReference" && typeAnnotation.typeName.type === "Identifier" && typeAnnotation.typeName.name === "const";
-}
-function isOutermostAssertionInChain(node) {
-  let current = node;
-  let parent = node.parent;
-  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
-    current = parent;
-    parent = parent.parent;
-  }
-  return !isTypeAssertionExpression(parent) || parent.expression !== current;
-}
-function isForbiddenAssertionChain(node) {
-  let assertionCount = 0;
-  let hasNonConstAssertion = false;
-  let current = node;
-  while (isTypeAssertionExpression(current)) {
-    assertionCount += 1;
-    hasNonConstAssertion ||= !isConstAssertion(current);
-    current = unwrapParenthesizedExpression(current.expression);
-  }
-  return assertionCount > 1 && hasNonConstAssertion;
-}
-var noChainedTypeAssertionsRule = defineRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains."
-    },
-    messages: {
-      chained: "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it."
-    }
-  },
-  createOnce(context) {
-    const checkTypeAssertion = (node) => {
-      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node))
-        return;
-      context.report({ node, messageId: "chained" });
-    };
-    return {
-      TSAsExpression: checkTypeAssertion,
-      TSTypeAssertion: checkTypeAssertion
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
-function unwrapParentheses(node) {
-  let current = node;
-  while (current.type === "ParenthesizedExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-function isEmptyObjectExpression(node) {
-  return node.type === "ObjectExpression" && node.properties.length === 0;
-}
-function isConditionalEmptyObjectSpread(node) {
-  const conditional = unwrapParentheses(node);
-  return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
-}
-var noConditionalEmptyObjectSpreadRule = defineRule2({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow object spreads that conditionally spread an empty object to omit fields."
-    },
-    messages: {
-      avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present."
-    }
-  },
-  createOnce(context) {
-    return {
-      SpreadElement(node) {
-        if (node.parent.type !== "ObjectExpression")
-          return;
-        if (isConditionalEmptyObjectSpread(node.argument)) {
-          context.report({ node, messageId: "avoid" });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-known-value-widening.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
-
-// src/rules/dillon-anti-slop/shared/dictionary-types.ts
-var BUILT_INS = new Set([
-  "Record",
-  "Readonly",
-  "Partial",
-  "Required",
-  "Pick",
-  "Omit",
-  "PropertyKey",
-  "NonNullable"
-]);
-var TRANSPARENT_WRAPPERS = new Set([
-  "Readonly",
-  "Partial",
-  "Required",
-  "NonNullable"
-]);
-function declaredStatement(statement) {
-  return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
-}
-function createTypeEnvironment(program) {
-  const aliases = new Map;
-  const interfaces = new Map;
-  const shadowedBuiltIns = new Set;
-  for (const statement of program.body) {
-    const declaration = declaredStatement(statement);
-    if (declaration?.type === "ImportDeclaration") {
-      for (const specifier of declaration.specifiers) {
-        if (BUILT_INS.has(specifier.local.name))
-          shadowedBuiltIns.add(specifier.local.name);
-      }
-      continue;
-    }
-    if (declaration?.type === "TSTypeAliasDeclaration") {
-      const existing = aliases.get(declaration.id.name);
-      if (existing === undefined)
-        aliases.set(declaration.id.name, declaration);
-      else
-        shadowedBuiltIns.add(declaration.id.name);
-      if (BUILT_INS.has(declaration.id.name))
-        shadowedBuiltIns.add(declaration.id.name);
-      continue;
-    }
-    if (declaration?.type === "TSInterfaceDeclaration") {
-      const declarations = interfaces.get(declaration.id.name) ?? [];
-      declarations.push(declaration);
-      interfaces.set(declaration.id.name, declarations);
-      if (BUILT_INS.has(declaration.id.name))
-        shadowedBuiltIns.add(declaration.id.name);
-      continue;
-    }
-    if (declaration?.type === "TSEnumDeclaration") {
-      if (BUILT_INS.has(declaration.id.name))
-        shadowedBuiltIns.add(declaration.id.name);
-      continue;
-    }
-    if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null) {
-      if (BUILT_INS.has(declaration.id.name))
-        shadowedBuiltIns.add(declaration.id.name);
-    }
-  }
-  return { aliases, interfaces, shadowedBuiltIns };
-}
-function typeReferenceName(type) {
-  return type.typeName.type === "Identifier" ? type.typeName.name : null;
-}
-function isBuiltIn(name, environment) {
-  return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
-}
-function isUnappliedReferenceTo(type, name) {
-  const unwrapped = unwrapTransparentType(type);
-  return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === name && (unwrapped.typeArguments === null || unwrapped.typeArguments === undefined || unwrapped.typeArguments.params.length === 0);
-}
-function unwrapTransparentType(type) {
-  let current = type;
-  while (current.type === "TSParenthesizedType" || current.type === "TSTypeOperator" && current.operator === "readonly") {
-    current = current.typeAnnotation;
-  }
-  return current;
-}
-function isNeverType(type) {
-  return unwrapTransparentType(type).type === "TSNeverKeyword";
-}
-function isEffectivelyEmptyMember(member) {
-  return member.type === "TSPropertySignature" && member.optional === true && member.typeAnnotation !== null && member.typeAnnotation !== undefined && isNeverType(member.typeAnnotation.typeAnnotation);
-}
-function isEffectivelyEmptyTypeLiteral(type) {
-  return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
-}
-function isEffectivelyEmptyInterface(declarations) {
-  if (declarations.length !== 1)
-    return false;
-  const [type] = declarations;
-  return type !== undefined && type.extends.length === 0 && (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember));
-}
-function resolvedSubstitutionArgument(type, base, resolving = new Set) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type !== "TSTypeReference")
-    return type;
-  const name = typeReferenceName(unwrapped);
-  if (name === null || resolving.has(name))
-    return type;
-  const substitution = base.get(name);
-  if (substitution === undefined)
-    return type;
-  const nextResolving = new Set(resolving);
-  nextResolving.add(name);
-  return resolvedSubstitutionArgument(substitution, base, nextResolving);
-}
-function aliasSubstitution(alias, type, base) {
-  const parameters = alias.typeParameters?.params ?? [];
-  const arguments_ = type.typeArguments?.params ?? [];
-  const next = new Map(base);
-  for (const [index, parameter] of parameters.entries()) {
-    const argument = arguments_[index] ?? parameter.default;
-    if (argument === null || argument === undefined)
-      return null;
-    next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
-  }
-  return next;
-}
-function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type === "TSUnknownKeyword")
-    return "unknown";
-  if (unwrapped.type === "TSAnyKeyword")
-    return "any";
-  if (unwrapped.type === "TSObjectKeyword")
-    return "object";
-  if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped))
-    return "empty-object";
-  if (unwrapped.type === "TSUnionType") {
-    return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
-  }
-  if (unwrapped.type === "TSIntersectionType") {
-    const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
-    if (unsafeMembers.includes("any"))
-      return "any";
-    return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] : null;
-  }
-  if (unwrapped.type !== "TSTypeReference")
-    return null;
-  const name = typeReferenceName(unwrapped);
-  if (name === null)
-    return null;
-  if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
-    const wrapped = unwrapped.typeArguments?.params[0];
-    return wrapped === undefined ? null : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
-  }
-  const substitution = substitutions.get(name);
-  if (substitution !== undefined) {
-    return isUnappliedReferenceTo(substitution, name) ? null : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
-  }
-  const interfaceDeclarations = environment.interfaces.get(name);
-  if (interfaceDeclarations !== undefined) {
-    return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
-  }
-  const alias = environment.aliases.get(name);
-  if (alias === undefined || resolvingAliases.has(name))
-    return null;
-  const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-  if (nextSubstitutions === null)
-    return null;
-  const nextResolving = new Set(resolvingAliases);
-  nextResolving.add(name);
-  return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
-}
-function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type === "TSTypeLiteral") {
-    return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null ? [{ type: member.typeAnnotation.typeAnnotation, substitutions }] : []);
-  }
-  if (unwrapped.type === "TSMappedType") {
-    return unwrapped.typeAnnotation === null ? [] : [{ type: unwrapped.typeAnnotation, substitutions }];
-  }
-  if (unwrapped.type !== "TSTypeReference")
-    return [];
-  const name = typeReferenceName(unwrapped);
-  if (name === null)
-    return [];
-  const substitution = substitutions.get(name);
-  if (substitution !== undefined) {
-    return isUnappliedReferenceTo(substitution, name) ? [] : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
-  }
-  if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
-    const wrapped = unwrapped.typeArguments?.params[0];
-    return wrapped === undefined ? [] : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
-  }
-  if (name === "Record" && isBuiltIn(name, environment)) {
-    const value = unwrapped.typeArguments?.params[1] ?? null;
-    return value === null ? [] : [{ type: value, substitutions }];
-  }
-  if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
-    const source = unwrapped.typeArguments?.params[0];
-    return source === undefined ? [] : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
-  }
-  const alias = environment.aliases.get(name);
-  if (alias === undefined || resolvingAliases.has(name))
-    return [];
-  const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-  if (nextSubstitutions === null)
-    return [];
-  const nextResolving = new Set(resolvingAliases);
-  nextResolving.add(name);
-  return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
-}
-function classifyUnsafeDictionaryValue(valueType, environment) {
-  const unsafeValue = unsafeDirectValue(valueType, environment, new Map, new Set);
-  return unsafeValue === null ? null : { kind: "unsafe-dictionary", unsafeValue };
-}
-function classifyUnsafeDictionary(type, environment) {
-  for (const valueType of dictionaryValueTypes(type, environment, new Map, new Set)) {
-    const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, new Set);
-    if (unsafeValue !== null)
-      return { kind: "unsafe-dictionary", unsafeValue };
-  }
-  return null;
-}
-function resolvesToDictionary(type, environment, substitutions, resolvingAliases) {
-  return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
-}
-function classifyWideningTarget(type, environment) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type === "TSUnknownKeyword")
-    return { kind: "unknown" };
-  if (unwrapped.type === "TSObjectKeyword")
-    return { kind: "object" };
-  if (unwrapped.type === "TSTypeLiteral") {
-    return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
-  }
-  if (unwrapped.type === "TSMappedType")
-    return { kind: "open dictionary" };
-  if (unwrapped.type !== "TSTypeReference")
-    return null;
-  const name = typeReferenceName(unwrapped);
-  if (name === null)
-    return null;
-  if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
-    const wrapped = unwrapped.typeArguments?.params[0];
-    return wrapped === undefined ? null : classifyWideningTarget(wrapped, environment);
-  }
-  if (name === "Record" && isBuiltIn(name, environment))
-    return { kind: "open dictionary" };
-  const alias = environment.aliases.get(name);
-  if (alias === undefined)
-    return null;
-  if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
-    return substitutions2 !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions2, new Set([name])) ? { kind: "generic container" } : null;
-  }
-  const substitutions = aliasSubstitution(alias, unwrapped, new Map);
-  if (substitutions === null)
-    return null;
-  const resolved = classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
-  return resolved;
-}
-function isBroadMappedKey(type, environment, substitutions) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") {
-    return true;
-  }
-  if (unwrapped.type === "TSUnionType") {
-    return unwrapped.types.every((member) => isBroadMappedKey(member, environment, substitutions));
-  }
-  if (unwrapped.type !== "TSTypeReference")
-    return false;
-  const name = typeReferenceName(unwrapped);
-  if (name === null)
-    return false;
-  const substitution = substitutions.get(name);
-  if (substitution !== undefined && !isUnappliedReferenceTo(substitution, name)) {
-    return isBroadMappedKey(substitution, environment, substitutions);
-  }
-  return name === "PropertyKey" && isBuiltIn(name, environment);
-}
-function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
-  const unwrapped = unwrapTransparentType(type);
-  if (unwrapped.type === "TSUnknownKeyword")
-    return { kind: "unknown" };
-  if (unwrapped.type === "TSObjectKeyword")
-    return { kind: "object" };
-  if (unwrapped.type === "TSTypeLiteral") {
-    return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : null;
-  }
-  if (unwrapped.type === "TSMappedType") {
-    return isBroadMappedKey(unwrapped.constraint, environment, substitutions) ? { kind: "open dictionary" } : null;
-  }
-  if (unwrapped.type !== "TSTypeReference")
-    return null;
-  const name = typeReferenceName(unwrapped);
-  if (name === null)
-    return null;
-  const substitution = substitutions.get(name);
-  if (substitution !== undefined) {
-    return isUnappliedReferenceTo(substitution, name) ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
-  }
-  if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
-    const wrapped = unwrapped.typeArguments?.params[0];
-    return wrapped === undefined ? null : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
-  }
-  if (name === "Record" && isBuiltIn(name, environment)) {
-    return { kind: "open dictionary" };
-  }
-  const alias = environment.aliases.get(name);
-  if (alias === undefined || resolvingAliases.has(name))
-    return null;
-  const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
-  if (nextSubstitutions === null)
-    return null;
-  const nextResolving = new Set(resolvingAliases);
-  nextResolving.add(name);
-  return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
-}
-function isKnownEvidenceExpression(expression) {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") {
-    current = current.expression;
-  }
-  if (current.type === "ObjectExpression")
-    return true;
-  return current.type === "ArrayExpression" || current.type === "ArrowFunctionExpression" || current.type === "ClassExpression" || current.type === "FunctionExpression" || current.type === "NewExpression" || current.type === "Literal" || current.type === "TemplateLiteral" || current.type === "UnaryExpression";
-}
-
-// src/rules/dillon-anti-slop/rules/no-known-value-widening.ts
-function unwrapExpression(expression) {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-function resolveVariable(sourceCode, identifier) {
-  let scope = sourceCode.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-function variableDeclarator(variable) {
-  if (variable.defs.length !== 1)
-    return null;
-  const [definition] = variable.defs;
-  return definition?.type === "Variable" && definition.node.type === "VariableDeclarator" ? definition.node : null;
-}
-function isStableConstVariable(variable, declarator) {
-  return declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const" && variable.references.every((reference) => reference.init || !reference.isWrite());
-}
-function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set) {
-  if (isKnownEvidenceExpression(expression))
-    return true;
-  const unwrapped = unwrapExpression(expression);
-  if (unwrapped.type !== "Identifier")
-    return false;
-  const variable = resolveVariable(sourceCode, unwrapped);
-  if (variable === null || visitedVariables.has(variable))
-    return false;
-  const declarator = variableDeclarator(variable);
-  if (declarator === null || declarator.init === null || !isStableConstVariable(variable, declarator)) {
-    return false;
-  }
-  visitedVariables.add(variable);
-  return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
-}
-function annotationTarget(annotation, environment) {
-  return annotation === null || annotation === undefined ? null : classifyWideningTarget(annotation.typeAnnotation, environment);
-}
-function enclosingFunction(node) {
-  let current = node.parent;
-  while (current !== null && current.type !== "Program") {
-    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
-function sourceKeyName(sourceCode, key) {
-  if (key.type === "Identifier" || key.type === "PrivateIdentifier")
-    return key.name;
-  if (key.type === "Literal")
-    return String(key.value);
-  return sourceCode.getText(key);
-}
-function functionName(sourceCode, owner) {
-  if (owner === null)
-    return "anonymous function";
-  if (owner.id !== null)
-    return owner.id.name;
-  const parent = owner.parent;
-  if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier")
-    return parent.id.name;
-  if (parent.type === "MethodDefinition")
-    return sourceKeyName(sourceCode, parent.key);
-  return "anonymous function";
-}
-function isEmptyObjectExpression2(expression) {
-  const unwrapped = unwrapExpression(expression);
-  return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
-}
-function isDictionaryAccumulatorTarget(destination) {
-  return destination.kind === "open dictionary" || destination.kind === "generic container";
-}
-function hasParentAssertion(node) {
-  return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
-}
-var noKnownValueWideningRule = defineRule3({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence."
-    },
-    messages: {
-      widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract."
-    }
-  },
-  createOnce(context) {
-    let environment = null;
-    const reportFlow = (expression, destination, subject) => {
-      if (destination === null)
-        return;
-      if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression2(expression)) {
-        return;
-      }
-      if (!hasKnownEvidence(context.sourceCode, expression))
-        return;
-      context.report({
-        node: expression,
-        messageId: "widening",
-        data: { subject, target: destination.kind }
-      });
-    };
-    const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
-    return {
-      Program(node) {
-        environment = createTypeEnvironment(node);
-      },
-      VariableDeclarator(node) {
-        if (node.init === null || node.id.type !== "Identifier")
-          return;
-        reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
-      },
-      PropertyDefinition(node) {
-        if (node.value === null)
-          return;
-        reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
-      },
-      AccessorProperty(node) {
-        if (node.value === null)
-          return;
-        reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
-      },
-      AssignmentExpression(node) {
-        if (node.operator !== "=" || node.left.type !== "Identifier")
-          return;
-        const variable = resolveVariable(context.sourceCode, node.left);
-        if (variable === null)
-          return;
-        const declarator = variableDeclarator(variable);
-        if (declarator === null || declarator.id.type !== "Identifier")
-          return;
-        reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
-      },
-      ReturnStatement(node) {
-        if (node.argument === null)
-          return;
-        const owner = enclosingFunction(node);
-        reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
-      },
-      ArrowFunctionExpression(node) {
-        if (node.body.type === "BlockStatement")
-          return;
-        reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
-      },
-      TSAsExpression(node) {
-        if (environment === null || hasParentAssertion(node))
-          return;
-        reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
-      },
-      TSTypeAssertion(node) {
-        if (environment === null || hasParentAssertion(node))
-          return;
-        reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
-      }
-    };
-  }
-});
-
-// 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) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-function importedName(node) {
-  if (node.type !== "ImportSpecifier")
-    return null;
-  return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
-}
-function testFramework(sourceCode, expression) {
-  if (expression.type !== "Identifier")
-    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 name;
-  for (const definition of variable.defs) {
-    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
-      continue;
-    }
-    const source = definition.parent.source.value;
-    const imported = importedName(definition.node);
-    if (source === "vitest" && imported === "vi")
-      return "vi";
-    if (source === "@jest/globals" && imported === "jest")
-      return "jest";
-  }
-  return null;
-}
-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: {
-    type: "problem",
-    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.",
-      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;
-        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 }
-        });
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-object-parameters.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-
-// src/rules/dillon-anti-slop/shared/lexical-type-parameters.ts
-function isNode(value) {
-  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
-}
-function collectInferTypeParameterNames(node, visitorKeys, names) {
-  if (node.type === "TSInferType")
-    names.add(node.typeParameter.name.name);
-  const record = node;
-  for (const key of visitorKeys[node.type] ?? []) {
-    const value = record[key];
-    if (isNode(value)) {
-      collectInferTypeParameterNames(value, visitorKeys, names);
-      continue;
-    }
-    if (!Array.isArray(value))
-      continue;
-    for (const child of value) {
-      if (isNode(child))
-        collectInferTypeParameterNames(child, visitorKeys, names);
-    }
-  }
-}
-function lexicalTypeParameterNames(node, visitorKeys) {
-  const names = new Set;
-  let descendant = node;
-  let current = node;
-  while (current !== null && current.type !== "Program") {
-    if ("typeParameters" in current) {
-      for (const parameter of current.typeParameters?.params ?? []) {
-        names.add(parameter.name.name);
-      }
-    }
-    if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) {
-      names.add(current.key.name);
-    }
-    if (current.type === "TSConditionalType" && descendant === current.trueType) {
-      collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
-    }
-    descendant = current;
-    current = current.parent;
-  }
-  return names;
-}
-
-// src/rules/dillon-anti-slop/rules/no-object-parameters.ts
-function parameterAnnotation(parameter) {
-  if (parameter.type === "TSParameterProperty") {
-    return parameterAnnotation(parameter.parameter);
-  }
-  if (parameter.type === "RestElement") {
-    return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
-  }
-  if (parameter.type === "AssignmentPattern") {
-    return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
-  }
-  return parameter.typeAnnotation;
-}
-function parameterName(parameter, sourceCode) {
-  return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
-}
-var noObjectParametersRule = defineRule5({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary."
-    },
-    messages: {
-      objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function."
-    }
-  },
-  createOnce(context) {
-    const aliases = new Map;
-    const resolvesToObject = (type, shadowedAliases, visited = new Set) => {
-      if (type.type === "TSObjectKeyword")
-        return true;
-      if (type.type === "TSParenthesizedType")
-        return resolvesToObject(type.typeAnnotation, shadowedAliases, visited);
-      if (type.type === "TSUnionType") {
-        return type.types.some((member) => resolvesToObject(member, shadowedAliases, visited));
-      }
-      if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeArguments !== null && type.typeArguments !== undefined && type.typeArguments.params.length > 0 || visited.has(type.typeName.name) || shadowedAliases.has(type.typeName.name)) {
-        return false;
-      }
-      const alias = aliases.get(type.typeName.name);
-      if (alias === undefined)
-        return false;
-      const nextVisited = new Set(visited);
-      nextVisited.add(type.typeName.name);
-      return resolvesToObject(alias, shadowedAliases, nextVisited);
-    };
-    const checkParameters = (node) => {
-      const shadowedAliases = lexicalTypeParameterNames(node, context.sourceCode.visitorKeys);
-      for (const parameter of node.params) {
-        const annotation = parameterAnnotation(parameter);
-        if (annotation === null || annotation === undefined)
-          continue;
-        if (!resolvesToObject(annotation.typeAnnotation, shadowedAliases))
-          continue;
-        context.report({
-          node: annotation.typeAnnotation,
-          messageId: "objectParameter",
-          data: { parameter: parameterName(parameter, context.sourceCode) }
-        });
-      }
-    };
-    return {
-      Program(node) {
-        aliases.clear();
-        for (const statement of node.body) {
-          const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-          if (declaration?.type === "TSTypeAliasDeclaration" && (declaration.typeParameters === null || declaration.typeParameters === undefined)) {
-            aliases.set(declaration.id.name, declaration.typeAnnotation);
-          }
-        }
-      },
-      ArrowFunctionExpression: checkParameters,
-      FunctionDeclaration: checkParameters,
-      FunctionExpression: checkParameters,
-      TSCallSignatureDeclaration: checkParameters,
-      TSConstructSignatureDeclaration: checkParameters,
-      TSConstructorType: checkParameters,
-      TSDeclareFunction: checkParameters,
-      TSEmptyBodyFunctionExpression: checkParameters,
-      TSFunctionType: checkParameters,
-      TSMethodSignature: checkParameters
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-reflect-apply.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
-
-// src/rules/dillon-anti-slop/shared/reflect-method.ts
-function resolveVariable3(sourceCode, identifier) {
-  let scope = sourceCode.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-function isGlobalReflect(sourceCode, expression) {
-  if (expression.type !== "Identifier" || expression.name !== "Reflect")
-    return false;
-  if (sourceCode.isGlobalReference(expression))
-    return true;
-  const variable = resolveVariable3(sourceCode, expression);
-  return variable === null || variable.defs.length === 0;
-}
-function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
-  if (!("property" in callee) || !("object" in callee) || !("computed" in callee))
-    return false;
-  if (!isGlobalReflect(sourceCode, callee.object))
-    return false;
-  const property = callee.property;
-  return callee.computed ? property.type === "Literal" && property.value === methodName : property.type === "Identifier" && property.name === methodName;
-}
-
-// src/rules/dillon-anti-slop/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule6({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface."
-    },
-    messages: {
-      reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface."
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
-          return;
-        if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) {
-          context.report({ node, messageId: "reflectApply" });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-reflect-get.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule7({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type."
-    },
-    messages: {
-      reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it."
-    }
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression")
-          return;
-        if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) {
-          context.report({ node, messageId: "reflectGet" });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-runtime-typeof.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
-function isRuntimeFunction(node) {
-  return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
-}
-function isInsideTypeGuard(node) {
-  let current = node.parent;
-  while (current !== null && current.type !== "Program") {
-    if (isRuntimeFunction(current)) {
-      return current.returnType?.typeAnnotation.type === "TSTypePredicate";
-    }
-    current = current.parent;
-  }
-  return false;
-}
-var noRuntimeTypeofRule = defineRule8({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary."
-    },
-    messages: {
-      runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value."
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allowInTypeGuards: { type: "boolean" }
-        },
-        additionalProperties: false
-      }
-    ],
-    defaultOptions: [{ allowInTypeGuards: false }]
-  },
-  createOnce(context) {
-    return {
-      UnaryExpression(node) {
-        const option = context.options?.[0];
-        const allowInTypeGuards = typeof option === "object" && option !== null && !Array.isArray(option) && option.allowInTypeGuards === true;
-        if (node.operator === "typeof" && (!allowInTypeGuards || !isInsideTypeGuard(node))) {
-          context.report({ node, messageId: "runtimeTypeof" });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var FORBIDDEN_SYMBOL_NAME = "shape";
-function containsForbiddenSymbolName(name) {
-  return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
-}
-var noForbiddenTermInSymbolNamesRule = defineRule9({
-  meta: {
-    type: "problem",
-    docs: {
-      description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.'
-    },
-    messages: {
-      forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.'
-    }
-  },
-  createOnce(context) {
-    const reportForbiddenSymbolName = (node) => {
-      if (!containsForbiddenSymbolName(node.name))
-        return;
-      context.report({
-        node,
-        messageId: "forbiddenSymbolName",
-        data: { name: node.name }
-      });
-    };
-    return {
-      Identifier: reportForbiddenSymbolName,
-      PrivateIdentifier: reportForbiddenSymbolName,
-      JSXIdentifier: reportForbiddenSymbolName
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-unknown-parameters.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
-function parameterAnnotation2(parameter) {
-  if (parameter.type === "TSParameterProperty") {
-    return parameterAnnotation2(parameter.parameter);
-  }
-  if (parameter.type === "RestElement") {
-    return parameter.typeAnnotation ?? parameterAnnotation2(parameter.argument);
-  }
-  if (parameter.type === "AssignmentPattern") {
-    return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
-  }
-  return parameter.typeAnnotation;
-}
-function parameterName2(parameter, sourceText) {
-  if (parameter.type === "TSParameterProperty") {
-    return parameterName2(parameter.parameter, sourceText);
-  }
-  if (parameter.type === "AssignmentPattern") {
-    return parameterName2(parameter.left, sourceText);
-  }
-  if (parameter.type === "RestElement") {
-    return parameterName2(parameter.argument, sourceText);
-  }
-  return parameter.type === "Identifier" ? parameter.name : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
-}
-var noUnknownParametersRule = defineRule10({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow explicitly unknown function parameters except `error` and `cause`; decode unknown input at its I/O boundary instead."
-    },
-    messages: {
-      unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function."
-    }
-  },
-  createOnce(context) {
-    const checkParameters = (node) => {
-      for (const parameter of node.params) {
-        const annotation = parameterAnnotation2(parameter);
-        if (annotation?.typeAnnotation.type !== "TSUnknownKeyword")
-          continue;
-        const name = parameterName2(parameter, context.sourceCode.getText(parameter));
-        if (name === "cause" || name === "error")
-          continue;
-        context.report({
-          node: annotation.typeAnnotation,
-          messageId: "unknownParameter",
-          data: { parameter: name }
-        });
-      }
-    };
-    return {
-      ArrowFunctionExpression: checkParameters,
-      FunctionDeclaration: checkParameters,
-      FunctionExpression: checkParameters,
-      TSCallSignatureDeclaration: checkParameters,
-      TSConstructSignatureDeclaration: checkParameters,
-      TSConstructorType: checkParameters,
-      TSDeclareFunction: checkParameters,
-      TSEmptyBodyFunctionExpression: checkParameters,
-      TSFunctionType: checkParameters,
-      TSMethodSignature: checkParameters
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-unknown-returns.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
-function referencedAliasName(type) {
-  if (type.type === "TSParenthesizedType")
-    return referencedAliasName(type.typeAnnotation);
-  if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier")
-    return null;
-  return type.typeArguments === null || type.typeArguments === undefined || type.typeArguments.params.length === 0 ? type.typeName.name : null;
-}
-var noUnknownReturnsRule = defineRule11({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>."
-    },
-    messages: {
-      unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type."
-    }
-  },
-  createOnce(context) {
-    const aliases = new Map;
-    const resolvesToUnknown = (type, shadowedAliases, visited = new Set) => {
-      if (type.type === "TSUnknownKeyword")
-        return true;
-      if (type.type === "TSParenthesizedType") {
-        return resolvesToUnknown(type.typeAnnotation, shadowedAliases, visited);
-      }
-      if (type.type === "TSUnionType") {
-        return type.types.some((member) => resolvesToUnknown(member, shadowedAliases, visited));
-      }
-      if (type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike")) {
-        const value = type.typeArguments?.params[0];
-        return value !== undefined && resolvesToUnknown(value, shadowedAliases, visited);
-      }
-      const name = referencedAliasName(type);
-      if (name === null || visited.has(name) || shadowedAliases.has(name))
-        return false;
-      const alias = aliases.get(name);
-      if (alias === undefined || alias.typeParameters !== null && alias.typeParameters !== undefined) {
-        return false;
-      }
-      const nextVisited = new Set(visited);
-      nextVisited.add(name);
-      return resolvesToUnknown(alias.typeAnnotation, shadowedAliases, nextVisited);
-    };
-    const checkReturnType = (node) => {
-      const annotation = node.returnType;
-      if (annotation === null || annotation === undefined)
-        return;
-      if (!resolvesToUnknown(annotation.typeAnnotation, lexicalTypeParameterNames(node, context.sourceCode.visitorKeys))) {
-        return;
-      }
-      context.report({
-        node: annotation.typeAnnotation,
-        messageId: "unknownReturn"
-      });
-    };
-    return {
-      Program(node) {
-        aliases.clear();
-        for (const statement of node.body) {
-          const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-          if (declaration?.type === "TSTypeAliasDeclaration") {
-            aliases.set(declaration.id.name, declaration);
-          }
-        }
-      },
-      ArrowFunctionExpression: checkReturnType,
-      FunctionDeclaration: checkReturnType,
-      FunctionExpression: checkReturnType,
-      TSCallSignatureDeclaration: checkReturnType,
-      TSConstructSignatureDeclaration: checkReturnType,
-      TSConstructorType: checkReturnType,
-      TSDeclareFunction: checkReturnType,
-      TSEmptyBodyFunctionExpression: checkReturnType,
-      TSFunctionType: checkReturnType,
-      TSMethodSignature: checkReturnType
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-function referencedAliasName2(type) {
-  if (type.type === "TSParenthesizedType")
-    return referencedAliasName2(type.typeAnnotation);
-  if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier")
-    return null;
-  return type.typeArguments === null || type.typeArguments === undefined || type.typeArguments.params.length === 0 ? type.typeName.name : null;
-}
-var noUnknownTypeAliasesRule = defineRule12({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary."
-    },
-    messages: {
-      unknownAlias: "Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type."
-    }
-  },
-  createOnce(context) {
-    const aliases = new Map;
-    const resolvesToUnknown = (type, visited = new Set) => {
-      if (type.type === "TSUnknownKeyword")
-        return true;
-      if (type.type === "TSParenthesizedType")
-        return resolvesToUnknown(type.typeAnnotation, visited);
-      const name = referencedAliasName2(type);
-      if (name === null || visited.has(name))
-        return false;
-      const alias = aliases.get(name);
-      if (alias === undefined || alias.typeParameters !== null && alias.typeParameters !== undefined) {
-        return false;
-      }
-      const nextVisited = new Set(visited);
-      nextVisited.add(name);
-      return resolvesToUnknown(alias.typeAnnotation, nextVisited);
-    };
-    return {
-      Program(node) {
-        aliases.clear();
-        for (const statement of node.body) {
-          const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
-          if (declaration?.type === "TSTypeAliasDeclaration") {
-            aliases.set(declaration.id.name, declaration);
-          }
-        }
-        for (const alias of aliases.values()) {
-          if (!resolvesToUnknown(alias.typeAnnotation, new Set([alias.id.name])))
-            continue;
-          context.report({
-            node: alias.id,
-            messageId: "unknownAlias",
-            data: { alias: alias.id.name }
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var typeNodeKinds = new Set([
-  "JSDocNonNullableType",
-  "JSDocNullableType",
-  "JSDocUnknownType",
-  "TSAnyKeyword",
-  "TSArrayType",
-  "TSBigIntKeyword",
-  "TSBooleanKeyword",
-  "TSConditionalType",
-  "TSConstructorType",
-  "TSFunctionType",
-  "TSImportType",
-  "TSIndexedAccessType",
-  "TSInferType",
-  "TSIntersectionType",
-  "TSIntrinsicKeyword",
-  "TSLiteralType",
-  "TSMappedType",
-  "TSNamedTupleMember",
-  "TSNeverKeyword",
-  "TSNullKeyword",
-  "TSNumberKeyword",
-  "TSObjectKeyword",
-  "TSParenthesizedType",
-  "TSStringKeyword",
-  "TSSymbolKeyword",
-  "TSTemplateLiteralType",
-  "TSThisType",
-  "TSTupleType",
-  "TSTypeLiteral",
-  "TSTypeOperator",
-  "TSTypePredicate",
-  "TSTypeQuery",
-  "TSTypeReference",
-  "TSUndefinedKeyword",
-  "TSUnionType",
-  "TSUnknownKeyword",
-  "TSVoidKeyword"
-]);
-function isTypeNode(node) {
-  return typeNodeKinds.has(node.type);
-}
-function typeReferenceName2(type) {
-  return type.typeName.type === "Identifier" ? type.typeName.name : null;
-}
-function isInsideTypeAliasDeclaration(node) {
-  let current = node.parent;
-  while (current !== null && current.type !== "Program") {
-    if (current.type === "TSTypeAliasDeclaration")
-      return true;
-    current = current.parent;
-  }
-  return false;
-}
-function isPlainAliasConsumerUse(node, environment) {
-  if (node.type !== "TSTypeReference" || node.typeArguments?.params.length)
-    return false;
-  const name = typeReferenceName2(node);
-  return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
-}
-function shouldReportType(node, environment) {
-  if (isPlainAliasConsumerUse(node, environment))
-    return false;
-  if (classifyUnsafeDictionary(node, environment) === null)
-    return false;
-  let current = node.parent;
-  while (current !== null && current.type !== "Program") {
-    if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null)
-      return false;
-    current = current.parent;
-  }
-  return true;
-}
-var noUnsafeDictionaryTypeRule = defineRule13({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches."
-    },
-    messages: {
-      unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion."
-    }
-  },
-  createOnce(context) {
-    let environment = null;
-    const report = (node, value) => {
-      context.report({ node, messageId: "unsafeDictionary", data: { value } });
-    };
-    const reportIfUnsafe = (node) => {
-      if (environment === null || !shouldReportType(node, environment))
-        return;
-      const unsafe = classifyUnsafeDictionary(node, environment);
-      if (unsafe === null)
-        return;
-      report(node, unsafe.unsafeValue);
-    };
-    return {
-      Program(node) {
-        environment = createTypeEnvironment(node);
-      },
-      TSTypeReference: reportIfUnsafe,
-      TSTypeLiteral: reportIfUnsafe,
-      TSMappedType: reportIfUnsafe,
-      TSIndexSignature(node) {
-        if (environment === null || node.typeAnnotation === null || node.parent.type === "TSTypeLiteral")
-          return;
-        const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
-        if (unsafe !== null)
-          report(node, unsafe.unsafeValue);
-      }
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/no-widen-then-assert.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var functionBoundaryTypes = new Set([
-  "ArrowFunctionExpression",
-  "FunctionDeclaration",
-  "FunctionExpression",
-  "TSDeclareFunction",
-  "TSEmptyBodyFunctionExpression"
-]);
-function unwrapExpressionParentheses(expression) {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression")
-    current = current.expression;
-  return current;
-}
-function unwrapTypeParentheses(type) {
-  let current = type;
-  while (current.type === "TSParenthesizedType")
-    current = current.typeAnnotation;
-  return current;
-}
-function typeReferenceName3(type) {
-  return type.typeName.type === "Identifier" ? type.typeName.name : null;
-}
-function isUnknownOrAnyType(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  return unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword";
-}
-function isBroadRecordKeyType(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") {
-    return true;
-  }
-  if (unwrapped.type === "TSUnionType")
-    return unwrapped.types.every(isBroadRecordKeyType);
-  return unwrapped.type === "TSTypeReference" && typeReferenceName3(unwrapped) === "PropertyKey";
-}
-function isBroadRecordType(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  if (unwrapped.type === "TSTypeReference") {
-    if (typeReferenceName3(unwrapped) === "Readonly") {
-      const [inner] = unwrapped.typeArguments?.params ?? [];
-      return inner !== undefined && isBroadRecordType(inner);
-    }
-    if (typeReferenceName3(unwrapped) !== "Record")
-      return false;
-    const parameters = unwrapped.typeArguments?.params ?? [];
-    return parameters.length === 2 && parameters[0] !== undefined && parameters[1] !== undefined && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
-  }
-  if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1)
-    return false;
-  const [member] = unwrapped.members;
-  const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
-  return member?.type === "TSIndexSignature" && member.parameters.length === 1 && parameter !== undefined && isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
-}
-function broadTypeKind(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword")
-    return "top";
-  if (unwrapped.type === "TSObjectKeyword")
-    return "object";
-  return isBroadRecordType(unwrapped) ? "record" : null;
-}
-function assertedExpression(node) {
-  return unwrapExpressionParentheses(node.expression);
-}
-function assertionFromExpression(expression) {
-  const unwrapped = unwrapExpressionParentheses(expression);
-  return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
-}
-function normalizedTypeText(sourceText, type) {
-  return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
-}
-function typesHaveSameSyntax(sourceText, left, right) {
-  return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
-}
-function isDefinitelyObjectType(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  switch (unwrapped.type) {
-    case "TSArrayType":
-    case "TSConstructorType":
-    case "TSFunctionType":
-    case "TSMappedType":
-    case "TSObjectKeyword":
-    case "TSTupleType":
-      return true;
-    case "TSTypeLiteral":
-      return unwrapped.members.length > 0;
-    case "TSIntersectionType":
-      return unwrapped.types.every(isDefinitelyObjectType);
-    case "TSTypeOperator":
-      return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
-    default:
-      return false;
-  }
-}
-function isDefinitelyNarrowerRecordType(type) {
-  const unwrapped = unwrapTypeParentheses(type);
-  if (unwrapped.type === "TSTypeLiteral") {
-    return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
-  }
-  if (unwrapped.type !== "TSTypeReference")
-    return false;
-  if (typeReferenceName3(unwrapped) === "Readonly") {
-    const [inner] = unwrapped.typeArguments?.params ?? [];
-    return inner !== undefined && isDefinitelyNarrowerRecordType(inner);
-  }
-  if (typeReferenceName3(unwrapped) !== "Record")
-    return false;
-  const parameters = unwrapped.typeArguments?.params ?? [];
-  return parameters.length === 2 && parameters[1] !== undefined && !isUnknownOrAnyType(parameters[1]);
-}
-function functionBoundary(node) {
-  let current = node.parent;
-  while (current !== null && current.type !== "Program") {
-    if (functionBoundaryTypes.has(current.type))
-      return current;
-    current = current.parent;
-  }
-  return null;
-}
-function resolvedVariableForIdentifier(scopes, identifier) {
-  for (const scope of scopes) {
-    const reference = scope.references.find((candidate) => candidate.identifier.start === identifier.start && candidate.identifier.end === identifier.end);
-    if (reference !== undefined)
-      return reference.resolved;
-  }
-  return null;
-}
-function variableDeclarator2(variable) {
-  for (const definition of variable.defs) {
-    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") {
-      return definition.node;
-    }
-  }
-  return null;
-}
-function knownValueEvidence(expression, scopes, boundary, visitedVariables) {
-  const unwrapped = unwrapExpressionParentheses(expression);
-  if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
-    if (broadTypeKind(unwrapped.typeAnnotation) !== null)
-      return null;
-    return { type: unwrapped.typeAnnotation };
-  }
-  if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") {
-    return { type: null };
-  }
-  if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") {
-    return { type: null };
-  }
-  if (unwrapped.type !== "Identifier")
-    return null;
-  const variable = resolvedVariableForIdentifier(scopes, unwrapped);
-  if (variable === null || visitedVariables.has(variable))
-    return null;
-  const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== undefined);
-  const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
-  if (annotation !== undefined && annotatedIdentifier !== undefined) {
-    if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) {
-      return null;
-    }
-    return { type: annotation };
-  }
-  const declarator = variableDeclarator2(variable);
-  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) {
-    return null;
-  }
-  return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
-}
-function widenedBinding(variable, scopes) {
-  const declarator = variableDeclarator2(variable);
-  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) {
-    return null;
-  }
-  const boundary = functionBoundary(declarator);
-  const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
-  const initializerAssertion = assertionFromExpression(declarator.init);
-  const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
-  const declaredBroadKind = declaredType === undefined ? null : broadTypeKind(declaredType);
-  const broadKind = declaredBroadKind ?? initializerBroadKind;
-  if (broadKind === null)
-    return null;
-  const originalExpression = initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init;
-  const evidence = knownValueEvidence(originalExpression, scopes, boundary, new Set([variable]));
-  return evidence === null ? null : { broadKind, evidence, declaredAt: declarator.end, boundary };
-}
-function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
-  if (broadTypeKind(assertedType) !== null)
-    return false;
-  if (broadKind === "top")
-    return true;
-  if (typesHaveSameSyntax(sourceText, evidence.type, assertedType))
-    return true;
-  if (broadKind === "object")
-    return isDefinitelyObjectType(assertedType);
-  return isDefinitelyNarrowerRecordType(assertedType);
-}
-var noWidenThenAssertRule = defineRule14({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type."
-    },
-    messages: {
-      widenThenAssert: 'Binding "{{name}}" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once.'
-    }
-  },
-  createOnce(context) {
-    let scopes = [];
-    const checkAssertion = (node) => {
-      const expression = assertedExpression(node);
-      if (expression.type !== "Identifier")
-        return;
-      const variable = resolvedVariableForIdentifier(scopes, expression);
-      if (variable === null)
-        return;
-      const widened = widenedBinding(variable, scopes);
-      if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) {
-        return;
-      }
-      context.report({
-        node,
-        messageId: "widenThenAssert",
-        data: { name: expression.name }
-      });
-    };
-    return {
-      Program() {
-        scopes = context.sourceCode.scopeManager.scopes;
-      },
-      TSAsExpression: checkAssertion,
-      TSTypeAssertion: checkAssertion
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var commentOwnerKinds = new Set([
-  "ExpressionStatement",
-  "PropertyDefinition",
-  "ReturnStatement",
-  "ThrowStatement",
-  "VariableDeclaration"
-]);
-function isConstAssertion2(node) {
-  return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
-}
-function hasSafetyComment(sourceCode, node) {
-  let current = node;
-  while (true) {
-    if (sourceCode.getCommentsBefore(current).some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))) {
-      return true;
-    }
-    if (commentOwnerKinds.has(current.type) && current.parent.type !== "ExportNamedDeclaration" && current.parent.type !== "ExportDefaultDeclaration" || current.parent.type === "Program")
-      return false;
-    current = current.parent;
-  }
-}
-var requireSafetyCommentForTypeAssertionRule = defineRule15({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require a nearby SAFETY comment for every TypeScript type assertion except const assertions."
-    },
-    messages: {
-      missingSafetyComment: "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement."
-    }
-  },
-  createOnce(context) {
-    const checkAssertion = (node) => {
-      if (isConstAssertion2(node) || hasSafetyComment(context.sourceCode, node))
-        return;
-      context.report({ node, messageId: "missingSafetyComment" });
-    };
-    return {
-      TSAsExpression: checkAssertion,
-      TSTypeAssertion: checkAssertion
-    };
-  }
-});
-
-// src/rules/dillon-anti-slop/index.ts
-var dillonAntiSlopPlugin = eslintCompatPlugin({
-  meta: { name: "dillon-anti-slop" },
-  rules: {
-    "no-chained-type-assertions": noChainedTypeAssertionsRule,
-    "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
-    "no-known-value-widening": noKnownValueWideningRule,
-    "no-module-mocking": noModuleMockingRule,
-    "no-object-parameters": noObjectParametersRule,
-    "no-reflect-apply": noReflectApplyRule,
-    "no-reflect-get": noReflectGetRule,
-    "no-runtime-typeof": noRuntimeTypeofRule,
-    "no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
-    "no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
-    "no-unknown-parameters": noUnknownParametersRule,
-    "no-unknown-returns": noUnknownReturnsRule,
-    "no-unknown-type-aliases": noUnknownTypeAliasesRule,
-    "no-widen-then-assert": noWidenThenAssertRule,
-    "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule
-  }
-});
-var dillon_anti_slop_default = dillonAntiSlopPlugin;
-export {
-  dillon_anti_slop_default as default
-};