@sarj/eslint-plugin 9.13.0 → 9.14.0

package/dist/index.js

@@ -13,9 +13,10 @@ var createRule = ESLintUtils.RuleCreator(examplesUrl);
 var SCRIPT_FILE_RE = /([\\/]scripts[\\/])|(\.mjs$)/;
 var STORY_FILE_RE = /\.stories\.[cm]?[jt]sx?$/i;
 var STORY_TREE_RE = /(^|\/)stories(?:[_-][^/]*)?\//i;
-var GENERATED_FILE_RE = /([\\/](?:generated|openapi-gen|graphql[\\/]types|vendor|vendored|third[-_]?party)[\\/])|(\.gen\.[cm]?[jt]sx?$)|(\.generated\.[cm]?[jt]sx?$)|(\.d\.[cm]?ts$)|(\.types\.[cm]?ts$)/;
+var GENERATED_FILE_RE = /((?:^|[\\/])(?:generated|__generated__|openapi-gen|graphql[\\/]types|vendor|vendored|third[-_]?party)[\\/])|(\.gen\.[cm]?[jt]sx?$)|(\.generated\.[cm]?[jt]sx?$)|(\.d\.[cm]?ts$)|(\.types\.[cm]?ts$)/i;
 var EXTERNAL_TREE_RE = /[\\/]external[\\/]/;
 var GENERATED_MARKER_RE = /(?:@generated\b|this file (?:is|was|has been)[\w\s,'-]{0,40}?generated|auto-?generated file\b|generated (?:with|by)|generated (?:graphql )?types|do not edit(?: directly| manually)?|do not (?:modify|change) this file)/i;
+var COMMENT_LINE_RE = /^\s*(?:\/\/|\/\*+|\*|#)/;
 var TEST_BASENAME_RE = /[.\-_](test|spec|e2e)\.[cm]?[jt]sx?$/;
 var TEST_INTEGRATION_BASENAME_RE = /\.integration\.[cm]?[jt]sx?$/;
 var TEST_DIR_RE = /(^|\/)(tests?|__tests__|__mocks__|fixtures|__fixtures__|__testfixtures__|e2e|integration)\//;
@@ -46,7 +47,7 @@ function isGeneratedFile(filename, sourceText = "", gates = []) {
   if (gates.includes("externalTree") && EXTERNAL_TREE_RE.test(normalized)) {
     return true;
   }
-  return GENERATED_MARKER_RE.test(sourceText.slice(0, 2048));
+  return sourceText.slice(0, 2048).split("\n").some((line) => COMMENT_LINE_RE.test(line) && GENERATED_MARKER_RE.test(line));
 }
 function isScriptFile(filename) {
   return SCRIPT_FILE_RE.test(filename);
@@ -3141,6 +3142,202 @@ var no_long_comment_default = createRule({
   }
 });
 
+// src/rules/no-generic-single-export-module.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES14, ASTUtils as ASTUtils2 } from "@typescript-eslint/utils";
+var GENERIC_STEMS = /* @__PURE__ */ new Set([
+  "base",
+  "common",
+  "constant",
+  "constants",
+  "core",
+  "enum",
+  "enums",
+  "helper",
+  "helpers",
+  "misc",
+  "model",
+  "models",
+  "shared",
+  "stuff",
+  "type",
+  "types",
+  "util",
+  "utils"
+]);
+var CONVENTIONAL_STEMS = /* @__PURE__ */ new Set(["base", "models"]);
+var CJS_OBJECT_EXPORT_METHODS = /* @__PURE__ */ new Set(["assign", "defineProperties", "defineProperty"]);
+function fileParts(filename) {
+  const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
+  const extension = base.match(/(\.[cm]?[jt]sx?)$/u)?.[1] ?? ".ts";
+  const segments = base.slice(0, -extension.length).split(".");
+  return {
+    extension,
+    stem: segments[0]?.toLowerCase() ?? "",
+    suffixes: segments.slice(1)
+  };
+}
+function declaredNames(declaration) {
+  if (declaration.declare === true) return [];
+  if (declaration.type === AST_NODE_TYPES14.FunctionDeclaration || declaration.type === AST_NODE_TYPES14.ClassDeclaration || declaration.type === AST_NODE_TYPES14.TSEnumDeclaration) {
+    if (declaration.type === AST_NODE_TYPES14.TSEnumDeclaration && declaration.const) return [];
+    return declaration.id === null ? [] : [declaration.id.name];
+  }
+  if (declaration.type === AST_NODE_TYPES14.TSModuleDeclaration && declaration.id.type === AST_NODE_TYPES14.Identifier) {
+    return [declaration.id.name];
+  }
+  if (declaration.type !== AST_NODE_TYPES14.VariableDeclaration) return [];
+  return declaration.declarations.flatMap(
+    (item) => item.id.type === AST_NODE_TYPES14.Identifier ? [item.id.name] : []
+  );
+}
+function typeOnlyBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  const runtimeNames = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES14.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES14.TSInterfaceDeclaration || declaration?.type === AST_NODE_TYPES14.TSTypeAliasDeclaration) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration?.type === AST_NODE_TYPES14.TSEnumDeclaration && declaration.const) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (statement.type === AST_NODE_TYPES14.ImportDeclaration) {
+      for (const specifier of statement.specifiers) {
+        if (statement.importKind === "type" || specifier.type === AST_NODE_TYPES14.ImportSpecifier && specifier.importKind === "type") {
+          names.add(specifier.local.name);
+        } else {
+          runtimeNames.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    if (declaration?.type === AST_NODE_TYPES14.TSDeclareFunction && declaration.id !== null) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration !== null && declaration.declare === true) {
+      if ((declaration.type === AST_NODE_TYPES14.ClassDeclaration || declaration.type === AST_NODE_TYPES14.FunctionDeclaration || declaration.type === AST_NODE_TYPES14.TSEnumDeclaration || declaration.type === AST_NODE_TYPES14.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === AST_NODE_TYPES14.Identifier) names.add(declaration.id.name);
+      if (declaration.type === AST_NODE_TYPES14.VariableDeclaration) {
+        for (const item of declaration.declarations) {
+          if (item.id.type === AST_NODE_TYPES14.Identifier) names.add(item.id.name);
+        }
+      }
+      continue;
+    }
+    if (declaration !== null && "type" in declaration) {
+      for (const name of declaredNames(declaration)) {
+        runtimeNames.add(name);
+      }
+    }
+  }
+  return new Set([...names].filter((name) => !runtimeNames.has(name)));
+}
+function runtimeExports(program) {
+  const exports = [];
+  const typeBindings = typeOnlyBindings(program);
+  let ambiguous = false;
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES14.ExportAllDeclaration) {
+      if (statement.exportKind !== "type") ambiguous = true;
+      continue;
+    }
+    if (statement.type === AST_NODE_TYPES14.ExportDefaultDeclaration) {
+      const declaration = statement.declaration;
+      if (declaration.type === AST_NODE_TYPES14.Identifier) {
+        if (!typeBindings.has(declaration.name)) {
+          exports.push({ key: "default", name: declaration.name, node: statement });
+        }
+      } else if ((declaration.type === AST_NODE_TYPES14.FunctionDeclaration || declaration.type === AST_NODE_TYPES14.ClassDeclaration) && declaration.id !== null && declaration.declare !== true) exports.push({ key: "default", name: declaration.id.name, node: declaration });
+      else if (declaration.type !== AST_NODE_TYPES14.TSInterfaceDeclaration && declaration.type !== AST_NODE_TYPES14.TSTypeAliasDeclaration) ambiguous = true;
+      continue;
+    }
+    if (statement.type !== AST_NODE_TYPES14.ExportNamedDeclaration || statement.exportKind === "type") continue;
+    if (statement.source !== null) {
+      if (statement.specifiers.some((specifier) => specifier.exportKind !== "type")) ambiguous = true;
+      continue;
+    }
+    if (statement.declaration !== null) {
+      const declaration = statement.declaration;
+      exports.push(...declaredNames(declaration).map((name) => ({ key: name, name, node: declaration })));
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.exportKind === "type" || typeBindings.has(specifier.local.name)) continue;
+      const exported = specifier.exported.type === AST_NODE_TYPES14.Identifier ? specifier.exported.name : specifier.exported.value;
+      const local = specifier.local.name;
+      exports.push({ key: exported, name: exported === "default" ? local : exported, node: specifier });
+    }
+  }
+  const unique = new Map(exports.map((entry) => [entry.key, entry]));
+  return { exports: [...unique.values()], ambiguous };
+}
+function kebabCase(name) {
+  return name.replaceAll(/oauth/giu, "Oauth").replaceAll(/graphql/giu, "Graphql").replaceAll(/grpc/giu, "Grpc").replaceAll(/([a-z\d])([A-Z])/gu, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/gu, "$1-$2").replaceAll(/[_\s]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/^-|-$/gu, "").toLowerCase();
+}
+function isGlobalIdentifier(context, node) {
+  const variable = ASTUtils2.findVariable(context.sourceCode.getScope(node), node.name);
+  return variable === null || variable.defs.length === 0;
+}
+function isConventionalFrameworkUtility(filename, exported) {
+  const normalized = filename.replaceAll("\\", "/");
+  return exported === "cn" && /(?:^|\/)lib\/utils\.[cm]?[jt]sx?$/u.test(normalized);
+}
+function memberPropertyName(node) {
+  if (!node.computed && node.property.type === AST_NODE_TYPES14.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES14.Literal && typeof node.property.value === "string" ? node.property.value : null;
+}
+var no_generic_single_export_module_default = createRule({
+  name: "no-generic-single-export-module",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Disallow generic module stems when one runtime export already names the responsibility." },
+    schema: [],
+    messages: {
+      genericSingleExport: "Module stem `{{stem}}` is generic and its only runtime export is `{{exported}}`; rename the file to `{{expected}}`."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const file = fileParts(context.filename);
+    const { stem: stem3 } = file;
+    if (!GENERIC_STEMS.has(stem3) || CONVENTIONAL_STEMS.has(stem3) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    let hasCommonJsExport = false;
+    return {
+      CallExpression(node) {
+        const first = node.arguments[0];
+        if (first?.type === AST_NODE_TYPES14.Identifier && first.name === "exports" && isGlobalIdentifier(context, first) && node.callee.type === AST_NODE_TYPES14.MemberExpression && node.callee.object.type === AST_NODE_TYPES14.Identifier && node.callee.object.name === "Object" && isGlobalIdentifier(context, node.callee.object) && memberPropertyName(node.callee) !== null && CJS_OBJECT_EXPORT_METHODS.has(memberPropertyName(node.callee))) hasCommonJsExport = true;
+      },
+      MemberExpression(node) {
+        if (node.object.type === AST_NODE_TYPES14.Identifier && node.object.name === "exports" && isGlobalIdentifier(context, node.object)) hasCommonJsExport = true;
+        if (node.object.type === AST_NODE_TYPES14.Identifier && node.object.name === "module" && isGlobalIdentifier(context, node.object) && memberPropertyName(node) === "exports") hasCommonJsExport = true;
+      },
+      "Program:exit"(program) {
+        if (hasCommonJsExport) return;
+        const exports = runtimeExports(program);
+        if (exports.ambiguous || exports.exports.length !== 1) return;
+        const onlyExport = exports.exports[0];
+        if (onlyExport === void 0) return;
+        const { name: exported, node } = onlyExport;
+        if (isConventionalFrameworkUtility(context.filename, exported)) return;
+        const expectedStem = kebabCase(exported);
+        const suffixStem = file.suffixes.map(kebabCase).join("-");
+        const currentResponsibility = [stem3, suffixStem].filter(Boolean).join("-");
+        if (expectedStem === currentResponsibility || GENERIC_STEMS.has(expectedStem) || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(expectedStem)) return;
+        const suffixTail = suffixStem === "" ? "" : `-${suffixStem}`;
+        const renameStem = suffixTail !== "" && expectedStem.endsWith(suffixTail) ? expectedStem.slice(0, -suffixTail.length) : expectedStem;
+        if (renameStem === "" || GENERIC_STEMS.has(renameStem)) return;
+        const suffix = file.suffixes.map((part) => `.${kebabCase(part)}`).join("");
+        context.report({
+          node,
+          messageId: "genericSingleExport",
+          data: { stem: stem3, exported, expected: `${renameStem}${suffix}${file.extension}` }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/no-offset-pagination.ts
 import "@typescript-eslint/utils";
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
@@ -3172,60 +3369,57 @@ var no_offset_pagination_default = createRule({
 });
 
 // src/rules/no-positional-tuple-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES15 } from "@typescript-eslint/utils";
 var MIN_ELEMENTS = 2;
-var ACCESSOR_PAIR_LENGTH = 2;
-var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited"]);
-function tupleReturnType(node) {
-  if (node.type === AST_NODE_TYPES14.TSTupleType) {
+var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited", "Readonly"]);
+function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
+  if (node.type === AST_NODE_TYPES15.TSTupleType) {
     return node;
   }
-  if (node.type === AST_NODE_TYPES14.TSTypeReference && node.typeName.type === AST_NODE_TYPES14.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
-    const argument = node.typeArguments?.params[0];
-    return argument === void 0 ? null : tupleReturnType(argument);
+  if (node.type === AST_NODE_TYPES15.TSTypeReference && node.typeName.type === AST_NODE_TYPES15.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+    const argument = node.typeArguments?.params.at(0);
+    return argument === void 0 ? null : tupleReturnType(argument, aliases, resolving);
   }
-  return null;
-}
-function normalizedText(sourceCode, node) {
-  return sourceCode.getText(node).replaceAll(/\s+/g, " ").trim();
-}
-function isPermittedTuple(tuple, sourceCode) {
-  const elements = tuple.elementTypes;
-  if (elements.length < MIN_ELEMENTS) {
-    return true;
+  if (node.type === AST_NODE_TYPES15.TSTypeReference && node.typeName.type === AST_NODE_TYPES15.Identifier && !resolving.has(node.typeName.name)) {
+    const target = aliases.get(node.typeName.name);
+    if (target !== void 0) return tupleReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
   }
-  if (elements.some((element) => element.type === AST_NODE_TYPES14.TSRestType)) {
-    return true;
-  }
-  if (elements.some((element) => element.type === AST_NODE_TYPES14.TSNamedTupleMember)) {
-    return true;
+  if (node.type === AST_NODE_TYPES15.TSTypeOperator && node.operator === "readonly") {
+    return node.typeAnnotation === void 0 ? null : tupleReturnType(node.typeAnnotation, aliases, resolving);
   }
-  if (elements[0]?.type === AST_NODE_TYPES14.TSLiteralType) {
-    return true;
-  }
-  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === AST_NODE_TYPES14.TSFunctionType)) {
-    return true;
+  if (node.type === AST_NODE_TYPES15.TSUnionType || node.type === AST_NODE_TYPES15.TSIntersectionType) {
+    for (const member of node.types) {
+      const tuple = tupleReturnType(member, aliases, resolving);
+      if (tuple !== null) return tuple;
+    }
   }
-  const texts = new Set(elements.map((element) => normalizedText(sourceCode, element)));
-  return texts.size === 1;
+  return null;
 }
 function functionName(node) {
-  if (node.type === AST_NODE_TYPES14.FunctionDeclaration) {
-    return node.id?.name ?? null;
+  if (node.type === AST_NODE_TYPES15.FunctionDeclaration) {
+    if (node.id !== null) return node.id.name;
+    return node.parent?.type === AST_NODE_TYPES15.ExportDefaultDeclaration ? "default" : null;
   }
-  const parent = node.parent;
-  if (parent?.type === AST_NODE_TYPES14.VariableDeclarator && parent.id.type === AST_NODE_TYPES14.Identifier) {
+  let wrapped = node;
+  while ((wrapped.parent?.type === AST_NODE_TYPES15.TSAsExpression || wrapped.parent?.type === AST_NODE_TYPES15.TSSatisfiesExpression || wrapped.parent?.type === AST_NODE_TYPES15.TSNonNullExpression) && wrapped.parent.expression === wrapped) {
+    wrapped = wrapped.parent;
+  }
+  const parent = wrapped.parent;
+  if (parent?.type === AST_NODE_TYPES15.ExportDefaultDeclaration) return "default";
+  if (parent?.type === AST_NODE_TYPES15.VariableDeclarator && parent.id.type === AST_NODE_TYPES15.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === AST_NODE_TYPES14.MethodDefinition || parent?.type === AST_NODE_TYPES14.PropertyDefinition || parent?.type === AST_NODE_TYPES14.Property) && parent.key.type === AST_NODE_TYPES14.Identifier) {
+  if ((parent?.type === AST_NODE_TYPES15.MethodDefinition || parent?.type === AST_NODE_TYPES15.TSAbstractMethodDefinition || parent?.type === AST_NODE_TYPES15.PropertyDefinition || parent?.type === AST_NODE_TYPES15.Property) && parent.key.type === AST_NODE_TYPES15.Identifier) {
+    if ((parent.type === AST_NODE_TYPES15.MethodDefinition || parent.type === AST_NODE_TYPES15.TSAbstractMethodDefinition || parent.type === AST_NODE_TYPES15.PropertyDefinition) && (parent.accessibility === "private" || parent.accessibility === "protected")) return null;
     return parent.key.name;
   }
   return null;
 }
 function isInlineExported(node) {
+  if (moduleScopeBindingName(node) === null) return false;
   for (let current = node; current != null; current = current.parent) {
     const parent = current.parent;
-    if (parent?.type === AST_NODE_TYPES14.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES14.ExportDefaultDeclaration) {
+    if (parent?.type === AST_NODE_TYPES15.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES15.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -3233,46 +3427,154 @@ function isInlineExported(node) {
 }
 function moduleScopeBindingName(node) {
   let current = node;
-  let child = node;
-  while (current.parent != null && current.parent.type !== AST_NODE_TYPES14.Program) {
-    child = current;
+  while (current.parent != null && current.parent.type !== AST_NODE_TYPES15.Program) {
     current = current.parent;
   }
-  if (current.parent?.type !== AST_NODE_TYPES14.Program) {
+  if (current.parent?.type !== AST_NODE_TYPES15.Program) {
     return null;
   }
-  if (current.type === AST_NODE_TYPES14.FunctionDeclaration || current.type === AST_NODE_TYPES14.ClassDeclaration) {
-    return current.id?.name ?? null;
+  let topLevel = current;
+  if (current.type === AST_NODE_TYPES15.ExportNamedDeclaration || current.type === AST_NODE_TYPES15.ExportDefaultDeclaration) {
+    topLevel = current.declaration;
   }
-  if (current.type === AST_NODE_TYPES14.VariableDeclaration) {
-    if (child.type !== AST_NODE_TYPES14.VariableDeclarator || child.id.type !== AST_NODE_TYPES14.Identifier) {
-      return null;
+  if (topLevel === null) return null;
+  if (topLevel.type === AST_NODE_TYPES15.FunctionDeclaration) {
+    if (topLevel !== node) return null;
+    return topLevel.id?.name ?? (current.type === AST_NODE_TYPES15.ExportDefaultDeclaration ? "default" : null);
+  }
+  if ((topLevel.type === AST_NODE_TYPES15.ArrowFunctionExpression || topLevel.type === AST_NODE_TYPES15.FunctionExpression) && topLevel === node && current.type === AST_NODE_TYPES15.ExportDefaultDeclaration) {
+    return "default";
+  }
+  if (topLevel.type === AST_NODE_TYPES15.ClassDeclaration) {
+    let owner = node.parent;
+    while (owner !== void 0 && owner.parent !== topLevel.body) owner = owner.parent;
+    return (owner?.type === AST_NODE_TYPES15.MethodDefinition || owner?.type === AST_NODE_TYPES15.TSAbstractMethodDefinition || owner?.type === AST_NODE_TYPES15.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === AST_NODE_TYPES15.ExportDefaultDeclaration ? "default" : null) : null;
+  }
+  if (topLevel.type === AST_NODE_TYPES15.VariableDeclaration) {
+    for (const declarator of topLevel.declarations) {
+      let initializer = declarator.init;
+      while (initializer?.type === AST_NODE_TYPES15.TSAsExpression || initializer?.type === AST_NODE_TYPES15.TSSatisfiesExpression || initializer?.type === AST_NODE_TYPES15.TSNonNullExpression) initializer = initializer.expression;
+      if (declarator.id.type === AST_NODE_TYPES15.Identifier && initializer === node) return declarator.id.name;
+      if (declarator.id.type === AST_NODE_TYPES15.Identifier && (initializer?.type === AST_NODE_TYPES15.ClassExpression || initializer?.type === AST_NODE_TYPES15.ObjectExpression)) {
+        let owner = node.parent;
+        const container = initializer.type === AST_NODE_TYPES15.ClassExpression ? initializer.body : initializer;
+        while (owner !== void 0 && owner.parent !== container) owner = owner.parent;
+        if ((owner?.type === AST_NODE_TYPES15.MethodDefinition || owner?.type === AST_NODE_TYPES15.PropertyDefinition || owner?.type === AST_NODE_TYPES15.Property) && owner.value === node) return declarator.id.name;
+      }
     }
-    return child.id.name;
   }
   return null;
 }
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === AST_NODE_TYPES14.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === AST_NODE_TYPES15.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
-        if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES14.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES15.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === AST_NODE_TYPES14.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES14.Identifier) {
+    if (statement.type === AST_NODE_TYPES15.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES15.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === AST_NODE_TYPES14.TSExportAssignment && statement.expression.type === AST_NODE_TYPES14.Identifier) {
+    if (statement.type === AST_NODE_TYPES15.TSExportAssignment && statement.expression.type === AST_NODE_TYPES15.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 }
+function exportedTypeNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type !== AST_NODE_TYPES15.ExportNamedDeclaration || statement.source !== null) continue;
+    if (statement.declaration?.type === AST_NODE_TYPES15.TSInterfaceDeclaration || statement.declaration?.type === AST_NODE_TYPES15.TSTypeAliasDeclaration) names.add(statement.declaration.id.name);
+    for (const specifier of statement.specifiers) names.add(specifier.local.name);
+  }
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES15.ExportDefaultDeclaration && (statement.declaration.type === AST_NODE_TYPES15.TSInterfaceDeclaration || statement.declaration.type === AST_NODE_TYPES15.TSTypeAliasDeclaration)) names.add(statement.declaration.id.name);
+  }
+  return names;
+}
+function typeAliases(program) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES15.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES15.TSTypeAliasDeclaration) {
+      aliases.set(declaration.id.name, declaration.typeAnnotation);
+    }
+  }
+  return aliases;
+}
+function callableReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
+  if (node.type === AST_NODE_TYPES15.TSFunctionType) return node.returnType?.typeAnnotation ?? null;
+  if (node.type === AST_NODE_TYPES15.TSTypeReference && node.typeName.type === AST_NODE_TYPES15.Identifier && !resolving.has(node.typeName.name)) {
+    const target = aliases.get(node.typeName.name);
+    if (target !== void 0) {
+      return callableReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
+    }
+  }
+  return null;
+}
+function publiclyReachableTypeNames(program, exported) {
+  const names = new Set(exported);
+  const interfaces = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES15.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES15.TSInterfaceDeclaration) {
+      interfaces.set(declaration.id.name, declaration.extends);
+    }
+  }
+  for (let pass = 0; pass < interfaces.size; pass += 1) {
+    let changed = false;
+    for (const name of [...names]) {
+      for (const heritage of interfaces.get(name) ?? []) {
+        if (heritage.expression.type === AST_NODE_TYPES15.Identifier && !names.has(heritage.expression.name)) {
+          names.add(heritage.expression.name);
+          changed = true;
+        }
+      }
+    }
+    if (!changed) break;
+  }
+  return names;
+}
+function owningInterface(node) {
+  for (let current = node.parent; current !== void 0; current = current.parent) {
+    if (current.type === AST_NODE_TYPES15.TSInterfaceDeclaration) return current;
+    if (current.type === AST_NODE_TYPES15.Program) return null;
+  }
+  return null;
+}
+function owningTypeAlias(node) {
+  for (let current = node.parent; current !== void 0; current = current.parent) {
+    if (current.type === AST_NODE_TYPES15.TSTypeAliasDeclaration) return current;
+    if (current.type === AST_NODE_TYPES15.Program) return null;
+  }
+  return null;
+}
+function owningClass(node) {
+  for (let current = node.parent; current !== void 0; current = current.parent) {
+    if (current.type === AST_NODE_TYPES15.ClassDeclaration || current.type === AST_NODE_TYPES15.ClassExpression) {
+      return current;
+    }
+    if (current.type === AST_NODE_TYPES15.Program) return null;
+  }
+  return null;
+}
+function isExportedClass(node, specifierExports) {
+  if (node.parent.type === AST_NODE_TYPES15.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES15.ExportDefaultDeclaration) return true;
+  if (node.type === AST_NODE_TYPES15.ClassDeclaration) {
+    return node.id !== null && node.parent.type === AST_NODE_TYPES15.Program && specifierExports.has(node.id.name);
+  }
+  if (node.parent.type === AST_NODE_TYPES15.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES15.Identifier) return specifierExports.has(node.parent.id.name) || isInlineExported(node);
+  return false;
+}
+function isExportedInterface(node, exports) {
+  return node.parent.type === AST_NODE_TYPES15.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES15.ExportDefaultDeclaration || node.parent.type === AST_NODE_TYPES15.Program && exports.has(node.id.name);
+}
 function isExported(node, specifierExports) {
   if (isInlineExported(node)) {
     return true;
@@ -3288,42 +3590,91 @@ var no_positional_tuple_return_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow returning a positional tuple of distinct fields from an exported function; return a named object so call sites cannot mismatch slots."
+      description: "Disallow returning a multi-field tuple from an exported function; return a named object so call sites cannot mismatch slots."
     },
     schema: [],
     messages: {
-      noPositionalTupleReturn: "Exported `{{name}}` returns a positional {{count}}-tuple, so every call site re-invents the field names and can disagree. Return a named object (or label the tuple members) instead."
+      noPositionalTupleReturn: "Exported `{{name}}` returns a {{count}}-field tuple, so consumers depend on positional slots that can be reordered silently. Return a named object instead."
     }
   },
   defaultOptions: [],
   create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     const specifierExports = specifierExportedNames(context.sourceCode.ast);
+    const typeExports = publiclyReachableTypeNames(
+      context.sourceCode.ast,
+      exportedTypeNames(context.sourceCode.ast)
+    );
+    const aliases = typeAliases(context.sourceCode.ast);
+    const report = (annotation, name) => {
+      const tuple = tupleReturnType(annotation, aliases);
+      if (tuple === null || tuple.elementTypes.length < MIN_ELEMENTS) return;
+      context.report({
+        node: tuple,
+        messageId: "noPositionalTupleReturn",
+        data: { name, count: String(tuple.elementTypes.length) }
+      });
+    };
     const check = (node) => {
       const annotation = node.returnType?.typeAnnotation;
       if (annotation === void 0) {
         return;
       }
-      const tuple = tupleReturnType(annotation);
-      if (tuple === null || isPermittedTuple(tuple, context.sourceCode)) {
-        return;
-      }
       const name = functionName(node);
-      if (name === null || name.startsWith("_") || /^use[A-Z]/.test(name)) {
+      if (name === null) {
         return;
       }
       if (!isExported(node, specifierExports)) {
         return;
       }
-      context.report({
-        node: tuple,
-        messageId: "noPositionalTupleReturn",
-        data: { name, count: String(tuple.elementTypes.length) }
-      });
+      report(annotation, name);
     };
     return {
       FunctionDeclaration: check,
       FunctionExpression: check,
-      ArrowFunctionExpression: check
+      ArrowFunctionExpression: check,
+      TSEmptyBodyFunctionExpression: check,
+      TSDeclareFunction(node) {
+        if (node.id === null || node.returnType === void 0 || node.parent.type !== AST_NODE_TYPES15.ExportNamedDeclaration && node.parent.type !== AST_NODE_TYPES15.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
+        report(node.returnType.typeAnnotation, node.id.name);
+      },
+      TSCallSignatureDeclaration(node) {
+        const owner = owningInterface(node);
+        if (owner === null || !isExportedInterface(owner, typeExports) || node.returnType === void 0) return;
+        report(node.returnType.typeAnnotation, `${owner.id.name}.call`);
+      },
+      TSMethodSignature(node) {
+        const owner = owningInterface(node);
+        const alias = owningTypeAlias(node);
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || node.key.type !== AST_NODE_TYPES15.Identifier) return;
+        report(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${node.key.name}`);
+      },
+      TSTypeAliasDeclaration(node) {
+        if (!typeExports.has(node.id.name)) return;
+        const returnType = callableReturnType(node.typeAnnotation, aliases);
+        if (returnType !== null) report(returnType, node.id.name);
+      },
+      TSPropertySignature(node) {
+        const owner = owningInterface(node);
+        const alias = owningTypeAlias(node);
+        const annotation = node.typeAnnotation?.typeAnnotation;
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.key.type !== AST_NODE_TYPES15.Identifier || annotation === void 0) return;
+        const returnType = callableReturnType(annotation, aliases);
+        if (returnType !== null) {
+          report(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${node.key.name}`);
+        }
+      },
+      PropertyDefinition(node) {
+        if (node.accessibility === "private" || node.accessibility === "protected") return;
+        const owner = owningClass(node);
+        const annotation = node.typeAnnotation?.typeAnnotation;
+        if (owner === null || !isExportedClass(owner, specifierExports) || annotation === void 0) return;
+        const returnType = callableReturnType(annotation, aliases);
+        if (returnType !== null) {
+          const name = node.key.type === AST_NODE_TYPES15.Identifier ? node.key.name : "property";
+          report(returnType, name);
+        }
+      }
     };
   }
 });
@@ -3406,7 +3757,7 @@ var no_raw_env_default = createRule({
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES16 } from "@typescript-eslint/utils";
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -3448,7 +3799,7 @@ function identifierLikeName(node) {
 }
 function isConstructedArgumentHandoff(node) {
   const [first] = node.arguments;
-  return node.arguments.length === 1 && first !== void 0 && first.type === AST_NODE_TYPES15.NewExpression;
+  return node.arguments.length === 1 && first !== void 0 && first.type === AST_NODE_TYPES16.NewExpression;
 }
 function isPresignedUrlTransfer(node) {
   const first = node.arguments[0];
@@ -3517,9 +3868,9 @@ var no_raw_fetch_outside_clients_default = createRule({
 });
 
 // src/rules/no-restricted-library-load.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES16, ASTUtils as ASTUtils2 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES17, ASTUtils as ASTUtils3 } from "@typescript-eslint/utils";
 function literalModule(node) {
-  return node?.type === AST_NODE_TYPES16.Literal && typeof node.value === "string" ? node.value : null;
+  return node?.type === AST_NODE_TYPES17.Literal && typeof node.value === "string" ? node.value : null;
 }
 function matchesModule(source, module) {
   return source === module || source.startsWith(`${module}/`);
@@ -3578,7 +3929,7 @@ var no_restricted_library_load_default = createRule({
       });
     }
     function isUnshadowedRequire(node) {
-      const variable = ASTUtils2.findVariable(
+      const variable = ASTUtils3.findVariable(
         context.sourceCode.getScope(node),
         node.name
       );
@@ -3591,9 +3942,9 @@ var no_restricted_library_load_default = createRule({
       },
       CallExpression(node) {
         let requireIdentifier = null;
-        if (node.callee.type === AST_NODE_TYPES16.Identifier && node.callee.name === "require") {
+        if (node.callee.type === AST_NODE_TYPES17.Identifier && node.callee.name === "require") {
           requireIdentifier = node.callee;
-        } else if (node.callee.type === AST_NODE_TYPES16.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES16.Identifier && node.callee.object.name === "require" && node.callee.property.type === AST_NODE_TYPES16.Identifier && node.callee.property.name === "resolve") {
+        } else if (node.callee.type === AST_NODE_TYPES17.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES17.Identifier && node.callee.object.name === "require" && node.callee.property.type === AST_NODE_TYPES17.Identifier && node.callee.property.name === "resolve") {
           requireIdentifier = node.callee.object;
         }
         if (requireIdentifier === null || !isUnshadowedRequire(requireIdentifier)) return;
@@ -3601,7 +3952,7 @@ var no_restricted_library_load_default = createRule({
         if (source !== null) report(node.arguments[0], source);
       },
       TSImportEqualsDeclaration(node) {
-        if (node.moduleReference.type !== AST_NODE_TYPES16.TSExternalModuleReference) return;
+        if (node.moduleReference.type !== AST_NODE_TYPES17.TSExternalModuleReference) return;
         const source = literalModule(node.moduleReference.expression);
         if (source !== null) report(node.moduleReference.expression, source);
       }
@@ -3610,16 +3961,16 @@ var no_restricted_library_load_default = createRule({
 });
 
 // src/rules/no-repeated-string-literal.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES17 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES18 } from "@typescript-eslint/utils";
 var MIN_LENGTH = 40;
 var MIN_DISTINCT_SCOPES = 2;
 var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES17.FunctionDeclaration,
-  AST_NODE_TYPES17.FunctionExpression,
-  AST_NODE_TYPES17.ArrowFunctionExpression
+  AST_NODE_TYPES18.FunctionDeclaration,
+  AST_NODE_TYPES18.FunctionExpression,
+  AST_NODE_TYPES18.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -3641,8 +3992,8 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  const isRequireSource = parent.type === AST_NODE_TYPES17.CallExpression && parent.callee.type === AST_NODE_TYPES17.Identifier && parent.callee.name === "require";
-  return parent.type === AST_NODE_TYPES17.ImportDeclaration || parent.type === AST_NODE_TYPES17.ImportExpression || parent.type === AST_NODE_TYPES17.ExportNamedDeclaration || parent.type === AST_NODE_TYPES17.ExportAllDeclaration || parent.type === AST_NODE_TYPES17.TSImportType || parent.type === AST_NODE_TYPES17.JSXAttribute || parent.type === AST_NODE_TYPES17.TSLiteralType || isRequireSource;
+  const isRequireSource = parent.type === AST_NODE_TYPES18.CallExpression && parent.callee.type === AST_NODE_TYPES18.Identifier && parent.callee.name === "require";
+  return parent.type === AST_NODE_TYPES18.ImportDeclaration || parent.type === AST_NODE_TYPES18.ImportExpression || parent.type === AST_NODE_TYPES18.ExportNamedDeclaration || parent.type === AST_NODE_TYPES18.ExportAllDeclaration || parent.type === AST_NODE_TYPES18.TSImportType || parent.type === AST_NODE_TYPES18.JSXAttribute || parent.type === AST_NODE_TYPES18.TSLiteralType || isRequireSource;
 }
 var no_repeated_string_literal_default = createRule({
   name: "no-repeated-string-literal",
@@ -3682,7 +4033,7 @@ var no_repeated_string_literal_default = createRule({
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === AST_NODE_TYPES17.TaggedTemplateExpression) {
+        if (node.parent.type === AST_NODE_TYPES18.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -3716,7 +4067,7 @@ var no_repeated_string_literal_default = createRule({
 });
 
 // src/rules/no-restated-comment.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES18 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES19 } from "@typescript-eslint/utils";
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
 var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
@@ -3769,7 +4120,7 @@ var no_restated_comment_default = createRule({
     function labelsASiblingRun(comment) {
       const token = sourceCode.getTokenAfter(comment, { includeComments: false });
       if (token === null) return false;
-      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== AST_NODE_TYPES18.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== AST_NODE_TYPES19.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -3829,7 +4180,7 @@ var no_restated_comment_default = createRule({
 });
 
 // src/rules/no-restated-jsdoc.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES19 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES20 } from "@typescript-eslint/utils";
 var MODELLED_TAGS = /* @__PURE__ */ new Set([
   "arg",
   "argument",
@@ -3883,30 +4234,30 @@ function declarationNames(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
-    case AST_NODE_TYPES19.ExportNamedDeclaration:
-    case AST_NODE_TYPES19.ExportDefaultDeclaration:
+    case AST_NODE_TYPES20.ExportNamedDeclaration:
+    case AST_NODE_TYPES20.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case AST_NODE_TYPES19.FunctionDeclaration:
-    case AST_NODE_TYPES19.TSDeclareFunction:
+    case AST_NODE_TYPES20.FunctionDeclaration:
+    case AST_NODE_TYPES20.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case AST_NODE_TYPES19.ClassDeclaration:
-    case AST_NODE_TYPES19.TSInterfaceDeclaration:
-    case AST_NODE_TYPES19.TSTypeAliasDeclaration:
-    case AST_NODE_TYPES19.TSEnumDeclaration:
+    case AST_NODE_TYPES20.ClassDeclaration:
+    case AST_NODE_TYPES20.TSInterfaceDeclaration:
+    case AST_NODE_TYPES20.TSTypeAliasDeclaration:
+    case AST_NODE_TYPES20.TSEnumDeclaration:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case AST_NODE_TYPES19.VariableDeclaration: {
+    case AST_NODE_TYPES20.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== AST_NODE_TYPES19.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== AST_NODE_TYPES20.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === AST_NODE_TYPES19.ArrowFunctionExpression || init.type === AST_NODE_TYPES19.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === AST_NODE_TYPES20.ArrowFunctionExpression || init.type === AST_NODE_TYPES20.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case AST_NODE_TYPES19.MethodDefinition:
-    case AST_NODE_TYPES19.PropertyDefinition:
-    case AST_NODE_TYPES19.TSMethodSignature:
-    case AST_NODE_TYPES19.TSPropertySignature: {
-      if (node.key.type !== AST_NODE_TYPES19.Identifier) return null;
-      const params = node.type === AST_NODE_TYPES19.MethodDefinition ? paramNames(node.value.params) : node.type === AST_NODE_TYPES19.TSMethodSignature ? paramNames(node.params) : [];
+    case AST_NODE_TYPES20.MethodDefinition:
+    case AST_NODE_TYPES20.PropertyDefinition:
+    case AST_NODE_TYPES20.TSMethodSignature:
+    case AST_NODE_TYPES20.TSPropertySignature: {
+      if (node.key.type !== AST_NODE_TYPES20.Identifier) return null;
+      const params = node.type === AST_NODE_TYPES20.MethodDefinition ? paramNames(node.value.params) : node.type === AST_NODE_TYPES20.TSMethodSignature ? paramNames(node.params) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -3916,9 +4267,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === AST_NODE_TYPES19.AssignmentPattern ? param.left : param;
-    if (target.type === AST_NODE_TYPES19.Identifier) names.push(target.name);
-    else if (target.type === AST_NODE_TYPES19.TSParameterProperty) continue;
+    const target = param.type === AST_NODE_TYPES20.AssignmentPattern ? param.left : param;
+    if (target.type === AST_NODE_TYPES20.Identifier) names.push(target.name);
+    else if (target.type === AST_NODE_TYPES20.TSParameterProperty) continue;
   }
   return names;
 }
@@ -3960,7 +4311,7 @@ var no_restated_jsdoc_default = createRule({
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
           let declaration = null;
-          while (node != null && node.type !== AST_NODE_TYPES19.Program) {
+          while (node != null && node.type !== AST_NODE_TYPES20.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -4419,12 +4770,12 @@ var no_select_star_default = createRule({
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES20 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES21 } from "@typescript-eslint/utils";
 function sentinelKind(arg) {
   if (arg === null) {
     return null;
   }
-  if (arg.type === AST_NODE_TYPES20.Literal) {
+  if (arg.type === AST_NODE_TYPES21.Literal) {
     if (arg.value === null) {
       return "nullish";
     }
@@ -4436,13 +4787,13 @@ function sentinelKind(arg) {
     }
     return null;
   }
-  if (arg.type === AST_NODE_TYPES20.Identifier && arg.name === "undefined") {
+  if (arg.type === AST_NODE_TYPES21.Identifier && arg.name === "undefined") {
     return "nullish";
   }
-  if (arg.type === AST_NODE_TYPES20.ArrayExpression) {
+  if (arg.type === AST_NODE_TYPES21.ArrayExpression) {
     return "array";
   }
-  if (arg.type === AST_NODE_TYPES20.ObjectExpression) {
+  if (arg.type === AST_NODE_TYPES21.ObjectExpression) {
     return "object";
   }
   return null;
@@ -4451,25 +4802,25 @@ function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
   }
-  if (arg.type === AST_NODE_TYPES20.Literal && arg.value === null) {
+  if (arg.type === AST_NODE_TYPES21.Literal && arg.value === null) {
     return true;
   }
-  if (arg.type === AST_NODE_TYPES20.Literal && arg.value === false) {
+  if (arg.type === AST_NODE_TYPES21.Literal && arg.value === false) {
     return true;
   }
-  if (arg.type === AST_NODE_TYPES20.Identifier && arg.name === "undefined") {
+  if (arg.type === AST_NODE_TYPES21.Identifier && arg.name === "undefined") {
     return true;
   }
-  if (arg.type === AST_NODE_TYPES20.ArrayExpression && arg.elements.length === 0) {
+  if (arg.type === AST_NODE_TYPES21.ArrayExpression && arg.elements.length === 0) {
     return true;
   }
-  if (arg.type === AST_NODE_TYPES20.ObjectExpression && arg.properties.length === 0) {
+  if (arg.type === AST_NODE_TYPES21.ObjectExpression && arg.properties.length === 0) {
     return true;
   }
   return false;
 }
 function isFunctionNode(node) {
-  return node.type === AST_NODE_TYPES20.FunctionDeclaration || node.type === AST_NODE_TYPES20.FunctionExpression || node.type === AST_NODE_TYPES20.ArrowFunctionExpression;
+  return node.type === AST_NODE_TYPES21.FunctionDeclaration || node.type === AST_NODE_TYPES21.FunctionExpression || node.type === AST_NODE_TYPES21.ArrowFunctionExpression;
 }
 function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
@@ -4509,24 +4860,24 @@ function walkWithinScope(node, visit) {
 function containsThrow(node) {
   return walkWithinScope(
     node,
-    (current) => current.type === AST_NODE_TYPES20.ThrowStatement
+    (current) => current.type === AST_NODE_TYPES21.ThrowStatement
   );
 }
 function bindsName(param, name) {
   switch (param.type) {
-    case AST_NODE_TYPES20.Identifier:
+    case AST_NODE_TYPES21.Identifier:
       return param.name === name;
-    case AST_NODE_TYPES20.AssignmentPattern:
+    case AST_NODE_TYPES21.AssignmentPattern:
       return bindsName(param.left, name);
-    case AST_NODE_TYPES20.RestElement:
+    case AST_NODE_TYPES21.RestElement:
       return bindsName(param.argument, name);
-    case AST_NODE_TYPES20.ArrayPattern:
+    case AST_NODE_TYPES21.ArrayPattern:
       return param.elements.some(
         (element) => element !== null && bindsName(element, name)
       );
-    case AST_NODE_TYPES20.ObjectPattern:
+    case AST_NODE_TYPES21.ObjectPattern:
       return param.properties.some(
-        (property) => property.type === AST_NODE_TYPES20.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
+        (property) => property.type === AST_NODE_TYPES21.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
       );
     default:
       return false;
@@ -4541,7 +4892,7 @@ function subtreeReadsName(node, name) {
     if (found) {
       return;
     }
-    if (current.type === AST_NODE_TYPES20.Identifier && current.name === name) {
+    if (current.type === AST_NODE_TYPES21.Identifier && current.name === name) {
       found = true;
       return;
     }
@@ -4552,10 +4903,10 @@ function subtreeReadsName(node, name) {
       if (key === "parent") {
         continue;
       }
-      if (key === "key" && current.type === AST_NODE_TYPES20.Property && !current.computed) {
+      if (key === "key" && current.type === AST_NODE_TYPES21.Property && !current.computed) {
         continue;
       }
-      if (key === "property" && current.type === AST_NODE_TYPES20.MemberExpression && !current.computed) {
+      if (key === "property" && current.type === AST_NODE_TYPES21.MemberExpression && !current.computed) {
         continue;
       }
       const value = current[key];
@@ -4588,10 +4939,10 @@ var SAFE_PARSE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "URLPattern"
 ]);
 function isParseShapedNode(node) {
-  if (node.type === AST_NODE_TYPES20.CallExpression && node.callee.type === AST_NODE_TYPES20.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES20.Identifier) {
+  if (node.type === AST_NODE_TYPES21.CallExpression && node.callee.type === AST_NODE_TYPES21.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES21.Identifier) {
     return node.callee.property.name === "parse";
   }
-  if (node.type === AST_NODE_TYPES20.NewExpression && node.callee.type === AST_NODE_TYPES20.Identifier) {
+  if (node.type === AST_NODE_TYPES21.NewExpression && node.callee.type === AST_NODE_TYPES21.Identifier) {
     return SAFE_PARSE_CONSTRUCTORS.has(node.callee.name);
   }
   return false;
@@ -4602,10 +4953,10 @@ var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "arrayBuffer"
 ]);
 function isBodyDecodeNode(node) {
-  return node.type === AST_NODE_TYPES20.CallExpression && node.callee.type === AST_NODE_TYPES20.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES20.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
+  return node.type === AST_NODE_TYPES21.CallExpression && node.callee.type === AST_NODE_TYPES21.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES21.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
 }
 function returnsMatching(stmt, predicate) {
-  return stmt.type === AST_NODE_TYPES20.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
+  return stmt.type === AST_NODE_TYPES21.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
 }
 function enclosingReturnTypeNode(node) {
   let current = node.parent;
@@ -4623,11 +4974,11 @@ function enclosingFunctionName(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
     if (isFunctionNode(current)) {
-      if ("id" in current && isNode3(current.id) && current.id.type === AST_NODE_TYPES20.Identifier) {
+      if ("id" in current && isNode3(current.id) && current.id.type === AST_NODE_TYPES21.Identifier) {
         return current.id.name;
       }
       const parent = current.parent;
-      if (parent?.type === AST_NODE_TYPES20.VariableDeclarator && parent.id.type === AST_NODE_TYPES20.Identifier) {
+      if (parent?.type === AST_NODE_TYPES21.VariableDeclarator && parent.id.type === AST_NODE_TYPES21.Identifier) {
         return parent.id.name;
       }
       return null;
@@ -4648,10 +4999,10 @@ function isDeclaredBooleanPredicate(catchNode, kind) {
     return false;
   }
   let declared = enclosingReturnTypeNode(catchNode);
-  if (declared?.type === AST_NODE_TYPES20.TSTypeReference && declared.typeName.type === AST_NODE_TYPES20.Identifier && declared.typeName.name === "Promise") {
+  if (declared?.type === AST_NODE_TYPES21.TSTypeReference && declared.typeName.type === AST_NODE_TYPES21.Identifier && declared.typeName.name === "Promise") {
     declared = declared.typeArguments?.params[0] ?? null;
   }
-  return declared?.type === AST_NODE_TYPES20.TSBooleanKeyword;
+  return declared?.type === AST_NODE_TYPES21.TSBooleanKeyword;
 }
 function tryReturnsSafeParse(catchNode) {
   const tryBlock = tryBlockOf(catchNode);
@@ -4667,7 +5018,7 @@ function tryReturnsSafeParse(catchNode) {
 function enclosingFunctionBody(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === AST_NODE_TYPES20.BlockStatement) {
+    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === AST_NODE_TYPES21.BlockStatement) {
       return current.body;
     }
     current = current.parent;
@@ -4680,7 +5031,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
     return false;
   }
   return walkWithinScope(functionBody, (current) => {
-    if (current.type !== AST_NODE_TYPES20.ReturnStatement) {
+    if (current.type !== AST_NODE_TYPES21.ReturnStatement) {
       return false;
     }
     if (isWithin(current, catchNode.body)) {
@@ -4699,13 +5050,13 @@ function returnedSentinelKinds(arg) {
     kinds.add(direct);
     return kinds;
   }
-  if (arg.type === AST_NODE_TYPES20.ConditionalExpression) {
+  if (arg.type === AST_NODE_TYPES21.ConditionalExpression) {
     for (const branch of [arg.consequent, arg.alternate]) {
       for (const nested of returnedSentinelKinds(branch)) {
         kinds.add(nested);
       }
     }
-  } else if (arg.type === AST_NODE_TYPES20.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
+  } else if (arg.type === AST_NODE_TYPES21.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
     for (const nested of returnedSentinelKinds(arg.right)) {
       kinds.add(nested);
     }
@@ -4748,7 +5099,7 @@ var no_sentinel_return_on_catch_default = createRule({
     const matcher = createLogMatcher(loggingOptions);
     function logsOrReportsError(catchBody, caughtName) {
       return walkWithinScope(catchBody, (current) => {
-        if (current.type !== AST_NODE_TYPES20.CallExpression) {
+        if (current.type !== AST_NODE_TYPES21.CallExpression) {
           return false;
         }
         if (matcher.isLoggingCall(current)) {
@@ -4765,7 +5116,7 @@ var no_sentinel_return_on_catch_default = createRule({
           return;
         }
         const last = body2[body2.length - 1];
-        if (last === void 0 || last.type !== AST_NODE_TYPES20.ReturnStatement) {
+        if (last === void 0 || last.type !== AST_NODE_TYPES21.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -4774,7 +5125,7 @@ var no_sentinel_return_on_catch_default = createRule({
         if (containsThrow(node.body)) {
           return;
         }
-        const caughtName = node.param?.type === AST_NODE_TYPES20.Identifier ? node.param.name : null;
+        const caughtName = node.param?.type === AST_NODE_TYPES21.Identifier ? node.param.name : null;
         if (logsOrReportsError(node.body, caughtName)) {
           return;
         }
@@ -4801,9 +5152,9 @@ var no_sentinel_return_on_catch_default = createRule({
 });
 
 // src/rules/no-silent-promise-catch.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES21 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES22 } from "@typescript-eslint/utils";
 function isBodyParseCall(node) {
-  return node.type === AST_NODE_TYPES21.CallExpression && node.arguments.length === 0 && node.callee.type === AST_NODE_TYPES21.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES21.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+  return node.type === AST_NODE_TYPES22.CallExpression && node.arguments.length === 0 && node.callee.type === AST_NODE_TYPES22.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES22.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -4818,21 +5169,21 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
-  return node.type === AST_NODE_TYPES21.CallExpression && node.callee.type === AST_NODE_TYPES21.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES21.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
+  return node.type === AST_NODE_TYPES22.CallExpression && node.callee.type === AST_NODE_TYPES22.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES22.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
 function isSilentExpression(node) {
   switch (node.type) {
-    case AST_NODE_TYPES21.Literal:
+    case AST_NODE_TYPES22.Literal:
       return !("regex" in node);
-    case AST_NODE_TYPES21.Identifier:
+    case AST_NODE_TYPES22.Identifier:
       return node.name === "undefined";
-    case AST_NODE_TYPES21.UnaryExpression:
-      return node.operator === "void" && node.argument.type === AST_NODE_TYPES21.Literal;
-    case AST_NODE_TYPES21.ObjectExpression:
+    case AST_NODE_TYPES22.UnaryExpression:
+      return node.operator === "void" && node.argument.type === AST_NODE_TYPES22.Literal;
+    case AST_NODE_TYPES22.ObjectExpression:
       return node.properties.length === 0;
-    case AST_NODE_TYPES21.ArrayExpression:
+    case AST_NODE_TYPES22.ArrayExpression:
       return node.elements.length === 0;
-    case AST_NODE_TYPES21.TSAsExpression:
+    case AST_NODE_TYPES22.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
@@ -4840,7 +5191,7 @@ function isSilentExpression(node) {
 }
 function isSilentHandler(handler) {
   const body2 = handler.body;
-  if (body2.type !== AST_NODE_TYPES21.BlockStatement) {
+  if (body2.type !== AST_NODE_TYPES22.BlockStatement) {
     return isSilentExpression(body2);
   }
   if (body2.body.length === 0) {
@@ -4848,7 +5199,7 @@ function isSilentHandler(handler) {
   }
   if (body2.body.length === 1) {
     const only = body2.body[0];
-    if (only !== void 0 && only.type === AST_NODE_TYPES21.ReturnStatement) {
+    if (only !== void 0 && only.type === AST_NODE_TYPES22.ReturnStatement) {
       return only.argument === null || isSilentExpression(only.argument);
     }
   }
@@ -4877,7 +5228,7 @@ var no_silent_promise_catch_default = createRule({
         return true;
       }
       let statement = call;
-      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== AST_NODE_TYPES21.VariableDeclaration) {
+      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== AST_NODE_TYPES22.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -4889,7 +5240,7 @@ var no_silent_promise_catch_default = createRule({
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES21.MemberExpression || node.callee.computed || node.callee.property.type !== AST_NODE_TYPES21.Identifier || node.callee.property.name !== "catch") {
+        if (node.callee.type !== AST_NODE_TYPES22.MemberExpression || node.callee.computed || node.callee.property.type !== AST_NODE_TYPES22.Identifier || node.callee.property.name !== "catch") {
           return;
         }
         if (isBodyParseCall(node.callee.object)) {
@@ -4898,14 +5249,14 @@ var no_silent_promise_catch_default = createRule({
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === AST_NODE_TYPES21.MemberExpression && node.parent.object === node) {
+        if (node.parent.type === AST_NODE_TYPES22.MemberExpression && node.parent.object === node) {
           return;
         }
         if (node.arguments.length !== 1) {
           return;
         }
         const handler = node.arguments[0];
-        if (handler === void 0 || handler.type !== AST_NODE_TYPES21.ArrowFunctionExpression && handler.type !== AST_NODE_TYPES21.FunctionExpression) {
+        if (handler === void 0 || handler.type !== AST_NODE_TYPES22.ArrowFunctionExpression && handler.type !== AST_NODE_TYPES22.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -4920,7 +5271,7 @@ var no_silent_promise_catch_default = createRule({
 });
 
 // src/rules/no-sleep-in-test-body.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES22 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES23 } from "@typescript-eslint/utils";
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS2 = /* @__PURE__ */ new Set([
   "it",
@@ -4929,34 +5280,34 @@ var TEST_CALLERS2 = /* @__PURE__ */ new Set([
   "afterEach"
 ]);
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES22.FunctionDeclaration,
-  AST_NODE_TYPES22.FunctionExpression,
-  AST_NODE_TYPES22.ArrowFunctionExpression
+  AST_NODE_TYPES23.FunctionDeclaration,
+  AST_NODE_TYPES23.FunctionExpression,
+  AST_NODE_TYPES23.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === AST_NODE_TYPES22.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === AST_NODE_TYPES23.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === AST_NODE_TYPES22.CallExpression && node.callee.type === AST_NODE_TYPES22.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  return node.type === AST_NODE_TYPES23.CallExpression && node.callee.type === AST_NODE_TYPES23.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== AST_NODE_TYPES22.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== AST_NODE_TYPES23.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== AST_NODE_TYPES22.ArrowFunctionExpression && executor?.type !== AST_NODE_TYPES22.FunctionExpression) {
+  if (executor?.type !== AST_NODE_TYPES23.ArrowFunctionExpression && executor?.type !== AST_NODE_TYPES23.FunctionExpression) {
     return false;
   }
   const body2 = executor.body;
-  if (body2.type !== AST_NODE_TYPES22.BlockStatement) {
+  if (body2.type !== AST_NODE_TYPES23.BlockStatement) {
     return isTimedSetTimeout(body2);
   }
   return body2.body.some(
-    (stmt) => stmt.type === AST_NODE_TYPES22.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+    (stmt) => stmt.type === AST_NODE_TYPES23.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === AST_NODE_TYPES22.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === AST_NODE_TYPES23.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
 }
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -4964,7 +5315,7 @@ function nearestEnclosingFunction2(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === AST_NODE_TYPES22.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === AST_NODE_TYPES23.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -4972,23 +5323,23 @@ function nearestEnclosingFunction2(node) {
   return null;
 }
 function testCallerName2(callee) {
-  if (callee.type === AST_NODE_TYPES22.Identifier) {
+  if (callee.type === AST_NODE_TYPES23.Identifier) {
     return callee.name;
   }
-  if (callee.type === AST_NODE_TYPES22.MemberExpression) {
+  if (callee.type === AST_NODE_TYPES23.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === AST_NODE_TYPES22.CallExpression) {
+  if (callee.type === AST_NODE_TYPES23.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === AST_NODE_TYPES22.TaggedTemplateExpression) {
+  if (callee.type === AST_NODE_TYPES23.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== AST_NODE_TYPES22.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== AST_NODE_TYPES23.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName2(call.callee);
@@ -5034,7 +5385,7 @@ var no_sleep_in_test_body_default = createRule({
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES23 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES24 } from "@typescript-eslint/utils";
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -5053,7 +5404,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES23.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES23.Identifier) {
+  if (callee.type !== AST_NODE_TYPES24.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES24.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -5267,7 +5618,7 @@ var no_string_concat_in_loop_default = createRule({
 });
 
 // src/rules/no-tautological-expect.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES24 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES25 } from "@typescript-eslint/utils";
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
   "toBeDefined",
@@ -5281,17 +5632,17 @@ var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
 function isLiteral(node) {
   switch (node.type) {
-    case AST_NODE_TYPES24.Literal:
+    case AST_NODE_TYPES25.Literal:
       return true;
-    case AST_NODE_TYPES24.TemplateLiteral:
+    case AST_NODE_TYPES25.TemplateLiteral:
       return node.expressions.length === 0;
-    case AST_NODE_TYPES24.UnaryExpression:
+    case AST_NODE_TYPES25.UnaryExpression:
       return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
-    case AST_NODE_TYPES24.ArrayExpression:
+    case AST_NODE_TYPES25.ArrayExpression:
       return node.elements.every((element) => element !== null && isLiteral(element));
-    case AST_NODE_TYPES24.ObjectExpression:
+    case AST_NODE_TYPES25.ObjectExpression:
       return node.properties.every(
-        (property) => property.type === AST_NODE_TYPES24.Property && !property.computed && isLiteral(property.value)
+        (property) => property.type === AST_NODE_TYPES25.Property && !property.computed && isLiteral(property.value)
       );
     default:
       return false;
@@ -5299,7 +5650,7 @@ function isLiteral(node) {
 }
 function expectOperand(callee) {
   const receiver = callee.object;
-  if (receiver.type !== AST_NODE_TYPES24.CallExpression || receiver.callee.type !== AST_NODE_TYPES24.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== AST_NODE_TYPES25.CallExpression || receiver.callee.type !== AST_NODE_TYPES25.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
     return null;
   }
   return receiver.arguments[0] ?? null;
@@ -5329,10 +5680,10 @@ var no_tautological_expect_default = createRule({
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== AST_NODE_TYPES24.MemberExpression || callee.computed) {
+        if (callee.type !== AST_NODE_TYPES25.MemberExpression || callee.computed) {
           return;
         }
-        if (callee.property.type !== AST_NODE_TYPES24.Identifier) {
+        if (callee.property.type !== AST_NODE_TYPES25.Identifier) {
           return;
         }
         const matcher = callee.property.name;
@@ -5526,10 +5877,10 @@ var no_trailing_value_narration_default = createRule({
 });
 
 // src/rules/no-declaration-comment-wall.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES26 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES27 } from "@typescript-eslint/utils";
 
 // src/rules/_comment-wall.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES25 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES26 } from "@typescript-eslint/utils";
 var WALL_DEFAULTS = {
   // Below three rows "a wall" is not a fair description of what the reader sees.
   minCommentedMembers: 3,
@@ -5633,10 +5984,10 @@ function isWall(members, commented, restated, options) {
   return commented >= options.minCommentedMembers && commented / members >= options.minCommentedRatio && restated / commented >= options.minRestatedRatio;
 }
 var OPAQUE_VALUE_TYPES = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES25.FunctionExpression,
-  AST_NODE_TYPES25.ArrowFunctionExpression,
-  AST_NODE_TYPES25.ObjectExpression,
-  AST_NODE_TYPES25.ArrayExpression
+  AST_NODE_TYPES26.FunctionExpression,
+  AST_NODE_TYPES26.ArrowFunctionExpression,
+  AST_NODE_TYPES26.ObjectExpression,
+  AST_NODE_TYPES26.ArrayExpression
 ]);
 function declarationRange(member) {
   const body2 = bodyOf(member);
@@ -5644,10 +5995,10 @@ function declarationRange(member) {
   return [member.range[0], body2.range[0]];
 }
 function bodyOf(member) {
-  if (member.type === AST_NODE_TYPES25.MethodDefinition || member.type === AST_NODE_TYPES25.TSAbstractMethodDefinition) {
+  if (member.type === AST_NODE_TYPES26.MethodDefinition || member.type === AST_NODE_TYPES26.TSAbstractMethodDefinition) {
     return member.value.body ?? void 0;
   }
-  if (member.type === AST_NODE_TYPES25.Property || member.type === AST_NODE_TYPES25.PropertyDefinition) {
+  if (member.type === AST_NODE_TYPES26.Property || member.type === AST_NODE_TYPES26.PropertyDefinition) {
     const value = member.value;
     if (value !== null && OPAQUE_VALUE_TYPES.has(value.type)) return value;
   }
@@ -5657,12 +6008,12 @@ function bodyOf(member) {
 // src/rules/no-declaration-comment-wall.ts
 function named(node) {
   switch (node.type) {
-    case AST_NODE_TYPES26.TSEnumMember:
+    case AST_NODE_TYPES27.TSEnumMember:
       return { node, key: node.id };
-    case AST_NODE_TYPES26.PropertyDefinition:
-    case AST_NODE_TYPES26.TSAbstractPropertyDefinition:
-    case AST_NODE_TYPES26.MethodDefinition:
-    case AST_NODE_TYPES26.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES27.PropertyDefinition:
+    case AST_NODE_TYPES27.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES27.MethodDefinition:
+    case AST_NODE_TYPES27.TSAbstractMethodDefinition:
       return node.computed ? void 0 : { node, key: node.key };
     default:
       return void 0;
@@ -5762,7 +6113,7 @@ var no_declaration_comment_wall_default = createRule({
 });
 
 // src/rules/no-union-in-comment.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES27 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES28 } from "@typescript-eslint/utils";
 var MAX_LITERAL_LENGTH = 28;
 var LITERAL = String.raw`(?:'[^'\n]*'|"[^"\n]*"|\`[^\`\n]*\`)`;
 var LEAD_IN_RE2 = /^(?:one of|either|values?|allowed(?: values)?|options?|possible(?: values)?)\s*[:=-]?\s*/i;
@@ -5781,14 +6132,14 @@ var STRING_BUILDERS = /* @__PURE__ */ new Set([
 function isBareString(node) {
   if (node === void 0) return false;
   switch (node.type) {
-    case AST_NODE_TYPES27.TSStringKeyword:
+    case AST_NODE_TYPES28.TSStringKeyword:
       return true;
     // `string[]` holds members of the same closed set, one element at a time.
-    case AST_NODE_TYPES27.TSArrayType:
+    case AST_NODE_TYPES28.TSArrayType:
       return isBareString(node.elementType);
     // `string | null` is still an unconstrained string, and so is `string | "a"`
     // — the checker collapses that one to `string`.
-    case AST_NODE_TYPES27.TSUnionType:
+    case AST_NODE_TYPES28.TSUnionType:
       return node.types.some((member) => isBareString(member));
     default:
       return false;
@@ -5798,13 +6149,13 @@ function rootCallee(node) {
   let current = node;
   for (let hops = 0; current != null && hops < 12; hops += 1) {
     switch (current.type) {
-      case AST_NODE_TYPES27.CallExpression:
+      case AST_NODE_TYPES28.CallExpression:
         current = current.callee;
         break;
-      case AST_NODE_TYPES27.MemberExpression:
+      case AST_NODE_TYPES28.MemberExpression:
         current = current.object;
         break;
-      case AST_NODE_TYPES27.Identifier:
+      case AST_NODE_TYPES28.Identifier:
         return current.name;
       default:
         return null;
@@ -5813,26 +6164,26 @@ function rootCallee(node) {
   return null;
 }
 function nameOf(key) {
-  if (key.type === AST_NODE_TYPES27.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES27.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES28.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES28.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function targetOf(node) {
   switch (node.type) {
-    case AST_NODE_TYPES27.TSPropertySignature:
-    case AST_NODE_TYPES27.PropertyDefinition: {
+    case AST_NODE_TYPES28.TSPropertySignature:
+    case AST_NODE_TYPES28.PropertyDefinition: {
       const name = node.computed ? null : nameOf(node.key);
       if (name === null || !isBareString(node.typeAnnotation?.typeAnnotation)) return null;
       return { node, name };
     }
-    case AST_NODE_TYPES27.Property: {
+    case AST_NODE_TYPES28.Property: {
       const name = node.computed || node.shorthand ? null : nameOf(node.key);
       const callee = rootCallee(node.value);
       if (name === null || callee === null || !STRING_BUILDERS.has(callee)) return null;
       return { node, name };
     }
-    case AST_NODE_TYPES27.VariableDeclarator: {
-      if (node.id.type !== AST_NODE_TYPES27.Identifier) return null;
+    case AST_NODE_TYPES28.VariableDeclarator: {
+      if (node.id.type !== AST_NODE_TYPES28.Identifier) return null;
       if (!isBareString(node.id.typeAnnotation?.typeAnnotation)) return null;
       return { node, name: node.id.name };
     }
@@ -5881,7 +6232,7 @@ var no_union_in_comment_default = createRule({
         if (after === null || after.loc.start.line !== comment.loc.end.line + 1) return null;
         anchor = sourceCode.getNodeByRangeIndex(after.range[0]);
       }
-      for (let node = anchor; node != null && node.type !== AST_NODE_TYPES27.Program; node = node.parent) {
+      for (let node = anchor; node != null && node.type !== AST_NODE_TYPES28.Program; node = node.parent) {
         const target = targetOf(node);
         if (target !== null) return target;
       }
@@ -5910,9 +6261,9 @@ var no_union_in_comment_default = createRule({
 });
 
 // src/rules/no-type-member-comment-wall.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES28 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES29 } from "@typescript-eslint/utils";
 function isNamedMember(node) {
-  return (node.type === AST_NODE_TYPES28.TSPropertySignature || node.type === AST_NODE_TYPES28.TSMethodSignature) && !node.computed;
+  return (node.type === AST_NODE_TYPES29.TSPropertySignature || node.type === AST_NODE_TYPES29.TSMethodSignature) && !node.computed;
 }
 var no_type_member_comment_wall_default = createRule({
   name: "no-type-member-comment-wall",
@@ -5959,7 +6310,7 @@ var no_type_member_comment_wall_default = createRule({
       return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
     }
     function check(node) {
-      const members = node.type === AST_NODE_TYPES28.TSInterfaceBody ? node.body : node.members;
+      const members = node.type === AST_NODE_TYPES29.TSInterfaceBody ? node.body : node.members;
       const named2 = members.filter(isNamedMember);
       if (named2.length === 0) return;
       const documented = named2.map((member) => ({ member, comment: documentingComment(member) }));
@@ -5999,7 +6350,7 @@ var no_type_member_comment_wall_default = createRule({
 });
 
 // src/rules/no-unnecessary-use-client.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES29 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES30 } from "@typescript-eslint/utils";
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -6025,13 +6376,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === AST_NODE_TYPES29.JSXMemberExpression) {
+  while (current.type === AST_NODE_TYPES30.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === AST_NODE_TYPES29.JSXIdentifier ? current.name : "";
+  return current.type === AST_NODE_TYPES30.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === AST_NODE_TYPES29.Identifier) {
+  if (node.type === AST_NODE_TYPES30.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -6046,16 +6397,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === AST_NODE_TYPES29.ExpressionStatement && node.expression.type === AST_NODE_TYPES29.Literal && node.expression.value === "use client";
+  return node.type === AST_NODE_TYPES30.ExpressionStatement && node.expression.type === AST_NODE_TYPES30.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === AST_NODE_TYPES29.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === AST_NODE_TYPES30.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === AST_NODE_TYPES29.Property && parent.key === node && !parent.computed) {
+    if (parent.type === AST_NODE_TYPES30.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -6095,13 +6446,13 @@ var no_unnecessary_use_client_default = createRule({
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === AST_NODE_TYPES29.Identifier) {
+      if (callee.type === AST_NODE_TYPES30.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === AST_NODE_TYPES29.MemberExpression && callee.property.type === AST_NODE_TYPES29.Identifier) {
+      if (callee.type === AST_NODE_TYPES30.MemberExpression && callee.property.type === AST_NODE_TYPES30.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -6111,7 +6462,7 @@ var no_unnecessary_use_client_default = createRule({
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== AST_NODE_TYPES29.ExpressionStatement) break;
+          if (stmt.type !== AST_NODE_TYPES30.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -6124,7 +6475,7 @@ var no_unnecessary_use_client_default = createRule({
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === AST_NODE_TYPES29.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === AST_NODE_TYPES30.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -6192,17 +6543,17 @@ var no_unnecessary_use_client_default = createRule({
 
 // src/rules/no-unsafe-mock-casting.ts
 import "@typescript-eslint/utils";
-import { AST_NODE_TYPES as AST_NODE_TYPES30 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES31 } from "@typescript-eslint/utils";
 function isMockTypeReference(node) {
-  if (node.type !== AST_NODE_TYPES30.TSTypeReference) {
+  if (node.type !== AST_NODE_TYPES31.TSTypeReference) {
     return false;
   }
   const typeName = node.typeName;
-  if (typeName.type === AST_NODE_TYPES30.Identifier) {
+  if (typeName.type === AST_NODE_TYPES31.Identifier) {
     const name = typeName.name;
     return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
   }
-  if (typeName.type === AST_NODE_TYPES30.TSQualifiedName) {
+  if (typeName.type === AST_NODE_TYPES31.TSQualifiedName) {
     const rightName = typeName.right.name;
     return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
   }
@@ -6240,7 +6591,7 @@ var no_unsafe_mock_casting_default = createRule({
 // src/rules/no-zod-native-enum.ts
 import {
   ESLintUtils as ESLintUtils2,
-  AST_NODE_TYPES as AST_NODE_TYPES31
+  AST_NODE_TYPES as AST_NODE_TYPES32
 } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 var IGNORE_PATTERNS = [
@@ -6259,7 +6610,7 @@ function isZodModule(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap2(node) {
-  if (node.type === AST_NODE_TYPES31.TSAsExpression || node.type === AST_NODE_TYPES31.TSSatisfiesExpression) {
+  if (node.type === AST_NODE_TYPES32.TSAsExpression || node.type === AST_NODE_TYPES32.TSSatisfiesExpression) {
     return unwrap2(node.expression);
   }
   return node;
@@ -6267,14 +6618,14 @@ function unwrap2(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== AST_NODE_TYPES31.Property) {
+    if (prop.type !== AST_NODE_TYPES32.Property) {
       return null;
     }
     if (prop.computed || prop.shorthand || prop.method || prop.kind !== "init") {
       return null;
     }
     const value = prop.value;
-    if (value.type !== AST_NODE_TYPES31.Literal || typeof value.value !== "string") {
+    if (value.type !== AST_NODE_TYPES32.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -6290,7 +6641,7 @@ function resolvesToLocalEnum(node, scope) {
     const variable = current.variables.find((v) => v.name === node.name);
     if (variable !== void 0) {
       return variable.defs.some(
-        (def) => def.node.type === AST_NODE_TYPES31.TSEnumDeclaration
+        (def) => def.node.type === AST_NODE_TYPES32.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -6342,25 +6693,25 @@ var no_zod_native_enum_default = createRule({
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === AST_NODE_TYPES31.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES31.Identifier) {
+      if (callee.type === AST_NODE_TYPES32.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES32.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === AST_NODE_TYPES31.Identifier) {
+      if (callee.type === AST_NODE_TYPES32.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES31.MemberExpression || callee.property.type !== AST_NODE_TYPES31.Identifier) {
+      if (callee.type !== AST_NODE_TYPES32.MemberExpression || callee.property.type !== AST_NODE_TYPES32.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === AST_NODE_TYPES31.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === AST_NODE_TYPES32.SpreadElement) {
         return null;
       }
       const inner = unwrap2(arg);
-      if (inner.type !== AST_NODE_TYPES31.ObjectExpression) {
+      if (inner.type !== AST_NODE_TYPES32.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -6380,7 +6731,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === AST_NODE_TYPES31.ImportSpecifier && spec.imported.type === AST_NODE_TYPES31.Identifier) {
+          if (spec.type === AST_NODE_TYPES32.ImportSpecifier && spec.imported.type === AST_NODE_TYPES32.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -6399,7 +6750,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== AST_NODE_TYPES31.Identifier) {
+        if (arg === void 0 || arg.type !== AST_NODE_TYPES32.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -6416,7 +6767,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES32 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES33 } from "@typescript-eslint/utils";
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
 var SENTINEL_WORDS = /(^|_)(SENTINEL|EMPTY|NONE|NULL|UNSET|MISSING|PLACEHOLDER|DUMMY|FAKE|EXAMPLE)(_|$)/;
@@ -6429,36 +6780,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case AST_NODE_TYPES32.Literal:
+    case AST_NODE_TYPES33.Literal:
       return true;
-    case AST_NODE_TYPES32.TemplateLiteral:
+    case AST_NODE_TYPES33.TemplateLiteral:
       return node.expressions.length === 0;
-    case AST_NODE_TYPES32.Identifier:
+    case AST_NODE_TYPES33.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case AST_NODE_TYPES32.MemberExpression:
-      return !node.computed && node.property.type === AST_NODE_TYPES32.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case AST_NODE_TYPES33.MemberExpression:
+      return !node.computed && node.property.type === AST_NODE_TYPES33.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === AST_NODE_TYPES32.Identifier) {
+  if (node.type === AST_NODE_TYPES33.Identifier) {
     return node.name;
   }
-  if (node.type === AST_NODE_TYPES32.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES32.Identifier) {
+  if (node.type === AST_NODE_TYPES33.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES33.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === AST_NODE_TYPES32.TemplateLiteral) {
+  if (node.type === AST_NODE_TYPES33.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === AST_NODE_TYPES32.TemplateLiteral) {
+  if (node.type === AST_NODE_TYPES33.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -6511,7 +6862,7 @@ var prefer_constant_time_secret_compare_default = createRule({
 
 // src/rules/prefer-discriminated-union.ts
 import "@typescript-eslint/utils";
-import { AST_NODE_TYPES as AST_NODE_TYPES33 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES34 } from "@typescript-eslint/utils";
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -6521,27 +6872,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== AST_NODE_TYPES33.TSPropertySignature) {
+  if (member.type !== AST_NODE_TYPES34.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === AST_NODE_TYPES33.Identifier) {
+  if (key.type === AST_NODE_TYPES34.Identifier) {
     return key.name;
   }
-  if (key.type === AST_NODE_TYPES33.Literal && typeof key.value === "string") {
+  if (key.type === AST_NODE_TYPES34.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES33.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES34.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   let optionalPayloadCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== AST_NODE_TYPES33.TSPropertySignature) {
+    if (member.type !== AST_NODE_TYPES34.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -6583,7 +6934,7 @@ var prefer_discriminated_union_default = createRule({
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: AST_NODE_TYPES33.TSTypeLiteral,
+          type: AST_NODE_TYPES34.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -6596,21 +6947,21 @@ var prefer_discriminated_union_default = createRule({
 });
 
 // src/rules/prefer-input-group-search.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES34 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES35 } from "@typescript-eslint/utils";
 var INPUT_MODULE = /(?:^|\/)components\/ui\/input$/u;
 var INPUT_GROUP_MODULE = /(?:^|\/)components\/ui\/input-group$/u;
 var MAX_JSX_DISTANCE = 2;
 function localNamedImports(node, importedName) {
   return node.specifiers.filter(
-    (specifier) => specifier.type === AST_NODE_TYPES34.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES34.Identifier ? specifier.imported.name : specifier.imported.value) === importedName
+    (specifier) => specifier.type === AST_NODE_TYPES35.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES35.Identifier ? specifier.imported.name : specifier.imported.value) === importedName
   ).map((specifier) => specifier.local.name);
 }
 function elementName(node) {
-  return node.name.type === AST_NODE_TYPES34.JSXIdentifier ? node.name.name : null;
+  return node.name.type === AST_NODE_TYPES35.JSXIdentifier ? node.name.name : null;
 }
 function jsxAncestors(occurrence) {
   return occurrence.ancestors.filter(
-    (ancestor) => ancestor.type === AST_NODE_TYPES34.JSXElement
+    (ancestor) => ancestor.type === AST_NODE_TYPES35.JSXElement
   );
 }
 function isWithinInputGroup(occurrence, inputGroupNames) {
@@ -6709,7 +7060,7 @@ var prefer_input_group_search_default = createRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES35 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES36, ASTUtils as ASTUtils4 } from "@typescript-eslint/utils";
 var CONSTANT_NAME = /^_?[A-Z][A-Z0-9_]*$/;
 var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "add",
@@ -6727,69 +7078,76 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "unshift"
 ]);
 function isAsConst(node, sourceText) {
-  if (node.type === AST_NODE_TYPES35.TSSatisfiesExpression) {
+  if (node.type === AST_NODE_TYPES36.TSSatisfiesExpression) {
     return isAsConst(node.expression, sourceText);
   }
-  return node.type === AST_NODE_TYPES35.TSAsExpression && sourceText(node.typeAnnotation).trim() === "const";
+  return node.type === AST_NODE_TYPES36.TSAsExpression && sourceText(node.typeAnnotation).trim() === "const";
 }
 function unwrapExpression(node) {
-  if (node.type === AST_NODE_TYPES35.TSAsExpression || node.type === AST_NODE_TYPES35.TSSatisfiesExpression || node.type === AST_NODE_TYPES35.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES36.TSAsExpression || node.type === AST_NODE_TYPES36.TSSatisfiesExpression || node.type === AST_NODE_TYPES36.TSNonNullExpression) {
     return unwrapExpression(node.expression);
   }
   return node;
 }
-function isObjectFreeze(node) {
+function isObjectFreeze(node, isUnshadowedGlobal) {
   const inner = unwrapExpression(node);
-  return inner.type === AST_NODE_TYPES35.CallExpression && inner.callee.type === AST_NODE_TYPES35.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES35.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === AST_NODE_TYPES35.Identifier && inner.callee.property.name === "freeze";
+  if (inner.type === AST_NODE_TYPES36.CallExpression && inner.callee.type === AST_NODE_TYPES36.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES36.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES36.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
+    const argument = inner.arguments[0];
+    return argument !== void 0 && argument.type !== AST_NODE_TYPES36.SpreadElement && collectionKind(argument, isUnshadowedGlobal) === "literal";
+  }
+  return false;
 }
-function collectionKind(node) {
+function collectionKind(node, isUnshadowedGlobal) {
   const inner = unwrapExpression(node);
-  if (inner.type === AST_NODE_TYPES35.ArrayExpression || inner.type === AST_NODE_TYPES35.ObjectExpression) {
+  if (inner.type === AST_NODE_TYPES36.CallExpression && inner.callee.type === AST_NODE_TYPES36.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES36.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES36.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES36.SpreadElement) {
+    return collectionKind(inner.arguments[0], isUnshadowedGlobal);
+  }
+  if (inner.type === AST_NODE_TYPES36.ArrayExpression || inner.type === AST_NODE_TYPES36.ObjectExpression) {
     return "literal";
   }
-  if (inner.type === AST_NODE_TYPES35.NewExpression && inner.callee.type === AST_NODE_TYPES35.Identifier && (inner.callee.name === "Set" || inner.callee.name === "Map")) {
+  if (inner.type === AST_NODE_TYPES36.NewExpression && inner.callee.type === AST_NODE_TYPES36.Identifier && (inner.callee.name === "Set" || inner.callee.name === "Map") && isUnshadowedGlobal(inner.callee)) {
     return inner.callee.name;
   }
   return null;
 }
 function isReadonlyType(node, kind) {
-  if (node.type === AST_NODE_TYPES35.TSTypeOperator && node.operator === "readonly") {
+  if (node.type === AST_NODE_TYPES36.TSTypeOperator && node.operator === "readonly") {
     return true;
   }
-  if (node.type !== AST_NODE_TYPES35.TSTypeReference || node.typeName.type !== AST_NODE_TYPES35.Identifier) {
+  if (node.type !== AST_NODE_TYPES36.TSTypeReference || node.typeName.type !== AST_NODE_TYPES36.Identifier) {
     return false;
   }
   if (node.typeName.name === "Readonly") {
-    return true;
+    return kind === "literal";
   }
   return kind === "literal" ? node.typeName.name === "ReadonlyArray" : node.typeName.name === `Readonly${kind}`;
 }
 function declaredReadonlyType(node, kind) {
-  const annotation = node.id.type === AST_NODE_TYPES35.Identifier ? node.id.typeAnnotation : void 0;
+  const annotation = node.id.type === AST_NODE_TYPES36.Identifier ? node.id.typeAnnotation : void 0;
   if (annotation !== void 0 && isReadonlyType(annotation.typeAnnotation, kind)) {
     return true;
   }
-  return node.init?.type === AST_NODE_TYPES35.TSAsExpression && isReadonlyType(node.init.typeAnnotation, kind);
+  return node.init?.type === AST_NODE_TYPES36.TSAsExpression && isReadonlyType(node.init.typeAnnotation, kind);
 }
 function referenceMutates(identifier) {
   let member = identifier.parent;
-  if (member?.type !== AST_NODE_TYPES35.MemberExpression || member.object !== identifier) {
-    return member?.type === AST_NODE_TYPES35.CallExpression && member.arguments[0] === identifier && member.callee.type === AST_NODE_TYPES35.MemberExpression && !member.callee.computed && member.callee.object.type === AST_NODE_TYPES35.Identifier && member.callee.object.name === "Object" && member.callee.property.type === AST_NODE_TYPES35.Identifier && member.callee.property.name === "assign";
+  if (member?.type !== AST_NODE_TYPES36.MemberExpression || member.object !== identifier) {
+    return member?.type === AST_NODE_TYPES36.CallExpression && member.arguments[0] === identifier && member.callee.type === AST_NODE_TYPES36.MemberExpression && !member.callee.computed && member.callee.object.type === AST_NODE_TYPES36.Identifier && member.callee.object.name === "Object" && member.callee.property.type === AST_NODE_TYPES36.Identifier && member.callee.property.name === "assign";
   }
-  while (member.parent.type === AST_NODE_TYPES35.MemberExpression && member.parent.object === member) {
+  while (member.parent.type === AST_NODE_TYPES36.MemberExpression && member.parent.object === member) {
     member = member.parent;
   }
   const parent = member.parent;
-  if (parent?.type === AST_NODE_TYPES35.AssignmentExpression && parent.left === member) {
+  if (parent?.type === AST_NODE_TYPES36.AssignmentExpression && parent.left === member) {
     return true;
   }
-  if (parent?.type === AST_NODE_TYPES35.UpdateExpression && parent.argument === member) {
+  if (parent?.type === AST_NODE_TYPES36.UpdateExpression && parent.argument === member) {
     return true;
   }
-  if (parent?.type === AST_NODE_TYPES35.UnaryExpression && parent.operator === "delete" && parent.argument === member) {
+  if (parent?.type === AST_NODE_TYPES36.UnaryExpression && parent.operator === "delete" && parent.argument === member) {
     return true;
   }
-  return parent?.type === AST_NODE_TYPES35.CallExpression && parent.callee === member && member.property.type === AST_NODE_TYPES35.Identifier && MUTATING_METHODS.has(member.property.name);
+  return parent?.type === AST_NODE_TYPES36.CallExpression && parent.callee === member && member.property.type === AST_NODE_TYPES36.Identifier && MUTATING_METHODS.has(member.property.name);
 }
 var prefer_immutable_module_constant_default = createRule({
   name: "prefer-immutable-module-constant",
@@ -6807,29 +7165,33 @@ var prefer_immutable_module_constant_default = createRule({
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
+    const isUnshadowedGlobal = (identifier) => {
+      const variable = ASTUtils4.findVariable(sourceCode.getScope(identifier), identifier.name);
+      return variable === null || variable.defs.length === 0;
+    };
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
       return {};
     }
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== AST_NODE_TYPES35.VariableDeclaration || declaration.kind !== "const" || node.id.type !== AST_NODE_TYPES35.Identifier || node.init === null || !CONSTANT_NAME.test(node.id.name)) {
+        if (declaration.type !== AST_NODE_TYPES36.VariableDeclaration || declaration.kind !== "const" || node.id.type !== AST_NODE_TYPES36.Identifier || node.init === null || !CONSTANT_NAME.test(node.id.name)) {
           return;
         }
         const container = declaration.parent;
-        if (container.type !== AST_NODE_TYPES35.Program && !(container.type === AST_NODE_TYPES35.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES35.Program)) {
+        if (container.type !== AST_NODE_TYPES36.Program && !(container.type === AST_NODE_TYPES36.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES36.Program)) {
           return;
         }
-        if (isAsConst(node.init, (target) => sourceCode.getText(target)) || isObjectFreeze(node.init)) {
+        if (isAsConst(node.init, (target) => sourceCode.getText(target)) || isObjectFreeze(node.init, isUnshadowedGlobal)) {
           return;
         }
-        const kind = collectionKind(node.init);
+        const kind = collectionKind(node.init, isUnshadowedGlobal);
         if (kind === null || declaredReadonlyType(node, kind)) {
           return;
         }
         const variable = sourceCode.getDeclaredVariables(node)[0];
         if (variable?.references.some(
-          (reference) => reference.identifier.type === AST_NODE_TYPES35.Identifier && referenceMutates(reference.identifier)
+          (reference) => reference.identifier.type === AST_NODE_TYPES36.Identifier && referenceMutates(reference.identifier)
         ) === true) {
           return;
         }
@@ -6844,7 +7206,7 @@ var prefer_immutable_module_constant_default = createRule({
 });
 
 // src/rules/prefer-shadcn-primitives.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES36 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES37 } from "@typescript-eslint/utils";
 var SHADCN_PRIMITIVES = {
   button: "Button",
   dialog: "Dialog or AlertDialog family",
@@ -6865,15 +7227,15 @@ var LABELABLE_ELEMENTS = /* @__PURE__ */ new Set([
   "textarea"
 ]);
 function rawElementName(node) {
-  if (node.name.type !== AST_NODE_TYPES36.JSXIdentifier) return null;
+  if (node.name.type !== AST_NODE_TYPES37.JSXIdentifier) return null;
   const name = node.name.name;
   return Object.hasOwn(SHADCN_PRIMITIVES, name) ? name : null;
 }
 function staticExpressionString(expression) {
-  if (expression.type === AST_NODE_TYPES36.Literal) {
+  if (expression.type === AST_NODE_TYPES37.Literal) {
     return typeof expression.value === "string" ? expression.value : null;
   }
-  if (expression.type === AST_NODE_TYPES36.TemplateLiteral) {
+  if (expression.type === AST_NODE_TYPES37.TemplateLiteral) {
     let value = expression.quasis[0]?.value.cooked ?? "";
     for (const [index, substitution] of expression.expressions.entries()) {
       const staticSubstitution = staticExpressionString(substitution);
@@ -6883,24 +7245,24 @@ function staticExpressionString(expression) {
     }
     return value;
   }
-  if (expression.type === AST_NODE_TYPES36.TSAsExpression || expression.type === AST_NODE_TYPES36.TSNonNullExpression || expression.type === AST_NODE_TYPES36.TSSatisfiesExpression || expression.type === AST_NODE_TYPES36.TSTypeAssertion) {
+  if (expression.type === AST_NODE_TYPES37.TSAsExpression || expression.type === AST_NODE_TYPES37.TSNonNullExpression || expression.type === AST_NODE_TYPES37.TSSatisfiesExpression || expression.type === AST_NODE_TYPES37.TSTypeAssertion) {
     return staticExpressionString(expression.expression);
   }
   return null;
 }
 function staticString(value) {
-  if (value?.type === AST_NODE_TYPES36.Literal) {
+  if (value?.type === AST_NODE_TYPES37.Literal) {
     return typeof value.value === "string" ? value.value : null;
   }
-  if (value?.type !== AST_NODE_TYPES36.JSXExpressionContainer) return null;
+  if (value?.type !== AST_NODE_TYPES37.JSXExpressionContainer) return null;
   return staticExpressionString(value.expression);
 }
 function effectiveAttribute(node, attributeName) {
   for (const attribute of node.attributes.toReversed()) {
-    if (attribute.type === AST_NODE_TYPES36.JSXSpreadAttribute) {
+    if (attribute.type === AST_NODE_TYPES37.JSXSpreadAttribute) {
       return { kind: "unknown" };
     }
-    if (attribute.name.type !== AST_NODE_TYPES36.JSXIdentifier || attribute.name.name !== attributeName) {
+    if (attribute.name.type !== AST_NODE_TYPES37.JSXIdentifier || attribute.name.name !== attributeName) {
       continue;
     }
     const value = staticString(attribute.value);
@@ -6909,7 +7271,7 @@ function effectiveAttribute(node, attributeName) {
   return { kind: "missing" };
 }
 function isLabelableElement(node) {
-  if (node.openingElement.name.type !== AST_NODE_TYPES36.JSXIdentifier) {
+  if (node.openingElement.name.type !== AST_NODE_TYPES37.JSXIdentifier) {
     return false;
   }
   const name = node.openingElement.name.name;
@@ -6921,10 +7283,10 @@ function isLabelableElement(node) {
 }
 function containsLabelableElement(node) {
   return node.children.some((child) => {
-    if (child.type === AST_NODE_TYPES36.JSXElement) {
+    if (child.type === AST_NODE_TYPES37.JSXElement) {
       return isLabelableElement(child) || containsLabelableElement(child);
     }
-    if (child.type === AST_NODE_TYPES36.JSXFragment) {
+    if (child.type === AST_NODE_TYPES37.JSXFragment) {
       return containsLabelableElement(child);
     }
     return false;
@@ -6933,7 +7295,7 @@ function containsLabelableElement(node) {
 function isStaticallyAssociatedLabel(node) {
   const htmlFor = effectiveAttribute(node, "htmlFor");
   if (htmlFor.kind === "known" && htmlFor.value.trim().length > 0) return true;
-  return node.parent.type === AST_NODE_TYPES36.JSXElement && containsLabelableElement(node.parent);
+  return node.parent.type === AST_NODE_TYPES37.JSXElement && containsLabelableElement(node.parent);
 }
 function replacementFor(node, element) {
   if (element !== "input") return SHADCN_PRIMITIVES[element];
@@ -6977,7 +7339,7 @@ var prefer_shadcn_primitives_default = createRule({
 });
 
 // src/rules/prefer-module-level-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES37 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES38 } from "@typescript-eslint/utils";
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS2 = [
@@ -7006,9 +7368,9 @@ var MUTATING_METHODS2 = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES37.FunctionDeclaration,
-  AST_NODE_TYPES37.FunctionExpression,
-  AST_NODE_TYPES37.ArrowFunctionExpression
+  AST_NODE_TYPES38.FunctionDeclaration,
+  AST_NODE_TYPES38.FunctionExpression,
+  AST_NODE_TYPES38.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile2(filename, sourceText) {
@@ -7021,14 +7383,14 @@ function isLocalFixtureFile(filename) {
   return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap3(node) {
-  if (node.type === AST_NODE_TYPES37.TSAsExpression || node.type === AST_NODE_TYPES37.TSSatisfiesExpression || node.type === AST_NODE_TYPES37.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES38.TSAsExpression || node.type === AST_NODE_TYPES38.TSSatisfiesExpression || node.type === AST_NODE_TYPES38.TSNonNullExpression) {
     return unwrap3(node.expression);
   }
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === AST_NODE_TYPES37.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === AST_NODE_TYPES38.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -7036,29 +7398,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap3(node);
   switch (inner.type) {
-    case AST_NODE_TYPES37.Literal: {
+    case AST_NODE_TYPES38.Literal: {
       return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case AST_NODE_TYPES37.TemplateLiteral: {
+    case AST_NODE_TYPES38.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case AST_NODE_TYPES37.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === AST_NODE_TYPES37.Literal && typeof inner.argument.value === "number";
+    case AST_NODE_TYPES38.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === AST_NODE_TYPES38.Literal && typeof inner.argument.value === "number";
     }
-    case AST_NODE_TYPES37.ArrayExpression: {
+    case AST_NODE_TYPES38.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== AST_NODE_TYPES37.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== AST_NODE_TYPES38.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case AST_NODE_TYPES37.ObjectExpression: {
+    case AST_NODE_TYPES38.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== AST_NODE_TYPES37.Property) {
+        if (prop.type !== AST_NODE_TYPES38.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== AST_NODE_TYPES37.Literal) {
+        if (prop.computed && prop.key.type !== AST_NODE_TYPES38.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -7071,7 +7433,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap3(node);
-  if (inner.type === AST_NODE_TYPES37.CallExpression && inner.callee.type === AST_NODE_TYPES37.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES37.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === AST_NODE_TYPES37.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES37.SpreadElement) {
+  if (inner.type === AST_NODE_TYPES38.CallExpression && inner.callee.type === AST_NODE_TYPES38.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES38.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === AST_NODE_TYPES38.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES38.SpreadElement) {
     return unwrap3(inner.arguments[0]);
   }
   return inner;
@@ -7087,19 +7449,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === AST_NODE_TYPES37.ArrayExpression) {
+  if (node.type === AST_NODE_TYPES38.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === AST_NODE_TYPES37.ObjectExpression) {
+  if (node.type === AST_NODE_TYPES38.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === AST_NODE_TYPES37.NewExpression && node.callee.type === AST_NODE_TYPES37.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === AST_NODE_TYPES38.NewExpression && node.callee.type === AST_NODE_TYPES38.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === AST_NODE_TYPES37.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === AST_NODE_TYPES38.SpreadElement) {
       return null;
     }
     const entries = unwrap3(arg);
-    if (entries.type !== AST_NODE_TYPES37.ArrayExpression) {
+    if (entries.type !== AST_NODE_TYPES38.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -7128,10 +7490,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === AST_NODE_TYPES37.Identifier && callee.name === "structuredClone") {
+  if (callee.type === AST_NODE_TYPES38.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== AST_NODE_TYPES37.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES37.Identifier || callee.property.type !== AST_NODE_TYPES37.Identifier) {
+  if (callee.type !== AST_NODE_TYPES38.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES38.Identifier || callee.property.type !== AST_NODE_TYPES38.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -7145,38 +7507,38 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === AST_NODE_TYPES37.MemberExpression) {
+  if (parent.type === AST_NODE_TYPES38.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === AST_NODE_TYPES37.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === AST_NODE_TYPES38.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === AST_NODE_TYPES37.UpdateExpression) {
+    if (grandparent.type === AST_NODE_TYPES38.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === AST_NODE_TYPES37.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === AST_NODE_TYPES38.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === AST_NODE_TYPES37.Identifier && MUTATING_METHODS2.has(parent.property.name) && grandparent.type === AST_NODE_TYPES37.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === AST_NODE_TYPES38.Identifier && MUTATING_METHODS2.has(parent.property.name) && grandparent.type === AST_NODE_TYPES38.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === AST_NODE_TYPES37.ForOfStatement && parent.right === identifier) {
+  if (parent.type === AST_NODE_TYPES38.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES37.SpreadElement) {
+  if (parent.type === AST_NODE_TYPES38.SpreadElement) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES37.BinaryExpression) {
+  if (parent.type === AST_NODE_TYPES38.BinaryExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES37.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === AST_NODE_TYPES38.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES37.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === AST_NODE_TYPES38.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
@@ -7200,7 +7562,7 @@ var prefer_module_level_constant_default = createRule({
       }
     ],
     messages: {
-      hoistCollection: "`{{name}}` is a literal-only {{kind}} rebuilt on every call. Hoist it to module scope so it is allocated once and can be reused, exported, and tested.",
+      hoistCollection: "`{{name}}` is a literal-only {{kind}} rebuilt on every call. Hoist it to module scope in immutable form (`as const`, a readonly collection, or `Object.freeze`) so it is allocated once without exposing mutable shared state.",
       hoistRegex: "`{{name}}` is a constant regex recompiled on every call. Hoist it to module scope."
     }
   },
@@ -7231,7 +7593,7 @@ var prefer_module_level_constant_default = createRule({
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== AST_NODE_TYPES37.Identifier) {
+        if (reference.identifier.type !== AST_NODE_TYPES38.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -7243,10 +7605,10 @@ var prefer_module_level_constant_default = createRule({
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== AST_NODE_TYPES37.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== AST_NODE_TYPES38.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES37.Identifier || node.init === null) {
+        if (node.id.type !== AST_NODE_TYPES38.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -7273,7 +7635,7 @@ var prefer_module_level_constant_default = createRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES38 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES39 } from "@typescript-eslint/utils";
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -7339,9 +7701,9 @@ var I18N_RECEIVER_NAMES = /* @__PURE__ */ new Set([
   "intl"
 ]);
 var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES38.ArrowFunctionExpression,
-  AST_NODE_TYPES38.FunctionDeclaration,
-  AST_NODE_TYPES38.FunctionExpression
+  AST_NODE_TYPES39.ArrowFunctionExpression,
+  AST_NODE_TYPES39.FunctionDeclaration,
+  AST_NODE_TYPES39.FunctionExpression
 ]);
 function schemaExpression(node) {
   let current = node;
@@ -7350,10 +7712,10 @@ function schemaExpression(node) {
     if (parent === void 0) {
       return current;
     }
-    if (parent.type === AST_NODE_TYPES38.MemberExpression && parent.object === current && !parent.computed && parent.property.type === AST_NODE_TYPES38.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
+    if (parent.type === AST_NODE_TYPES39.MemberExpression && parent.object === current && !parent.computed && parent.property.type === AST_NODE_TYPES39.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
       return current;
     }
-    if (parent.type === AST_NODE_TYPES38.MemberExpression && parent.object === current || parent.type === AST_NODE_TYPES38.CallExpression && parent.callee === current || parent.type === AST_NODE_TYPES38.TSAsExpression && parent.expression === current || parent.type === AST_NODE_TYPES38.TSNonNullExpression && parent.expression === current) {
+    if (parent.type === AST_NODE_TYPES39.MemberExpression && parent.object === current || parent.type === AST_NODE_TYPES39.CallExpression && parent.callee === current || parent.type === AST_NODE_TYPES39.TSAsExpression && parent.expression === current || parent.type === AST_NODE_TYPES39.TSNonNullExpression && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -7404,22 +7766,22 @@ function subtreeSome(root, predicate) {
 function readsReceiver(node) {
   return subtreeSome(
     node,
-    (inner) => inner.type === AST_NODE_TYPES38.ThisExpression || inner.type === AST_NODE_TYPES38.Super || inner.type === AST_NODE_TYPES38.Identifier && inner.name === "arguments"
+    (inner) => inner.type === AST_NODE_TYPES39.ThisExpression || inner.type === AST_NODE_TYPES39.Super || inner.type === AST_NODE_TYPES39.Identifier && inner.name === "arguments"
   );
 }
 function buildsLocalizedText(node) {
   return subtreeSome(node, (inner) => {
-    if (inner.type === AST_NODE_TYPES38.TaggedTemplateExpression) {
+    if (inner.type === AST_NODE_TYPES39.TaggedTemplateExpression) {
       return true;
     }
-    if (inner.type !== AST_NODE_TYPES38.CallExpression) {
+    if (inner.type !== AST_NODE_TYPES39.CallExpression) {
       return false;
     }
     const { callee } = inner;
-    if (callee.type === AST_NODE_TYPES38.Identifier) {
+    if (callee.type === AST_NODE_TYPES39.Identifier) {
       return I18N_CALLEE_NAMES.has(callee.name);
     }
-    return callee.type === AST_NODE_TYPES38.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES38.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
+    return callee.type === AST_NODE_TYPES39.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES39.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
   });
 }
 function collectReferences(scope, out) {
@@ -7476,15 +7838,15 @@ var prefer_module_level_schema_default = createRule({
     }
     const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodCall(node) {
-      return node.type === AST_NODE_TYPES38.CallExpression && node.callee.type === AST_NODE_TYPES38.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES38.Identifier && zodNamespaces.has(node.callee.object.name);
+      return node.type === AST_NODE_TYPES39.CallExpression && node.callee.type === AST_NODE_TYPES39.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES39.Identifier && zodNamespaces.has(node.callee.object.name);
     }
     function isCovered(node) {
       let current = node.parent ?? void 0;
       while (current !== void 0) {
-        if (current !== node && isZodCall(current) && current.callee.type === AST_NODE_TYPES38.MemberExpression && current.callee.property.type === AST_NODE_TYPES38.Identifier && factories.has(current.callee.property.name)) {
+        if (current !== node && isZodCall(current) && current.callee.type === AST_NODE_TYPES39.MemberExpression && current.callee.property.type === AST_NODE_TYPES39.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === AST_NODE_TYPES38.CallExpression && (current.callee.type === AST_NODE_TYPES38.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === AST_NODE_TYPES38.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES38.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === AST_NODE_TYPES39.CallExpression && (current.callee.type === AST_NODE_TYPES39.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === AST_NODE_TYPES39.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES39.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -7499,11 +7861,11 @@ var prefer_module_level_schema_default = createRule({
         if (parent === void 0) {
           return confirmed;
         }
-        if (parent.type === AST_NODE_TYPES38.Property && parent.value === current || parent.type === AST_NODE_TYPES38.ObjectExpression || parent.type === AST_NODE_TYPES38.ArrayExpression) {
+        if (parent.type === AST_NODE_TYPES39.Property && parent.value === current || parent.type === AST_NODE_TYPES39.ObjectExpression || parent.type === AST_NODE_TYPES39.ArrayExpression) {
           current = parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES38.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
+        if (parent.type === AST_NODE_TYPES39.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
           current = schemaExpression(parent);
           confirmed = current;
           continue;
@@ -7513,7 +7875,7 @@ var prefer_module_level_schema_default = createRule({
     }
     function isSchemaComposition(node) {
       const { callee } = node;
-      const isCombinator = callee.type === AST_NODE_TYPES38.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES38.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
+      const isCombinator = callee.type === AST_NODE_TYPES39.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES39.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
       return isCombinator || isZodCall(node);
     }
     function closesOverNothing(node, enclosing) {
@@ -7547,13 +7909,13 @@ var prefer_module_level_schema_default = createRule({
     }
     function ownerName(enclosing) {
       const parent = enclosing.parent ?? void 0;
-      if (enclosing.type === AST_NODE_TYPES38.FunctionDeclaration && enclosing.id !== null) {
+      if (enclosing.type === AST_NODE_TYPES39.FunctionDeclaration && enclosing.id !== null) {
         return enclosing.id.name;
       }
-      if (parent !== void 0 && parent.type === AST_NODE_TYPES38.VariableDeclarator && parent.id.type === AST_NODE_TYPES38.Identifier) {
+      if (parent !== void 0 && parent.type === AST_NODE_TYPES39.VariableDeclarator && parent.id.type === AST_NODE_TYPES39.Identifier) {
         return parent.id.name;
       }
-      if (parent !== void 0 && (parent.type === AST_NODE_TYPES38.MethodDefinition || parent.type === AST_NODE_TYPES38.Property) && parent.key.type === AST_NODE_TYPES38.Identifier) {
+      if (parent !== void 0 && (parent.type === AST_NODE_TYPES39.MethodDefinition || parent.type === AST_NODE_TYPES39.Property) && parent.key.type === AST_NODE_TYPES39.Identifier) {
         return parent.key.name;
       }
       return "this function";
@@ -7564,7 +7926,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES38.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES38.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES38.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES38.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === AST_NODE_TYPES39.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES39.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES39.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES39.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -7574,7 +7936,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const callee = node.callee;
-        if (callee.property.type !== AST_NODE_TYPES38.Identifier) {
+        if (callee.property.type !== AST_NODE_TYPES39.Identifier) {
           return;
         }
         const factory = callee.property.name;
@@ -7589,7 +7951,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const shape = node.arguments[0];
-        if (shape !== void 0 && shape.type === AST_NODE_TYPES38.ObjectExpression && shape.properties.length < minProperties) {
+        if (shape !== void 0 && shape.type === AST_NODE_TYPES39.ObjectExpression && shape.properties.length < minProperties) {
           return;
         }
         const expression = schemaExpression(node);
@@ -7617,9 +7979,9 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES39, ASTUtils as ASTUtils3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES40, ASTUtils as ASTUtils5 } from "@typescript-eslint/utils";
 function requireUuid(node) {
-  return node?.type === AST_NODE_TYPES39.CallExpression && node.callee.type === AST_NODE_TYPES39.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES39.Literal && node.arguments[0].value === "uuid";
+  return node?.type === AST_NODE_TYPES40.CallExpression && node.callee.type === AST_NODE_TYPES40.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES40.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -7640,7 +8002,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils3.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils5.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -7662,37 +8024,37 @@ var prefer_native_random_uuid_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "uuid") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES39.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES39.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === AST_NODE_TYPES40.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES40.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === AST_NODE_TYPES39.ImportNamespaceSpecifier) {
+          } else if (specifier.type === AST_NODE_TYPES40.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== AST_NODE_TYPES39.CallExpression || node.init.callee.type !== AST_NODE_TYPES39.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== AST_NODE_TYPES40.CallExpression || node.init.callee.type !== AST_NODE_TYPES40.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === AST_NODE_TYPES39.Identifier) {
+        if (node.id.type === AST_NODE_TYPES40.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES39.ObjectPattern) return;
+        if (node.id.type !== AST_NODE_TYPES40.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === AST_NODE_TYPES39.Property && !property.computed && (property.key.type === AST_NODE_TYPES39.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES39.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES39.Identifier) {
+          if (property.type === AST_NODE_TYPES40.Property && !property.computed && (property.key.type === AST_NODE_TYPES40.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES40.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES40.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === AST_NODE_TYPES39.Identifier) {
+        if (node.callee.type === AST_NODE_TYPES40.Identifier) {
           const variable2 = resolve(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report(node);
           return;
         }
-        if (node.callee.type !== AST_NODE_TYPES39.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES39.Identifier || node.callee.property.type !== AST_NODE_TYPES39.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== AST_NODE_TYPES40.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES40.Identifier || node.callee.property.type !== AST_NODE_TYPES40.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve(node.callee.object);
@@ -7703,20 +8065,20 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES40 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES41 } from "@typescript-eslint/utils";
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === AST_NODE_TYPES40.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES40.Literal) return String(key.value);
+  if (key.type === AST_NODE_TYPES41.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES41.Literal) return String(key.value);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === AST_NODE_TYPES40.TSArrayType) return true;
-  return node.type === AST_NODE_TYPES40.TSTypeReference && node.typeName.type === AST_NODE_TYPES40.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === AST_NODE_TYPES41.TSArrayType) return true;
+  return node.type === AST_NODE_TYPES41.TSTypeReference && node.typeName.type === AST_NODE_TYPES41.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function isNullishType(node) {
-  return node.type === AST_NODE_TYPES40.TSNullKeyword || node.type === AST_NODE_TYPES40.TSUndefinedKeyword;
+  return node.type === AST_NODE_TYPES41.TSNullKeyword || node.type === AST_NODE_TYPES41.TSUndefinedKeyword;
 }
 function isNullableArrayOnly(node) {
   const values = node.types.filter((member) => !isNullishType(member));
@@ -7744,7 +8106,7 @@ var prefer_non_nullable_collection_default = createRule({
       if (node.optional) return;
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== AST_NODE_TYPES40.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== AST_NODE_TYPES41.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -7757,7 +8119,7 @@ var prefer_non_nullable_collection_default = createRule({
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== AST_NODE_TYPES40.TSUnionType) return;
+        if (node.typeAnnotation.type !== AST_NODE_TYPES41.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -7770,13 +8132,13 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES41 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES42 } from "@typescript-eslint/utils";
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === AST_NODE_TYPES41.TSAsExpression || current.type === AST_NODE_TYPES41.TSTypeAssertion || current.type === AST_NODE_TYPES41.TSNonNullExpression || current.type === AST_NODE_TYPES41.TSSatisfiesExpression) {
+    if (current.type === AST_NODE_TYPES42.TSAsExpression || current.type === AST_NODE_TYPES42.TSTypeAssertion || current.type === AST_NODE_TYPES42.TSNonNullExpression || current.type === AST_NODE_TYPES42.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === AST_NODE_TYPES41.ChainExpression) {
+    } else if (current.type === AST_NODE_TYPES42.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -7791,23 +8153,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === AST_NODE_TYPES41.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES41.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === AST_NODE_TYPES42.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES42.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node) => {
   let current = unwrap4(node);
   if (current === null) return false;
-  if (current.type === AST_NODE_TYPES41.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES42.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== AST_NODE_TYPES41.CallExpression) {
+  if (current === null || current.type !== AST_NODE_TYPES42.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== AST_NODE_TYPES41.MemberExpression) {
+  if (callee === null || callee.type !== AST_NODE_TYPES42.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== AST_NODE_TYPES41.Identifier) {
+  if (property === null || property.type !== AST_NODE_TYPES42.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -7817,16 +8179,16 @@ var isRawPayloadSource = (node) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES41.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]);
+  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES42.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === AST_NODE_TYPES41.CallExpression) {
+    if (current.type === AST_NODE_TYPES42.CallExpression) {
       const callee = unwrap4(current.callee);
-      const name = callee?.type === AST_NODE_TYPES41.Identifier ? callee.name : callee?.type === AST_NODE_TYPES41.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES41.Identifier ? callee.property.name : null;
+      const name = callee?.type === AST_NODE_TYPES42.Identifier ? callee.name : callee?.type === AST_NODE_TYPES42.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES42.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -7848,15 +8210,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== AST_NODE_TYPES41.CallExpression) continue;
+    if (current.type !== AST_NODE_TYPES42.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === AST_NODE_TYPES41.MemberExpression) {
+    while (callee.type === AST_NODE_TYPES42.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === AST_NODE_TYPES41.CallExpression) {
+    if (callee.type === AST_NODE_TYPES42.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === AST_NODE_TYPES41.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === AST_NODE_TYPES42.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -7875,39 +8237,39 @@ var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
 var isValidationRead = (node) => {
   let current = node;
   let parent = current.parent;
-  while (parent !== null && parent !== void 0 && (parent.type === AST_NODE_TYPES41.TSAsExpression || parent.type === AST_NODE_TYPES41.TSTypeAssertion || parent.type === AST_NODE_TYPES41.TSNonNullExpression || parent.type === AST_NODE_TYPES41.TSSatisfiesExpression || parent.type === AST_NODE_TYPES41.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === AST_NODE_TYPES42.TSAsExpression || parent.type === AST_NODE_TYPES42.TSTypeAssertion || parent.type === AST_NODE_TYPES42.TSNonNullExpression || parent.type === AST_NODE_TYPES42.TSSatisfiesExpression || parent.type === AST_NODE_TYPES42.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === AST_NODE_TYPES41.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === AST_NODE_TYPES42.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== AST_NODE_TYPES41.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== AST_NODE_TYPES42.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === AST_NODE_TYPES41.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES41.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES41.Identifier && callee.property.name === "isArray") {
+  if (callee.type === AST_NODE_TYPES42.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES42.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES42.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === AST_NODE_TYPES41.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === AST_NODE_TYPES42.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var isGuardTestPosition = (node) => {
   let current = node;
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case AST_NODE_TYPES41.UnaryExpression:
-      case AST_NODE_TYPES41.LogicalExpression:
-      case AST_NODE_TYPES41.ChainExpression:
+      case AST_NODE_TYPES42.UnaryExpression:
+      case AST_NODE_TYPES42.LogicalExpression:
+      case AST_NODE_TYPES42.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case AST_NODE_TYPES41.IfStatement:
-      case AST_NODE_TYPES41.ConditionalExpression:
-      case AST_NODE_TYPES41.WhileStatement:
-      case AST_NODE_TYPES41.DoWhileStatement:
-      case AST_NODE_TYPES41.ForStatement:
+      case AST_NODE_TYPES42.IfStatement:
+      case AST_NODE_TYPES42.ConditionalExpression:
+      case AST_NODE_TYPES42.WhileStatement:
+      case AST_NODE_TYPES42.DoWhileStatement:
+      case AST_NODE_TYPES42.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -7917,7 +8279,7 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES41.Identifier) {
+  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES42.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -7960,11 +8322,11 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === AST_NODE_TYPES41.Identifier) {
+        if (node.id.type === AST_NODE_TYPES42.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === AST_NODE_TYPES41.ObjectPattern || node.id.type === AST_NODE_TYPES41.ArrayPattern) {
+        if (node.id.type === AST_NODE_TYPES42.ObjectPattern || node.id.type === AST_NODE_TYPES42.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             if (!isFullyNarrowedPattern(node)) {
               context.report({ node: node.id, messageId: "unparsedJsonAccess" });
@@ -7978,7 +8340,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === AST_NODE_TYPES41.Identifier) {
+        if (node.left.type === AST_NODE_TYPES42.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -7988,7 +8350,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === AST_NODE_TYPES41.ObjectPattern || node.left.type === AST_NODE_TYPES41.ArrayPattern) {
+        if (node.left.type === AST_NODE_TYPES42.ObjectPattern || node.left.type === AST_NODE_TYPES42.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -8005,15 +8367,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES41.Identifier) return;
+        if (node.callee.type !== AST_NODE_TYPES42.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === AST_NODE_TYPES41.SpreadElement) continue;
+          if (arg.type === AST_NODE_TYPES42.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES41.Identifier) {
+          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES42.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -8027,13 +8389,13 @@ var prefer_schema_for_api_payload_default = createRule({
         const obj = unwrap4(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          if (parent.type === AST_NODE_TYPES41.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES41.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === AST_NODE_TYPES42.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES42.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === AST_NODE_TYPES41.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === AST_NODE_TYPES42.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -8046,7 +8408,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES42 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES43 } from "@typescript-eslint/utils";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { dirname, join, parse } from "path";
 
@@ -8146,8 +8508,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === AST_NODE_TYPES42.JSXIdentifier) return name.name;
-  if (name.type === AST_NODE_TYPES42.JSXMemberExpression && name.property.type === AST_NODE_TYPES42.JSXIdentifier) {
+  if (name.type === AST_NODE_TYPES43.JSXIdentifier) return name.name;
+  if (name.type === AST_NODE_TYPES43.JSXMemberExpression && name.property.type === AST_NODE_TYPES43.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -8173,7 +8535,7 @@ var EMAIL_OR_PDF_MODULE_RE = /^@react-(?:email|pdf)\//;
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === AST_NODE_TYPES42.JSXElement) {
+    if (current.type === AST_NODE_TYPES43.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -8184,7 +8546,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === AST_NODE_TYPES42.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES42.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES42.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES42.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === AST_NODE_TYPES43.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES43.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES43.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES43.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -8321,12 +8683,12 @@ var hasSemanticTokenSystem = (filename) => {
   return root !== null && workspaceHasMarker(root);
 };
 var propName = (key) => {
-  if (key.type === AST_NODE_TYPES42.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES42.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES43.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES43.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== AST_NODE_TYPES42.ImportDeclaration && statement.type !== AST_NODE_TYPES42.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES42.ExportAllDeclaration) {
+  if (statement.type !== AST_NODE_TYPES43.ImportDeclaration && statement.type !== AST_NODE_TYPES43.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES43.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -8378,27 +8740,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case AST_NODE_TYPES42.Literal:
+        case AST_NODE_TYPES43.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case AST_NODE_TYPES42.TemplateLiteral:
+        case AST_NODE_TYPES43.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case AST_NODE_TYPES42.ArrayExpression:
+        case AST_NODE_TYPES43.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== AST_NODE_TYPES42.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== AST_NODE_TYPES43.SpreadElement) checkClassNode(element);
           }
           break;
-        case AST_NODE_TYPES42.ObjectExpression:
+        case AST_NODE_TYPES43.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === AST_NODE_TYPES42.Property) checkClassNode(property.value);
+            if (property.type === AST_NODE_TYPES43.Property) checkClassNode(property.value);
           }
           break;
-        case AST_NODE_TYPES42.ConditionalExpression:
+        case AST_NODE_TYPES43.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case AST_NODE_TYPES42.LogicalExpression:
+        case AST_NODE_TYPES43.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -8406,32 +8768,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === AST_NODE_TYPES42.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === AST_NODE_TYPES43.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         report(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === AST_NODE_TYPES42.Literal) checkClassNode(node.value);
-        else if (node.value.type === AST_NODE_TYPES42.JSXExpressionContainer) {
-          if (node.value.expression.type !== AST_NODE_TYPES42.JSXEmptyExpression) {
+        if (node.value.type === AST_NODE_TYPES43.Literal) checkClassNode(node.value);
+        else if (node.value.type === AST_NODE_TYPES43.JSXExpressionContainer) {
+          if (node.value.expression.type !== AST_NODE_TYPES43.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES42.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES42.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === AST_NODE_TYPES43.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES43.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === AST_NODE_TYPES42.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === AST_NODE_TYPES43.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== AST_NODE_TYPES42.SpreadElement) checkClassNode(arg);
+            if (arg.type !== AST_NODE_TYPES43.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES42.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === AST_NODE_TYPES43.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -8441,9 +8803,9 @@ var prefer_semantic_colors_default = createRule({
       },
       // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== AST_NODE_TYPES42.Literal) return;
+        if (node.value?.type !== AST_NODE_TYPES43.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === AST_NODE_TYPES42.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === AST_NODE_TYPES43.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -8457,7 +8819,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES42.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === AST_NODE_TYPES43.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -8604,8 +8966,8 @@ var prefer_server_actions_default = createRule({
             }
           }
         } else if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && !node.callee.computed) {
-          const methodName = node.callee.property.name.toLowerCase();
-          if (AXIOS_MUTATION_METHODS.has(methodName)) {
+          const methodName2 = node.callee.property.name.toLowerCase();
+          if (AXIOS_MUTATION_METHODS.has(methodName2)) {
             const urlArg = node.arguments[0];
             const hasHandlerArg = node.arguments.some(
               (arg) => arg.type !== "SpreadElement" && isFunctionArgument(arg, context)
@@ -8663,7 +9025,7 @@ var prefer_single_sentence_comment_default = createRule({
 // src/rules/prefer-string-literal-union.ts
 import {
   ESLintUtils as ESLintUtils3,
-  AST_NODE_TYPES as AST_NODE_TYPES43
+  AST_NODE_TYPES as AST_NODE_TYPES44
 } from "@typescript-eslint/utils";
 import * as ts2 from "typescript";
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
@@ -8707,19 +9069,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === AST_NODE_TYPES43.Identifier) {
+  if (key.type === AST_NODE_TYPES44.Identifier) {
     return key.name;
   }
-  if (key.type === AST_NODE_TYPES43.Literal && typeof key.value === "string") {
+  if (key.type === AST_NODE_TYPES44.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === AST_NODE_TYPES43.TSLiteralType && t.literal.type === AST_NODE_TYPES43.Literal && typeof t.literal.value === "string";
+  return t.type === AST_NODE_TYPES44.TSLiteralType && t.literal.type === AST_NODE_TYPES44.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== AST_NODE_TYPES43.TSUnionType) {
+  if (node?.type !== AST_NODE_TYPES44.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -8748,12 +9110,12 @@ function bindingSourceExpression(decl) {
   return ts2.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === AST_NODE_TYPES43.Identifier) {
+  if (node.type === AST_NODE_TYPES44.Identifier) {
     return node.name;
   }
-  if (node.type === AST_NODE_TYPES43.MemberExpression && !node.computed) {
+  if (node.type === AST_NODE_TYPES44.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== AST_NODE_TYPES43.Identifier) {
+    if (inner === null || node.property.type !== AST_NODE_TYPES44.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -8761,7 +9123,7 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === AST_NODE_TYPES43.Literal && typeof node.value === "string") {
+  if (node.type === AST_NODE_TYPES44.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
@@ -8914,7 +9276,7 @@ var prefer_string_literal_union_default = createRule({
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== AST_NODE_TYPES43.TSStringKeyword) {
+      if (typeNode?.type !== AST_NODE_TYPES44.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -9002,10 +9364,10 @@ var prefer_string_literal_union_default = createRule({
       }
     };
     function refKeyText(node) {
-      if (node.type === AST_NODE_TYPES43.BinaryExpression) {
+      if (node.type === AST_NODE_TYPES44.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === AST_NODE_TYPES43.SwitchStatement) {
+      if (node.type === AST_NODE_TYPES44.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -9014,7 +9376,7 @@ var prefer_string_literal_union_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES45 } from "@typescript-eslint/utils";
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ARRAY_MATCHERS = /* @__PURE__ */ new Set(["toEqual", "toStrictEqual"]);
 var COLLECTION_PROPERTIES = /* @__PURE__ */ new Set(["length", "size"]);
@@ -9023,11 +9385,11 @@ var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
 var MIN_RUN_LENGTH = 2;
 function literalText(node, getText) {
   switch (node.type) {
-    case AST_NODE_TYPES44.Literal:
+    case AST_NODE_TYPES45.Literal:
       return "regex" in node ? null : getText(node);
-    case AST_NODE_TYPES44.TemplateLiteral:
+    case AST_NODE_TYPES45.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case AST_NODE_TYPES44.UnaryExpression:
+    case AST_NODE_TYPES45.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -9035,15 +9397,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case AST_NODE_TYPES44.Identifier:
-    case AST_NODE_TYPES44.ThisExpression:
+    case AST_NODE_TYPES45.Identifier:
+    case AST_NODE_TYPES45.ThisExpression:
       return true;
-    case AST_NODE_TYPES44.MemberExpression:
+    case AST_NODE_TYPES45.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === AST_NODE_TYPES44.Literal && isPureReceiver(node.object);
+        return node.property.type === AST_NODE_TYPES45.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -9051,7 +9413,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== AST_NODE_TYPES44.Literal || typeof node.value !== "number") {
+  if (node.type !== AST_NODE_TYPES45.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -9077,24 +9439,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== AST_NODE_TYPES44.ExpressionStatement) {
+      if (statement.type !== AST_NODE_TYPES45.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== AST_NODE_TYPES44.CallExpression) {
+      if (call.type !== AST_NODE_TYPES45.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== AST_NODE_TYPES44.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES44.Identifier) {
+      if (callee.type !== AST_NODE_TYPES45.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES45.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== AST_NODE_TYPES44.CallExpression || expectCall.callee.type !== AST_NODE_TYPES44.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== AST_NODE_TYPES45.CallExpression || expectCall.callee.type !== AST_NODE_TYPES45.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== AST_NODE_TYPES44.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== AST_NODE_TYPES45.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -9108,7 +9470,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         key = { kind: "index", index };
       } else {
-        if (actual.property.type !== AST_NODE_TYPES44.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
+        if (actual.property.type !== AST_NODE_TYPES45.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
           return null;
         }
         key = { kind: "property", name: actual.property.name };
@@ -9120,7 +9482,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES44.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES45.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -9235,7 +9597,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/prefer-zod-enum.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES45 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES46 } from "@typescript-eslint/utils";
 var prefer_zod_enum_default = createRule({
   name: "prefer-zod-enum",
   meta: {
@@ -9255,25 +9617,25 @@ var prefer_zod_enum_default = createRule({
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES45.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES45.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== AST_NODE_TYPES45.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== AST_NODE_TYPES46.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES46.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== AST_NODE_TYPES46.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
         return null;
       }
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== AST_NODE_TYPES45.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== AST_NODE_TYPES46.ArrayExpression || argument.elements.length === 0) {
         return null;
       }
       const values = [];
       let canFix = true;
       for (const element of argument.elements) {
-        if (element?.type === AST_NODE_TYPES45.SpreadElement) {
+        if (element?.type === AST_NODE_TYPES46.SpreadElement) {
           canFix = false;
           continue;
         }
-        if (element === null || element.type !== AST_NODE_TYPES45.CallExpression || element.callee.type !== AST_NODE_TYPES45.MemberExpression || element.callee.computed || element.callee.object.type !== AST_NODE_TYPES45.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== AST_NODE_TYPES45.Identifier || element.callee.property.name !== "literal") {
+        if (element === null || element.type !== AST_NODE_TYPES46.CallExpression || element.callee.type !== AST_NODE_TYPES46.MemberExpression || element.callee.computed || element.callee.object.type !== AST_NODE_TYPES46.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== AST_NODE_TYPES46.Identifier || element.callee.property.name !== "literal") {
           return null;
         }
         const value = element.arguments[0];
-        if (element.arguments.length !== 1 || value === void 0 || value.type !== AST_NODE_TYPES45.Literal || typeof value.value !== "string") {
+        if (element.arguments.length !== 1 || value === void 0 || value.type !== AST_NODE_TYPES46.Literal || typeof value.value !== "string") {
           canFix = false;
           continue;
         }
@@ -9283,11 +9645,11 @@ var prefer_zod_enum_default = createRule({
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== AST_NODE_TYPES45.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== AST_NODE_TYPES46.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES45.MemberExpression || callee.property.type !== AST_NODE_TYPES45.Identifier) {
+      if (callee.type !== AST_NODE_TYPES46.MemberExpression || callee.property.type !== AST_NODE_TYPES46.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -9304,7 +9666,7 @@ var prefer_zod_enum_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES45.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES45.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES45.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES45.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === AST_NODE_TYPES46.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES46.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES46.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES46.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -9326,7 +9688,7 @@ var prefer_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES46 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES47 } from "@typescript-eslint/utils";
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -9363,44 +9725,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [AST_NODE_TYPES46.TSStringKeyword],
-  email: [AST_NODE_TYPES46.TSStringKeyword],
-  url: [AST_NODE_TYPES46.TSStringKeyword],
-  uuid: [AST_NODE_TYPES46.TSStringKeyword],
-  ulid: [AST_NODE_TYPES46.TSStringKeyword],
-  cuid: [AST_NODE_TYPES46.TSStringKeyword],
-  cuid2: [AST_NODE_TYPES46.TSStringKeyword],
-  nanoid: [AST_NODE_TYPES46.TSStringKeyword],
-  iso: [AST_NODE_TYPES46.TSStringKeyword],
-  number: [AST_NODE_TYPES46.TSNumberKeyword],
-  int: [AST_NODE_TYPES46.TSNumberKeyword],
-  float32: [AST_NODE_TYPES46.TSNumberKeyword],
-  float64: [AST_NODE_TYPES46.TSNumberKeyword],
-  boolean: [AST_NODE_TYPES46.TSBooleanKeyword],
-  bigint: [AST_NODE_TYPES46.TSBigIntKeyword],
-  symbol: [AST_NODE_TYPES46.TSSymbolKeyword],
-  any: [AST_NODE_TYPES46.TSAnyKeyword],
-  unknown: [AST_NODE_TYPES46.TSUnknownKeyword],
-  never: [AST_NODE_TYPES46.TSNeverKeyword],
-  void: [AST_NODE_TYPES46.TSVoidKeyword],
-  null: [AST_NODE_TYPES46.TSNullKeyword],
-  undefined: [AST_NODE_TYPES46.TSUndefinedKeyword],
-  literal: [AST_NODE_TYPES46.TSLiteralType],
-  date: [AST_NODE_TYPES46.TSTypeReference],
-  array: [AST_NODE_TYPES46.TSArrayType, AST_NODE_TYPES46.TSTypeReference],
-  tuple: [AST_NODE_TYPES46.TSTupleType],
-  object: [AST_NODE_TYPES46.TSTypeLiteral, AST_NODE_TYPES46.TSTypeReference],
-  strictObject: [AST_NODE_TYPES46.TSTypeLiteral, AST_NODE_TYPES46.TSTypeReference],
-  looseObject: [AST_NODE_TYPES46.TSTypeLiteral, AST_NODE_TYPES46.TSTypeReference],
-  record: [AST_NODE_TYPES46.TSTypeReference, AST_NODE_TYPES46.TSTypeLiteral],
-  map: [AST_NODE_TYPES46.TSTypeReference],
-  set: [AST_NODE_TYPES46.TSTypeReference],
-  promise: [AST_NODE_TYPES46.TSTypeReference],
-  enum: [AST_NODE_TYPES46.TSUnionType, AST_NODE_TYPES46.TSTypeReference, AST_NODE_TYPES46.TSLiteralType],
-  nativeEnum: [AST_NODE_TYPES46.TSUnionType, AST_NODE_TYPES46.TSTypeReference, AST_NODE_TYPES46.TSLiteralType],
-  union: [AST_NODE_TYPES46.TSUnionType, AST_NODE_TYPES46.TSTypeReference],
-  discriminatedUnion: [AST_NODE_TYPES46.TSUnionType, AST_NODE_TYPES46.TSTypeReference],
-  intersection: [AST_NODE_TYPES46.TSIntersectionType, AST_NODE_TYPES46.TSTypeReference]
+  string: [AST_NODE_TYPES47.TSStringKeyword],
+  email: [AST_NODE_TYPES47.TSStringKeyword],
+  url: [AST_NODE_TYPES47.TSStringKeyword],
+  uuid: [AST_NODE_TYPES47.TSStringKeyword],
+  ulid: [AST_NODE_TYPES47.TSStringKeyword],
+  cuid: [AST_NODE_TYPES47.TSStringKeyword],
+  cuid2: [AST_NODE_TYPES47.TSStringKeyword],
+  nanoid: [AST_NODE_TYPES47.TSStringKeyword],
+  iso: [AST_NODE_TYPES47.TSStringKeyword],
+  number: [AST_NODE_TYPES47.TSNumberKeyword],
+  int: [AST_NODE_TYPES47.TSNumberKeyword],
+  float32: [AST_NODE_TYPES47.TSNumberKeyword],
+  float64: [AST_NODE_TYPES47.TSNumberKeyword],
+  boolean: [AST_NODE_TYPES47.TSBooleanKeyword],
+  bigint: [AST_NODE_TYPES47.TSBigIntKeyword],
+  symbol: [AST_NODE_TYPES47.TSSymbolKeyword],
+  any: [AST_NODE_TYPES47.TSAnyKeyword],
+  unknown: [AST_NODE_TYPES47.TSUnknownKeyword],
+  never: [AST_NODE_TYPES47.TSNeverKeyword],
+  void: [AST_NODE_TYPES47.TSVoidKeyword],
+  null: [AST_NODE_TYPES47.TSNullKeyword],
+  undefined: [AST_NODE_TYPES47.TSUndefinedKeyword],
+  literal: [AST_NODE_TYPES47.TSLiteralType],
+  date: [AST_NODE_TYPES47.TSTypeReference],
+  array: [AST_NODE_TYPES47.TSArrayType, AST_NODE_TYPES47.TSTypeReference],
+  tuple: [AST_NODE_TYPES47.TSTupleType],
+  object: [AST_NODE_TYPES47.TSTypeLiteral, AST_NODE_TYPES47.TSTypeReference],
+  strictObject: [AST_NODE_TYPES47.TSTypeLiteral, AST_NODE_TYPES47.TSTypeReference],
+  looseObject: [AST_NODE_TYPES47.TSTypeLiteral, AST_NODE_TYPES47.TSTypeReference],
+  record: [AST_NODE_TYPES47.TSTypeReference, AST_NODE_TYPES47.TSTypeLiteral],
+  map: [AST_NODE_TYPES47.TSTypeReference],
+  set: [AST_NODE_TYPES47.TSTypeReference],
+  promise: [AST_NODE_TYPES47.TSTypeReference],
+  enum: [AST_NODE_TYPES47.TSUnionType, AST_NODE_TYPES47.TSTypeReference, AST_NODE_TYPES47.TSLiteralType],
+  nativeEnum: [AST_NODE_TYPES47.TSUnionType, AST_NODE_TYPES47.TSTypeReference, AST_NODE_TYPES47.TSLiteralType],
+  union: [AST_NODE_TYPES47.TSUnionType, AST_NODE_TYPES47.TSTypeReference],
+  discriminatedUnion: [AST_NODE_TYPES47.TSUnionType, AST_NODE_TYPES47.TSTypeReference],
+  intersection: [AST_NODE_TYPES47.TSIntersectionType, AST_NODE_TYPES47.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -9409,20 +9771,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== AST_NODE_TYPES46.TSUnionType) {
+  if (annotation.type !== AST_NODE_TYPES47.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === AST_NODE_TYPES46.TSNullKeyword
+      nullable: annotation.type === AST_NODE_TYPES47.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === AST_NODE_TYPES46.TSNullKeyword) {
+    if (member.type === AST_NODE_TYPES47.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === AST_NODE_TYPES46.TSUndefinedKeyword) {
+    if (member.type === AST_NODE_TYPES47.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -9487,35 +9849,35 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === AST_NODE_TYPES46.CallExpression) {
+      while (current.type === AST_NODE_TYPES47.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES46.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES46.Identifier) {
+        if (callee.type !== AST_NODE_TYPES47.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES47.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES46.Identifier) {
+        if (receiver.type === AST_NODE_TYPES47.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
       }
       return null;
     }
-    function methodName(call) {
+    function methodName2(call) {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES46.MemberExpression && callee.property.type === AST_NODE_TYPES46.Identifier ? callee.property.name : "";
+      return callee.type === AST_NODE_TYPES47.MemberExpression && callee.property.type === AST_NODE_TYPES47.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === AST_NODE_TYPES46.CallExpression) {
+      while (current.type === AST_NODE_TYPES47.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES46.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES46.Identifier) {
+        if (callee.type !== AST_NODE_TYPES47.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES47.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES46.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === AST_NODE_TYPES47.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -9538,24 +9900,24 @@ var prefer_zod_infer_default = createRule({
       if (base === void 0) {
         return null;
       }
-      const baseMethod = methodName(base);
+      const baseMethod = methodName2(base);
       if (baseMethod !== "object" && baseMethod !== "strictObject") {
         return null;
       }
-      if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(methodName(call)))) {
+      if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(methodName2(call)))) {
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== AST_NODE_TYPES46.ObjectExpression) {
+      if (shape === void 0 || shape.type !== AST_NODE_TYPES47.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== AST_NODE_TYPES46.Property || property.computed) {
+        if (property.type !== AST_NODE_TYPES47.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === AST_NODE_TYPES46.Identifier ? key.name : key.type === AST_NODE_TYPES46.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === AST_NODE_TYPES47.Identifier ? key.name : key.type === AST_NODE_TYPES47.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -9566,11 +9928,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES46.TSPropertySignature || member.computed) {
+        if (member.type !== AST_NODE_TYPES47.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === AST_NODE_TYPES46.Identifier ? key.name : key.type === AST_NODE_TYPES46.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === AST_NODE_TYPES47.Identifier ? key.name : key.type === AST_NODE_TYPES47.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -9584,8 +9946,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === AST_NODE_TYPES46.TSTypeReference) {
-        if (node.typeName.type === AST_NODE_TYPES46.Identifier) {
+      if (node.type === AST_NODE_TYPES47.TSTypeReference) {
+        if (node.typeName.type === AST_NODE_TYPES47.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -9593,11 +9955,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === AST_NODE_TYPES46.TSArrayType) {
+      if (node.type === AST_NODE_TYPES47.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === AST_NODE_TYPES46.TSUnionType || node.type === AST_NODE_TYPES46.TSIntersectionType) {
+      if (node.type === AST_NODE_TYPES47.TSUnionType || node.type === AST_NODE_TYPES47.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -9641,13 +10003,13 @@ var prefer_zod_infer_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES46.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES46.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES46.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES46.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === AST_NODE_TYPES47.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES47.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES47.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES47.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES46.Identifier || node.init == null) {
+        if (node.id.type !== AST_NODE_TYPES47.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -9657,14 +10019,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === AST_NODE_TYPES46.Identifier && node.property.type === AST_NODE_TYPES46.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === AST_NODE_TYPES47.Identifier && node.property.type === AST_NODE_TYPES47.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === AST_NODE_TYPES46.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES46.TSQualifiedName && typeName.right.type === AST_NODE_TYPES46.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === AST_NODE_TYPES47.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES47.TSQualifiedName && typeName.right.type === AST_NODE_TYPES47.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -9682,7 +10044,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES46.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES47.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -9727,10 +10089,10 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES47 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES48 } from "@typescript-eslint/utils";
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === AST_NODE_TYPES47.EmptyStatement) return false;
-  if (statement.type === AST_NODE_TYPES47.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES48.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES48.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -9746,7 +10108,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES47.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES48.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -9786,7 +10148,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES48, ASTUtils as ASTUtils4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES49, ASTUtils as ASTUtils6 } from "@typescript-eslint/utils";
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -9802,14 +10164,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== AST_NODE_TYPES48.ObjectExpression) {
+  if (init.type !== AST_NODE_TYPES49.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === AST_NODE_TYPES48.SpreadElement) {
+    if (prop.type === AST_NODE_TYPES49.SpreadElement) {
       return false;
     }
-    if (prop.key.type === AST_NODE_TYPES48.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES48.Literal && prop.key.value === "signal") {
+    if (prop.key.type === AST_NODE_TYPES49.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES49.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -9819,7 +10181,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isStringish(node) {
-  return node.type === AST_NODE_TYPES48.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES48.TemplateLiteral;
+  return node.type === AST_NODE_TYPES49.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES49.TemplateLiteral;
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -9856,14 +10218,14 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils4.findVariable(scope, identifier.name);
+      const variable = ASTUtils6.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === AST_NODE_TYPES48.Identifier) {
+      if (callee.type === AST_NODE_TYPES49.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === AST_NODE_TYPES48.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES48.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES48.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === AST_NODE_TYPES49.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES49.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES49.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -9883,28 +10245,51 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-injected-service.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES49 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES50 } from "@typescript-eslint/utils";
 var CONFIGISH_TYPE_RE = /(?:Options|Opts|Config|Configuration|Settings|Params|Props|Args|Env|Environment|Callbacks|Flags)$/;
 var CONFIGISH_NAME_RE = /^(?:options|opts|config|configuration|settings|params|props|args|env|environment|callbacks|flags|logger|log|clock)$/i;
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
 var BUILTIN_CONTAINER_TYPE_RE = /^(?:Record|Map|WeakMap|Set|WeakSet|Array|ReadonlyArray|ReadonlyMap|ReadonlySet|Promise|Partial|Required|Readonly|Pick|Omit|Exclude|Extract|NonNullable|Awaited|Parameters|ReturnType|InstanceType)$/;
+var VALUE_TYPE_RE = /^(?:ArrayBuffer|Blob|Buffer|Date|RegExp|URL|URLSearchParams)$/;
 var TRANSPORT_WRAPPER_NAME_RE = /Client$/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
-var isExportedClass = (node) => node.parent.type === AST_NODE_TYPES49.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES49.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === AST_NODE_TYPES49.Identifier ? name.name : name.type === AST_NODE_TYPES49.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
+var detachedValueExports = (program) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES50.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+      for (const specifier of statement.specifiers) {
+        if (specifier.exportKind !== "type") names.add(specifier.local.name);
+      }
+    } else if (statement.type === AST_NODE_TYPES50.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES50.Identifier) {
+      names.add(statement.declaration.name);
+    } else if (statement.type === AST_NODE_TYPES50.TSExportAssignment && statement.expression.type === AST_NODE_TYPES50.Identifier) {
+      names.add(statement.expression.name);
+    }
+  }
+  return names;
+};
+var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES50.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES50.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var qualifiedName = (name) => name.type === AST_NODE_TYPES50.Identifier ? name.name : name.type === AST_NODE_TYPES50.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var readTypeReference = (annotation) => {
-  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES49.TSTypeReference) return null;
+  if (annotation?.type === AST_NODE_TYPES50.TSUnionType) {
+    const members = annotation.types.filter(
+      (member) => member.type !== AST_NODE_TYPES50.TSUndefinedKeyword && member.type !== AST_NODE_TYPES50.TSNullKeyword
+    );
+    annotation = members.length === 1 ? members[0] : void 0;
+  }
+  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES50.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === AST_NODE_TYPES49.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES49.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === AST_NODE_TYPES50.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES50.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES49.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES49.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES49.Identifier) return null;
+  if (target.type === AST_NODE_TYPES50.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES50.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES50.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference };
@@ -9912,8 +10297,8 @@ var namedParameterCollaborator = (annotated) => {
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== AST_NODE_TYPES49.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== AST_NODE_TYPES49.Identifier) continue;
+    if (member.type !== AST_NODE_TYPES50.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== AST_NODE_TYPES50.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -9924,18 +10309,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES49.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES49.TSInterfaceDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES50.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES50.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== AST_NODE_TYPES49.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== AST_NODE_TYPES50.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === AST_NODE_TYPES49.TSFunctionType || aliased.type === AST_NODE_TYPES49.TSConstructorType) {
+    if (aliased.type === AST_NODE_TYPES50.TSFunctionType || aliased.type === AST_NODE_TYPES50.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === AST_NODE_TYPES49.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES49.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES49.TSTypeLiteral) : [];
+    const literals = aliased.type === AST_NODE_TYPES50.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES50.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES50.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -9948,10 +10333,10 @@ var fileTypeIndex = (program) => {
   return { objects, functionAliases };
 };
 var bagMemberTypes = (annotation, declared) => {
-  if (annotation.type === AST_NODE_TYPES49.TSTypeLiteral) {
+  if (annotation.type === AST_NODE_TYPES50.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== AST_NODE_TYPES49.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES49.Identifier) {
+  if (annotation.type !== AST_NODE_TYPES50.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES50.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
@@ -9963,11 +10348,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== AST_NODE_TYPES49.Property || property.computed) continue;
-    if (property.key.type !== AST_NODE_TYPES49.Identifier) continue;
+    if (property.type !== AST_NODE_TYPES50.Property || property.computed) continue;
+    if (property.key.type !== AST_NODE_TYPES50.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === AST_NODE_TYPES49.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== AST_NODE_TYPES49.Identifier) continue;
+    const bound = property.value.type === AST_NODE_TYPES50.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== AST_NODE_TYPES50.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -9977,8 +10362,8 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var parameterCollaborators = (parameter, declared) => {
   let target = parameter;
-  if (target.type === AST_NODE_TYPES49.AssignmentPattern) target = target.left;
-  if (target.type === AST_NODE_TYPES49.ObjectPattern) {
+  if (target.type === AST_NODE_TYPES50.AssignmentPattern) target = target.left;
+  if (target.type === AST_NODE_TYPES50.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -9996,18 +10381,31 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const storedFrom = /* @__PURE__ */ new Set();
   let constructedFields = 0;
   if (body2 !== null && body2 !== void 0) {
-    for (const statement of body2.body) {
-      if (statement.type !== AST_NODE_TYPES49.ExpressionStatement) continue;
-      const expression = statement.expression;
-      if (expression.type !== AST_NODE_TYPES49.AssignmentExpression || expression.operator !== "=" || expression.left.type !== AST_NODE_TYPES49.MemberExpression || expression.left.object.type !== AST_NODE_TYPES49.ThisExpression) {
+    const pending = [...body2.body];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (current === void 0) break;
+      if (current.type === AST_NODE_TYPES50.ArrowFunctionExpression || current.type === AST_NODE_TYPES50.FunctionExpression || current.type === AST_NODE_TYPES50.FunctionDeclaration || current.type === AST_NODE_TYPES50.ClassExpression || current.type === AST_NODE_TYPES50.ClassDeclaration) continue;
+      const expression = current.type === AST_NODE_TYPES50.ExpressionStatement ? current.expression : null;
+      if (expression?.type !== AST_NODE_TYPES50.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES50.MemberExpression || expression.left.object.type !== AST_NODE_TYPES50.ThisExpression) {
+        for (const key of Object.keys(current)) {
+          if (key === "parent") continue;
+          const value = current[key];
+          for (const child of Array.isArray(value) ? value : [value]) {
+            if (child !== null && typeof child === "object" && typeof child.type === "string") {
+              pending.push(child);
+            }
+          }
+        }
         continue;
       }
-      const source = expression.right;
-      if (source.type === AST_NODE_TYPES49.NewExpression) {
+      let source = expression.right;
+      while (source.type === AST_NODE_TYPES50.TSNonNullExpression || source.type === AST_NODE_TYPES50.TSAsExpression || source.type === AST_NODE_TYPES50.TSSatisfiesExpression || source.type === AST_NODE_TYPES50.TSTypeAssertion) source = source.expression;
+      if (source.type === AST_NODE_TYPES50.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === AST_NODE_TYPES49.Identifier) {
+      } else if (source.type === AST_NODE_TYPES50.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === AST_NODE_TYPES49.MemberExpression && source.object.type === AST_NODE_TYPES49.Identifier) {
+      } else if (source.type === AST_NODE_TYPES50.MemberExpression && source.object.type === AST_NODE_TYPES50.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -10015,12 +10413,13 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared)) {
-      const stored = parameter.type === AST_NODE_TYPES49.TSParameterProperty || storedFrom.has(reference.name);
+      const stored = parameter.type === AST_NODE_TYPES50.TSParameterProperty || storedFrom.has(reference.name);
       if (!stored) continue;
       if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
       if (CONFIGISH_NAME_RE.test(reference.name)) continue;
       if (typeParameters.has(reference.typeName)) continue;
       if (BUILTIN_CONTAINER_TYPE_RE.test(reference.typeName)) continue;
+      if (VALUE_TYPE_RE.test(reference.typeName)) continue;
       if (declared().functionAliases.has(reference.typeName)) continue;
       collaborators.push(reference);
     }
@@ -10049,19 +10448,19 @@ var subtreeHas = (root, found) => {
   return hit;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === AST_NODE_TYPES49.CallExpression) {
+  if (node.type === AST_NODE_TYPES50.CallExpression) {
     const { callee } = node;
-    if (callee.type === AST_NODE_TYPES49.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === AST_NODE_TYPES49.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES49.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === AST_NODE_TYPES50.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === AST_NODE_TYPES50.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES50.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === AST_NODE_TYPES49.TSTypeReference && node.typeName.type === AST_NODE_TYPES49.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === AST_NODE_TYPES50.TSTypeReference && node.typeName.type === AST_NODE_TYPES50.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var stem2 = (name) => name.replace(/^I(?=[A-Z])/, "").replace(/Impl$/, "");
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES49.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES49.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES50.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES50.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
@@ -10076,28 +10475,153 @@ var isTransportWrapper = (className, collaborators, program) => {
     return target.endsWith(other) || other.endsWith(target);
   });
 };
-var publicMethodNames = (body2) => {
+var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type !== AST_NODE_TYPES49.MethodDefinition) continue;
+    if (member.type === AST_NODE_TYPES50.PropertyDefinition) {
+      if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
+      if (member.value?.type !== AST_NODE_TYPES50.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES50.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES50.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES50.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES50.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === AST_NODE_TYPES50.Identifier ? member.key.name : "\u2026");
+      continue;
+    }
+    if (member.type !== AST_NODE_TYPES50.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === AST_NODE_TYPES49.PrivateIdentifier) continue;
-    if (member.key.type === AST_NODE_TYPES49.Identifier) names.push(member.key.name);
+    if (member.key.type === AST_NODE_TYPES50.PrivateIdentifier) continue;
+    if (member.key.type === AST_NODE_TYPES50.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
 };
+function localClassAbstractness(program) {
+  const classes = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES50.ExportNamedDeclaration || statement.type === AST_NODE_TYPES50.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES50.ClassDeclaration && declaration.id !== null) {
+      classes.set(declaration.id.name, declaration.abstract === true);
+      if (declaration.superClass?.type === AST_NODE_TYPES50.Identifier) {
+        parents.set(declaration.id.name, declaration.superClass.name);
+      }
+    }
+  }
+  for (let pass = 0; pass < classes.size; pass += 1) {
+    let changed = false;
+    for (const [name, parent] of parents) {
+      if (classes.get(name) !== true && classes.get(parent) === true) {
+        classes.set(name, true);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  return classes;
+}
+function localInterfaceSurfaces(program) {
+  const interfaces = /* @__PURE__ */ new Map();
+  const parents = /* @__PURE__ */ new Map();
+  const functionAliases = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES50.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES50.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES50.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES50.TSConstructorType)) functionAliases.add(declaration.id.name);
+  }
+  for (const statement of program.body) {
+    const declaration = statement.type === AST_NODE_TYPES50.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES50.TSTypeAliasDeclaration) {
+      const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
+      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES50.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const inherited = parents.get(declaration.id.name) ?? [];
+      for (const part of parts) {
+        if (part.type === AST_NODE_TYPES50.TSTypeReference && part.typeName.type === AST_NODE_TYPES50.Identifier) {
+          inherited.push(part.typeName.name);
+          continue;
+        }
+        if (part.type !== AST_NODE_TYPES50.TSTypeLiteral) continue;
+        for (const member of part.members) {
+          if (member.type !== AST_NODE_TYPES50.TSMethodSignature && member.type !== AST_NODE_TYPES50.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== AST_NODE_TYPES50.Identifier) continue;
+          if (member.type === AST_NODE_TYPES50.TSMethodSignature) {
+            callables2.add(member.key.name);
+            continue;
+          }
+          if (member.type !== AST_NODE_TYPES50.TSPropertySignature) continue;
+          const annotation = member.typeAnnotation?.typeAnnotation;
+          if (annotation?.type === AST_NODE_TYPES50.TSFunctionType || annotation?.type === AST_NODE_TYPES50.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES50.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+        }
+      }
+      interfaces.set(declaration.id.name, callables2);
+      parents.set(declaration.id.name, inherited);
+      continue;
+    }
+    if (declaration?.type !== AST_NODE_TYPES50.TSInterfaceDeclaration) continue;
+    const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
+    for (const member of declaration.body.body) {
+      if (member.type !== AST_NODE_TYPES50.TSMethodSignature && member.type !== AST_NODE_TYPES50.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== AST_NODE_TYPES50.Identifier) continue;
+      if (member.type === AST_NODE_TYPES50.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES50.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES50.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES50.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+    }
+    interfaces.set(declaration.id.name, callables);
+    parents.set(
+      declaration.id.name,
+      [
+        ...parents.get(declaration.id.name) ?? [],
+        ...declaration.extends.flatMap(
+          (heritage) => heritage.expression.type === AST_NODE_TYPES50.Identifier ? [heritage.expression.name] : ["*"]
+        )
+      ]
+    );
+  }
+  for (let pass = 0; pass <= interfaces.size; pass += 1) {
+    let changed = false;
+    for (const [name, inherited] of parents) {
+      const surface = interfaces.get(name);
+      if (surface === void 0) continue;
+      for (const parent of inherited) {
+        const parentSurface = interfaces.get(parent);
+        const additions = parentSurface ?? /* @__PURE__ */ new Set(["*"]);
+        for (const method of additions) {
+          if (!surface.has(method)) {
+            surface.add(method);
+            changed = true;
+          }
+        }
+      }
+    }
+    if (!changed) break;
+  }
+  return interfaces;
+}
+function hasServicePort(node, methods, classes, interfaces) {
+  if (node.superClass !== null) {
+    if (node.superClass.type !== AST_NODE_TYPES50.Identifier) return true;
+    const localAbstract = classes.get(node.superClass.name);
+    if (localAbstract === void 0 || localAbstract) return true;
+  }
+  if (node.implements.length === 0) return false;
+  const combined = /* @__PURE__ */ new Set();
+  for (const implementation of node.implements) {
+    if (implementation.expression.type !== AST_NODE_TYPES50.Identifier) return true;
+    const name = implementation.expression.name;
+    const localAbstract = classes.get(name);
+    if (localAbstract === true) return true;
+    const surface = interfaces.get(name);
+    if (surface === void 0 && localAbstract === void 0) return true;
+    if (surface === void 0) continue;
+    if (surface.has("*")) return true;
+    for (const method of surface) combined.add(method);
+  }
+  return methods.every((method) => combined.has(method));
+}
 var require_interface_for_injected_service_default = createRule({
   name: "require-interface-for-injected-service",
   meta: {
     type: "suggestion",
     docs: {
-      description: "An exported service class with constructor-injected collaborators must implement an interface, so consumers depend on a port they can substitute instead of mocking the class."
+      description: "An exported service class with constructor-injected collaborators should declare the interface its public callable surface implements."
     },
     schema: [],
     messages: {
-      requireInterface: "`{{name}}` stores injected collaborator(s) ({{deps}}) but implements no interface, so every consumer depends on this concrete class and can only be tested by mocking it. Declare an interface with its public method signature(s) ({{methods}}) and `class {{name}} implements <Interface>`."
+      requireInterface: "`{{name}}` stores injected collaborator(s) ({{deps}}) but declares no service interface. Extract its public callable surface ({{methods}}) into a port and declare `class {{name}} implements <Interface>` so consumers can inject that port."
     }
   },
   defaultOptions: [],
@@ -10106,17 +10630,18 @@ var require_interface_for_injected_service_default = createRule({
     if (isTestFile(filename) || isStoryFile(filename) || isScriptFile(filename)) return {};
     if (isGeneratedFile(filename, context.sourceCode.getText())) return {};
     let declaredTypes = null;
+    const detachedExports = detachedValueExports(context.sourceCode.ast);
+    const localClasses = localClassAbstractness(context.sourceCode.ast);
+    const localInterfaces = localInterfaceSurfaces(context.sourceCode.ast);
     const objectTypes = () => declaredTypes ??= fileTypeIndex(context.sourceCode.ast);
     return {
       ClassDeclaration(node) {
         if (node.id === null) return;
-        if (!isExportedClass(node)) return;
+        if (!isExportedClass2(node, detachedExports)) return;
         if (node.abstract === true) return;
-        if (node.superClass !== null) return;
-        if (node.implements.length > 0) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === AST_NODE_TYPES49.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === AST_NODE_TYPES50.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(
@@ -10128,8 +10653,9 @@ var require_interface_for_injected_service_default = createRule({
         if (constructedFields > collaborators.length) return;
         if (isFrameworkWiring(node.body)) return;
         if (isTransportWrapper(node.id.name, collaborators, context.sourceCode.ast)) return;
-        const methods = publicMethodNames(node.body);
+        const methods = publicMethodNames(node.body, objectTypes().functionAliases);
         if (methods.length === 0) return;
+        if (hasServicePort(node, methods, localClasses, localInterfaces)) return;
         context.report({
           node: node.id,
           messageId: "requireInterface",
@@ -10145,37 +10671,37 @@ var require_interface_for_injected_service_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES51 } from "@typescript-eslint/utils";
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression2(node) {
-  if (node.type === AST_NODE_TYPES50.TSAsExpression || node.type === AST_NODE_TYPES50.TSSatisfiesExpression || node.type === AST_NODE_TYPES50.TSNonNullExpression || node.type === AST_NODE_TYPES50.TSTypeAssertion) {
+  if (node.type === AST_NODE_TYPES51.TSAsExpression || node.type === AST_NODE_TYPES51.TSSatisfiesExpression || node.type === AST_NODE_TYPES51.TSNonNullExpression || node.type === AST_NODE_TYPES51.TSTypeAssertion) {
     return unwrapExpression2(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression2(node);
-  if (value.type === AST_NODE_TYPES50.Literal) {
+  if (value.type === AST_NODE_TYPES51.Literal) {
     return true;
   }
-  if (value.type === AST_NODE_TYPES50.TemplateLiteral) {
+  if (value.type === AST_NODE_TYPES51.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === AST_NODE_TYPES50.ArrayExpression) {
+  if (value.type === AST_NODE_TYPES51.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== AST_NODE_TYPES50.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== AST_NODE_TYPES51.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === AST_NODE_TYPES50.ObjectExpression) {
+  if (value.type === AST_NODE_TYPES51.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === AST_NODE_TYPES50.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES50.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === AST_NODE_TYPES51.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES51.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === AST_NODE_TYPES50.Identifier) return property.key.name;
+  if (property.key.type === AST_NODE_TYPES51.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -10197,19 +10723,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== AST_NODE_TYPES50.VariableDeclaration) {
+        if (node.declaration?.type !== AST_NODE_TYPES51.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== AST_NODE_TYPES50.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== AST_NODE_TYPES51.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression2(declaration.init);
-          if (config.type !== AST_NODE_TYPES50.ObjectExpression) {
+          if (config.type !== AST_NODE_TYPES51.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== AST_NODE_TYPES50.Property || propertyName2(property) !== "matcher" || property.value.type === AST_NODE_TYPES50.AssignmentPattern) {
+            if (property.type !== AST_NODE_TYPES51.Property || propertyName2(property) !== "matcher" || property.value.type === AST_NODE_TYPES51.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -10223,18 +10749,18 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES51 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES52 } from "@typescript-eslint/utils";
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES51.Identifier) {
+    if (current.type === AST_NODE_TYPES52.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === AST_NODE_TYPES51.CallExpression) {
+    if (current.type === AST_NODE_TYPES52.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES51.MemberExpression) {
+    if (current.type === AST_NODE_TYPES52.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -10242,23 +10768,23 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== AST_NODE_TYPES51.CallExpression) return false;
+  if (node.type !== AST_NODE_TYPES52.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES51.MemberExpression) return false;
+  if (callee.type !== AST_NODE_TYPES52.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== AST_NODE_TYPES51.Identifier) return false;
+  if (callee.property.type !== AST_NODE_TYPES52.Identifier) return false;
   const method = callee.property.name;
   if (method !== "parse" && method !== "safeParse") return false;
   return looksLikeZodSchema(callee.object);
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === AST_NODE_TYPES51.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES52.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES51.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES52.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES51.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES51.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES52.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES52.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -10278,14 +10804,14 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== AST_NODE_TYPES51.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES52.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES51.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES52.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -10296,8 +10822,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES51.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES51.Identifier || callee.property.name !== "get") {
+      if (callee.type !== AST_NODE_TYPES52.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES52.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -10312,11 +10838,11 @@ var require_zod_form_validation_default = createRule({
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES51.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES51.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES52.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES52.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === AST_NODE_TYPES51.VariableDeclarator && parent.init === node && parent.id.type === AST_NODE_TYPES51.Identifier) {
+      if (parent.type === AST_NODE_TYPES52.VariableDeclarator && parent.init === node && parent.id.type === AST_NODE_TYPES52.Identifier) {
         return parent;
       }
       return null;
@@ -10374,8 +10900,395 @@ var store_insert_requires_on_conflict_default = createRule({
   }
 });
 
+// src/rules/stepdown.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES53, ASTUtils as ASTUtils7 } from "@typescript-eslint/utils";
+function isFunction(node) {
+  return node.type === AST_NODE_TYPES53.ArrowFunctionExpression || node.type === AST_NODE_TYPES53.FunctionDeclaration || node.type === AST_NODE_TYPES53.FunctionExpression;
+}
+function cycleComponents(graph) {
+  const nodes = /* @__PURE__ */ new Set();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [caller, callees] of graph) {
+    nodes.add(caller);
+    for (const callee of callees) {
+      nodes.add(callee);
+      const incoming = reverse.get(callee) ?? /* @__PURE__ */ new Set();
+      incoming.add(caller);
+      reverse.set(callee, incoming);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const finishOrder = [];
+  for (const root of nodes) {
+    if (seen.has(root)) continue;
+    const pending = [
+      { name: root, exiting: false }
+    ];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (current === void 0) break;
+      if (current.exiting) {
+        finishOrder.push(current.name);
+        continue;
+      }
+      if (seen.has(current.name)) continue;
+      seen.add(current.name);
+      pending.push({ name: current.name, exiting: true });
+      for (const callee of graph.get(current.name) ?? []) {
+        if (!seen.has(callee)) pending.push({ name: callee, exiting: false });
+      }
+    }
+  }
+  const components = /* @__PURE__ */ new Map();
+  let nextComponent = 0;
+  const assigned = /* @__PURE__ */ new Set();
+  for (let index = finishOrder.length - 1; index >= 0; index -= 1) {
+    const root = finishOrder[index];
+    if (root === void 0 || assigned.has(root)) continue;
+    const members = [];
+    const pending = [root];
+    assigned.add(root);
+    while (pending.length > 0) {
+      const member = pending.pop();
+      if (member === void 0) break;
+      members.push(member);
+      for (const caller of reverse.get(member) ?? []) {
+        if (!assigned.has(caller)) {
+          assigned.add(caller);
+          pending.push(caller);
+        }
+      }
+    }
+    if (members.length > 1) {
+      for (const cyclicName of members) components.set(cyclicName, nextComponent);
+      nextComponent += 1;
+    }
+  }
+  return components;
+}
+function reportMisordered(context, candidates, scopeDefinitions, calls, pinned) {
+  const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
+  const cycles = cycleComponents(calls);
+  const callers = /* @__PURE__ */ new Map();
+  for (const [caller, callees] of calls) {
+    for (const callee of callees) {
+      if (caller === callee) continue;
+      const names = callers.get(callee) ?? /* @__PURE__ */ new Set();
+      names.add(caller);
+      callers.set(callee, names);
+    }
+  }
+  for (const helper of candidates) {
+    const helperCallers = [...callers.get(helper.name) ?? []];
+    if (pinned.has(helper.name) || helperCallers.length !== 1) continue;
+    const callerName = helperCallers[0];
+    if (callerName === void 0 || cycles.has(helper.name) && cycles.get(helper.name) === cycles.get(callerName)) continue;
+    const caller = byName.get(callerName);
+    if (caller === void 0 || helper.node.range[0] >= caller.node.range[0]) continue;
+    context.report({
+      node: helper.node,
+      messageId: "helperAboveOnlyCaller",
+      data: { helper: helper.name, caller: callerName }
+    });
+  }
+}
+function exportedNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) {
+    if (statement.type !== AST_NODE_TYPES53.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === AST_NODE_TYPES53.FunctionDeclaration && statement.declaration.id !== null) {
+      names.add(statement.declaration.id.name);
+    }
+    if (statement.declaration?.type === AST_NODE_TYPES53.VariableDeclaration) {
+      for (const declarator of statement.declaration.declarations) {
+        if (declarator.id.type === AST_NODE_TYPES53.Identifier) names.add(declarator.id.name);
+      }
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES53.Identifier) {
+        names.add(specifier.local.name);
+      }
+    }
+  }
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES53.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES53.Identifier) names.add(statement.declaration.name);
+    if (statement.type === AST_NODE_TYPES53.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES53.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+  }
+  return names;
+}
+function moduleDefinitions(program) {
+  const definitions = [];
+  for (const statement of program.body) {
+    const node = statement.type === AST_NODE_TYPES53.ExportNamedDeclaration || statement.type === AST_NODE_TYPES53.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === AST_NODE_TYPES53.FunctionDeclaration && node.id !== null && node.body !== null) {
+      definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
+      continue;
+    }
+    if (node?.type !== AST_NODE_TYPES53.VariableDeclaration || node.kind !== "const") continue;
+    for (const declarator of node.declarations) {
+      if (declarator.id.type === AST_NODE_TYPES53.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+        definitions.push({
+          name: declarator.id.name,
+          node: declarator,
+          functionNode: declarator.init,
+          bindingNode: declarator
+        });
+      }
+    }
+  }
+  return definitions;
+}
+function moduleScope(context, program) {
+  const declarations = moduleDefinitions(program);
+  const counts = /* @__PURE__ */ new Map();
+  for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
+  const overloadNames = new Set(
+    program.body.flatMap((statement) => {
+      const node = statement.type === AST_NODE_TYPES53.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === AST_NODE_TYPES53.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+    })
+  );
+  const exported = exportedNames(program);
+  const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1 && !overloadNames.has(node.name));
+  const definitions = scopeDefinitions.filter((definition) => !exported.has(definition.name));
+  const byFunction = new Map(scopeDefinitions.map((definition) => [definition.functionNode, definition]));
+  const calls = /* @__PURE__ */ new Map();
+  const pinned = /* @__PURE__ */ new Set();
+  for (const definition of scopeDefinitions) {
+    const variable = context.sourceCode.getDeclaredVariables(definition.bindingNode)[0];
+    for (const reference of variable?.references ?? []) {
+      if (reference.isWrite() && reference.init !== true) {
+        pinned.add(definition.name);
+        continue;
+      }
+      if (!reference.isRead()) continue;
+      const identifier = reference.identifier;
+      const ancestors = context.sourceCode.getAncestors(identifier);
+      const nearestFunction = [...ancestors].reverse().find(isFunction);
+      const parent = identifier.parent;
+      const callerDefinition = nearestFunction === void 0 ? void 0 : byFunction.get(nearestFunction);
+      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES53.CallExpression || parent.callee !== identifier) {
+        pinned.add(definition.name);
+        continue;
+      }
+      const caller = callerDefinition.name;
+      const callees = calls.get(caller) ?? /* @__PURE__ */ new Set();
+      callees.add(definition.name);
+      calls.set(caller, callees);
+    }
+  }
+  reportMisordered(context, definitions, scopeDefinitions, calls, pinned);
+}
+function methodName(node) {
+  if (node.key.type === AST_NODE_TYPES53.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === AST_NODE_TYPES53.Identifier ? node.key.name : null;
+}
+function referencedMethod(context, node, classVariables) {
+  const objectVariable = node.object.type === AST_NODE_TYPES53.Identifier ? ASTUtils7.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
+  if (node.object.type !== AST_NODE_TYPES53.ThisExpression && !isClassReference) return null;
+  if (node.property.type === AST_NODE_TYPES53.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES53.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES53.Literal && typeof node.property.value === "string" ? node.property.value : null;
+}
+function referencedPropertyName(node) {
+  if (node.property.type === AST_NODE_TYPES53.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES53.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES53.Literal && typeof node.property.value === "string" ? node.property.value : null;
+}
+function walk(node, visitorKeys, visit, nestedFunction = false) {
+  visit(node, nestedFunction);
+  const nested = nestedFunction || isFunction(node);
+  for (const key of visitorKeys[node.type] ?? []) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) if (typeof item === "object" && item !== null && "type" in item) walk(item, visitorKeys, visit, nested);
+    } else if (typeof child === "object" && child !== null && "type" in child) {
+      walk(child, visitorKeys, visit, nested);
+    }
+  }
+}
+function classScope(context, node, computedReferenceNames) {
+  const methods = node.body.body.filter(
+    (member) => member.type === AST_NODE_TYPES53.MethodDefinition
+  );
+  const counts = /* @__PURE__ */ new Map();
+  for (const method of methods) {
+    const name = methodName(method);
+    if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  for (const member of node.body.body) {
+    if (member.type !== AST_NODE_TYPES53.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === AST_NODE_TYPES53.Identifier ? member.key.name : null;
+    if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  const scopeDefinitions = methods.flatMap((method) => {
+    const name = methodName(method);
+    return name !== null && counts.get(name) === 1 ? [{ name, node: method }] : [];
+  });
+  const definitions = methods.flatMap((method) => {
+    const name = methodName(method);
+    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES53.PrivateIdentifier;
+    return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
+  });
+  if (definitions.length === 0) return;
+  const privateNames = new Set(definitions.map((definition) => definition.name));
+  const calls = /* @__PURE__ */ new Map();
+  const pinned = /* @__PURE__ */ new Set();
+  const classVariables = /* @__PURE__ */ new Set();
+  if (node.id !== null) {
+    const internal = ASTUtils7.findVariable(context.sourceCode.getScope(node), node.id.name);
+    if (internal !== null) classVariables.add(internal);
+  }
+  if (node.type === AST_NODE_TYPES53.ClassExpression && node.parent.type === AST_NODE_TYPES53.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES53.Identifier) {
+    const outer = ASTUtils7.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    if (outer !== null) classVariables.add(outer);
+  }
+  for (const method of methods) {
+    const caller = methodName(method);
+    if (caller === null || method.value.body === null) continue;
+    const methodClassVariables = new Set(classVariables);
+    const methodAliases = /* @__PURE__ */ new Set();
+    const parameterDecoratorNodes = /* @__PURE__ */ new Set();
+    for (const parameter of method.value.params) {
+      for (const decorator of parameter.decorators) {
+        walk(decorator, context.sourceCode.visitorKeys, (current) => parameterDecoratorNodes.add(current));
+      }
+    }
+    const thisValue = (value) => {
+      let current = value;
+      while (current?.type === AST_NODE_TYPES53.TSAsExpression || current?.type === AST_NODE_TYPES53.TSSatisfiesExpression || current?.type === AST_NODE_TYPES53.TSNonNullExpression) current = current.expression;
+      return current?.type === AST_NODE_TYPES53.ThisExpression;
+    };
+    const collectAlias = (current, nestedFunction) => {
+      if (nestedFunction || current.type !== AST_NODE_TYPES53.VariableDeclarator && current.type !== AST_NODE_TYPES53.AssignmentPattern) return;
+      if (current.type === AST_NODE_TYPES53.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES53.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === AST_NODE_TYPES53.VariableDeclarator ? current.id : current.left;
+      const value = current.type === AST_NODE_TYPES53.VariableDeclarator ? current.init : current.right;
+      if (!thisValue(value)) return;
+      if (binding.type === AST_NODE_TYPES53.ObjectPattern) {
+        for (const property of binding.properties) {
+          if (property.type === AST_NODE_TYPES53.RestElement) {
+            for (const name of privateNames) pinned.add(name);
+          } else if (property.key.type === AST_NODE_TYPES53.Identifier && privateNames.has(property.key.name)) {
+            pinned.add(property.key.name);
+          }
+        }
+        return;
+      }
+      if (binding.type !== AST_NODE_TYPES53.Identifier) return;
+      const variable = ASTUtils7.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (variable !== null) {
+        methodClassVariables.add(variable);
+        methodAliases.add(variable);
+      }
+    };
+    for (const parameter of method.value.params) {
+      walk(parameter, context.sourceCode.visitorKeys, collectAlias);
+    }
+    for (const statement of method.value.body.body) {
+      walk(statement, context.sourceCode.visitorKeys, collectAlias);
+    }
+    const visitCall = (current, nestedFunction) => {
+      if (current.type === AST_NODE_TYPES53.VariableDeclarator && current.id.type === AST_NODE_TYPES53.ObjectPattern && thisValue(current.init)) {
+        for (const property of current.id.properties) {
+          if (property.type === AST_NODE_TYPES53.RestElement) {
+            for (const name of privateNames) pinned.add(name);
+            continue;
+          }
+          if (property.type === AST_NODE_TYPES53.Property && property.key.type === AST_NODE_TYPES53.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+        }
+      }
+      if (current.type !== AST_NODE_TYPES53.MemberExpression) return;
+      const target = referencedMethod(context, current, methodClassVariables);
+      if (target === null) {
+        const possibleTarget = referencedPropertyName(current);
+        if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
+        return;
+      }
+      if (!privateNames.has(target)) return;
+      const objectVariable = current.object.type === AST_NODE_TYPES53.Identifier ? ASTUtils7.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      if (objectVariable !== null && methodAliases.has(objectVariable)) {
+        pinned.add(target);
+        return;
+      }
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES53.CallExpression || current.parent.callee !== current) {
+        pinned.add(target);
+        return;
+      }
+      const callees = calls.get(caller) ?? /* @__PURE__ */ new Set();
+      callees.add(target);
+      calls.set(caller, callees);
+    };
+    for (const decorator of method.decorators) {
+      walk(decorator, context.sourceCode.visitorKeys, visitCall, true);
+    }
+    if (method.computed) walk(method.key, context.sourceCode.visitorKeys, visitCall, true);
+    for (const parameter of method.value.params) {
+      walk(parameter, context.sourceCode.visitorKeys, visitCall);
+    }
+    for (const statement of method.value.body.body) {
+      walk(statement, context.sourceCode.visitorKeys, visitCall);
+    }
+  }
+  for (const member of node.body.body) {
+    if (member.type === AST_NODE_TYPES53.MethodDefinition || member.type === AST_NODE_TYPES53.TSAbstractMethodDefinition) continue;
+    walk(member, context.sourceCode.visitorKeys, (current) => {
+      if (current.type !== AST_NODE_TYPES53.MemberExpression) return;
+      const target = referencedMethod(context, current, classVariables);
+      const possibleTarget = target ?? referencedPropertyName(current);
+      if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
+    });
+  }
+  for (const name of privateNames) if (computedReferenceNames.has(name)) pinned.add(name);
+  const accessibility = new Map(
+    scopeDefinitions.map((definition) => {
+      const method = definition.node;
+      const accessibility2 = method.key.type === AST_NODE_TYPES53.PrivateIdentifier ? "private" : method.accessibility ?? "public";
+      return [definition.name, accessibility2];
+    })
+  );
+  for (const [caller, callees] of calls) {
+    if (accessibility.get(caller) === "private") continue;
+    for (const callee of callees) pinned.add(callee);
+  }
+  reportMisordered(context, definitions, scopeDefinitions, calls, pinned);
+}
+var stepdown_default = createRule({
+  name: "stepdown",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Place a private helper below its sole direct same-scope caller." },
+    schema: [],
+    messages: {
+      helperAboveOnlyCaller: "Private helper `{{helper}}` is defined above its only caller `{{caller}}`; move it below the caller."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    const classes = [];
+    return {
+      ClassDeclaration: (node) => {
+        classes.push(node);
+      },
+      ClassExpression: (node) => {
+        classes.push(node);
+      },
+      "Program:exit": (program) => {
+        moduleScope(context, program);
+        const computedReferenceNames = /* @__PURE__ */ new Set();
+        walk(program, context.sourceCode.visitorKeys, (node) => {
+          if (node.type === AST_NODE_TYPES53.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES53.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+        });
+        for (const node of classes) classScope(context, node, computedReferenceNames);
+      }
+    };
+  }
+});
+
 // src/rules/zod-naming-convention.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES52 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES54 } from "@typescript-eslint/utils";
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -10400,15 +11313,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES52.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES54.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === AST_NODE_TYPES52.MemberExpression) {
+  while (current.type === AST_NODE_TYPES54.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === AST_NODE_TYPES52.Identifier && receiver.name === "z") {
+    if (receiver.type === AST_NODE_TYPES54.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === AST_NODE_TYPES52.CallExpression) {
+    if (receiver.type === AST_NODE_TYPES54.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -10453,13 +11366,13 @@ var zod_naming_convention_default = createRule({
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== AST_NODE_TYPES52.CallExpression) return;
+        if (init.type !== AST_NODE_TYPES54.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== AST_NODE_TYPES52.MemberExpression) return;
+        if (callee.type !== AST_NODE_TYPES54.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== AST_NODE_TYPES52.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES54.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -10544,6 +11457,7 @@ var rules = {
   "no-json-stringify-error": no_json_stringify_error_default,
   "no-log-only-catch": no_log_only_catch_default,
   "no-long-comment": no_long_comment_default,
+  "no-generic-single-export-module": no_generic_single_export_module_default,
   "no-offset-pagination": no_offset_pagination_default,
   "no-positional-tuple-return": no_positional_tuple_return_default,
   "no-raw-env": no_raw_env_default,
@@ -10591,11 +11505,12 @@ var rules = {
   "require-static-next-matcher": require_static_next_matcher_default,
   "require-zod-form-validation": require_zod_form_validation_default,
   "store-insert-requires-on-conflict": store_insert_requires_on_conflict_default,
+  "stepdown": stepdown_default,
   "zod-naming-convention": zod_naming_convention_default
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "9.13.0"
+  version: "9.14.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",
@@ -10617,6 +11532,7 @@ var recommendedRules = {
   "@sarj/no-json-stringify-error": "warn",
   "@sarj/no-log-only-catch": "warn",
   "@sarj/no-long-comment": "warn",
+  "@sarj/no-generic-single-export-module": "warn",
   "@sarj/no-offset-pagination": "warn",
   "@sarj/no-positional-tuple-return": "warn",
   "@sarj/no-repeated-string-literal": "warn",
@@ -10658,6 +11574,7 @@ var recommendedRules = {
   "@sarj/require-static-next-matcher": "error",
   "@sarj/require-zod-form-validation": "error",
   "@sarj/store-insert-requires-on-conflict": "warn",
+  "@sarj/stepdown": "warn",
   "@sarj/zod-naming-convention": "warn"
 };
 var strictRules = {
@@ -10676,6 +11593,7 @@ var strictRules = {
   "@sarj/no-json-stringify-error": "error",
   "@sarj/no-log-only-catch": "error",
   "@sarj/no-long-comment": "error",
+  "@sarj/no-generic-single-export-module": "warn",
   "@sarj/no-offset-pagination": "error",
   "@sarj/no-positional-tuple-return": "error",
   "@sarj/no-raw-env": "error",
@@ -10720,6 +11638,7 @@ var strictRules = {
   "@sarj/require-static-next-matcher": "error",
   "@sarj/require-zod-form-validation": "error",
   "@sarj/store-insert-requires-on-conflict": "error",
+  "@sarj/stepdown": "warn",
   "@sarj/zod-naming-convention": "error"
 };
 var plugin = {