@sarj/eslint-plugin 15.16.0 → 15.17.0

package/dist/index.cjs

@@ -11695,8 +11695,268 @@ var prefer_module_level_schema_default = createRule({
   }
 });
 
-// src/rules/prefer-named-complex-return-type.ts
+// src/rules/prefer-module-level-refined-schema.ts
 var import_utils66 = require("@typescript-eslint/utils");
+var FACTORIES = /* @__PURE__ */ new Set([
+  "array",
+  "bigint",
+  "boolean",
+  "date",
+  "number",
+  "string"
+]);
+var REFINEMENTS = /* @__PURE__ */ new Set([
+  "brand",
+  "check",
+  "email",
+  "finite",
+  "int",
+  "length",
+  "max",
+  "min",
+  "multipleOf",
+  "nonempty",
+  "positive",
+  "regex",
+  "refine",
+  "safe",
+  "superRefine",
+  "transform",
+  "trim",
+  "url",
+  "uuid"
+]);
+var PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION = {
+  summary: "Declare closed, refined Zod scalar and array schemas at module scope.",
+  rationale: "A closed validation pipeline created inside a function is rebuilt on every invocation and obscures a reusable constraint.",
+  remediation: "Move the validation schema to module scope and call parse on the shared schema.",
+  category: "performance",
+  limitations: ["Only direct Zod scalar/array chains with at least two refinement methods and no non-literal arguments are reported."],
+  examples: [
+    { id: "module-refinement", title: "Share the validation schema", outcome: "no-match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; const BatchSize = z.number().int().min(1).max(1000); export function parse(value: unknown) { return BatchSize.parse(value); }" }], focusPath: "src/options.ts", expectedCount: 0, public: true },
+    { id: "local-refinement", title: "Do not rebuild a closed validation chain", outcome: "match", files: [{ path: "src/options.ts", source: "import { z } from 'zod'; export function parse(value: unknown) { return z.number().int().min(1).max(1000).parse(value); }" }], focusPath: "src/options.ts", expectedCount: 1, public: true }
+  ]
+};
+function enclosingFunction4(node) {
+  let current = node.parent ?? void 0;
+  while (current !== void 0) {
+    if ([import_utils66.AST_NODE_TYPES.ArrowFunctionExpression, import_utils66.AST_NODE_TYPES.FunctionDeclaration, import_utils66.AST_NODE_TYPES.FunctionExpression].includes(current.type)) return current;
+    current = current.parent ?? void 0;
+  }
+  return void 0;
+}
+function collectReferences2(scope, output) {
+  output.push(...scope.references);
+  for (const child of scope.childScopes) collectReferences2(child, output);
+}
+var prefer_module_level_refined_schema_default = createRule({
+  name: "prefer-module-level-refined-schema",
+  documentation: PREFER_MODULE_LEVEL_REFINED_SCHEMA_DOCUMENTATION,
+  meta: { type: "suggestion", docs: { description: "Declare closed, refined Zod scalar and array schemas at module scope." }, schema: [], messages: { hoistRefinedSchema: "Move this closed refined Zod schema to module scope and reuse it for parsing." } },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) if (specifier.type === import_utils66.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils66.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils66.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils66.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") namespaces.add(specifier.local.name);
+      },
+      CallExpression(node) {
+        const enclosing = enclosingFunction4(node);
+        if (enclosing === void 0 || node.parent?.type !== import_utils66.AST_NODE_TYPES.MemberExpression || node.parent.object !== node) return;
+        if (node.callee.type !== import_utils66.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils66.AST_NODE_TYPES.Identifier || !namespaces.has(node.callee.object.name) || node.callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier || !FACTORIES.has(node.callee.property.name)) return;
+        let current = node;
+        let refinements = 0;
+        while (current.parent?.type === import_utils66.AST_NODE_TYPES.MemberExpression && current.parent.object === current && !current.parent.computed && current.parent.property.type === import_utils66.AST_NODE_TYPES.Identifier && current.parent.parent?.type === import_utils66.AST_NODE_TYPES.CallExpression && current.parent.parent.callee === current.parent) {
+          const call = current.parent.parent;
+          if (["parse", "parseAsync", "safeParse", "safeParseAsync"].includes(current.parent.property.name)) break;
+          if (REFINEMENTS.has(current.parent.property.name)) refinements += 1;
+          current = call;
+        }
+        if (refinements < 2) return;
+        const references = [];
+        collectReferences2(context.sourceCode.getScope(current), references);
+        const [start, end] = current.range;
+        const [functionStart, functionEnd] = enclosing.range;
+        for (const reference of references) {
+          const [referenceStart] = reference.identifier.range;
+          if (referenceStart < start || referenceStart >= end || reference.resolved === null) continue;
+          for (const definition of reference.resolved.defs) {
+            if (definition.type === "ImportBinding") continue;
+            if (definition.node.type === import_utils66.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils66.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const") return;
+            const [definitionStart, definitionEnd] = definition.node.range;
+            if (definitionStart >= start && definitionEnd <= end) continue;
+            if (definitionStart >= functionStart && definitionEnd <= functionEnd) return;
+          }
+        }
+        context.report({ node, messageId: "hoistRefinedSchema" });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-multi-value-zod-literal.ts
+var import_utils67 = require("@typescript-eslint/utils");
+var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
+  summary: "Use the Zod 4 multi-value literal API instead of a union of literal schemas.",
+  rationale: "One multi-value literal expresses the same closed value domain without repeated schema wrappers.",
+  remediation: "Replace the union with z.literal([value1, value2, ...]).",
+  category: "maintainability",
+  limitations: [
+    "Bare `zod` imports are analyzed only when the rule option explicitly declares `zodMajorVersion: 4`; `zod/v4` imports are self-declaring."
+  ],
+  examples: [
+    {
+      id: "multi-value",
+      title: "Use one multi-value literal",
+      outcome: "no-match",
+      files: [
+        {
+          path: "src/schema.ts",
+          source: "import { z } from 'zod'; export const Version = z.literal([1, 2, 3]);"
+        }
+      ],
+      focusPath: "src/schema.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "literal-union",
+      title: "Avoid repeated literal wrappers",
+      outcome: "match",
+      files: [
+        {
+          path: "src/schema.ts",
+          source: "import { z } from 'zod'; export const Version = z.union([z.literal(1), z.literal(2), z.literal(3)]);"
+        }
+      ],
+      focusPath: "src/schema.ts",
+      expectedCount: 1,
+      public: true
+    }
+  ]
+};
+function memberCall(node, object, method) {
+  return node.callee.type === import_utils67.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.object.name === object && node.callee.property.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.property.name === method;
+}
+var prefer_multi_value_zod_literal_default = createRule({
+  name: "prefer-multi-value-zod-literal",
+  documentation: PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Use the Zod 4 multi-value literal API instead of a union of literal schemas."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          zodMajorVersion: { type: "integer", minimum: 4, maximum: 4 }
+        }
+      }
+    ],
+    messages: {
+      useMultiValueLiteral: "Replace this literal-schema union with `{{zod}}.literal([\u2026])`."
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options]) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text))
+      return {};
+    const namespaces = /* @__PURE__ */ new Set();
+    const zod4Namespaces = /* @__PURE__ */ new Set();
+    return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils67.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils67.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils67.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils67.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+            namespaces.add(specifier.local.name);
+            if (node.source.value === "zod/v4" || node.source.value.startsWith("zod/v4/"))
+              zod4Namespaces.add(specifier.local.name);
+          }
+        }
+      },
+      CallExpression(node) {
+        const namespace = [...namespaces].find(
+          (name) => memberCall(node, name, "union")
+        );
+        if (namespace === void 0 || options?.zodMajorVersion !== 4 && !zod4Namespaces.has(namespace) || node.arguments.length !== 1)
+          return;
+        const [argument] = node.arguments;
+        if (argument?.type !== import_utils67.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 3 || argument.elements.some((element) => {
+          if (element === null || element.type !== import_utils67.AST_NODE_TYPES.CallExpression || !memberCall(element, namespace, "literal") || element.arguments.length !== 1)
+            return true;
+          const [value] = element.arguments;
+          return value === void 0 || value.type === import_utils67.AST_NODE_TYPES.SpreadElement || ![
+            import_utils67.AST_NODE_TYPES.Literal,
+            import_utils67.AST_NODE_TYPES.TemplateLiteral
+          ].includes(value.type);
+        }))
+          return;
+        context.report({
+          node,
+          messageId: "useMultiValueLiteral",
+          data: { zod: namespace }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-named-callback-domain.ts
+var import_utils68 = require("@typescript-eslint/utils");
+var PREFER_NAMED_CALLBACK_DOMAIN_DOCUMENTATION = {
+  summary: "Name literal-union domains used by callbacks in exported contracts.",
+  rationale: "An inline callback domain hides a reusable vocabulary at the point where callers and implementations must agree.",
+  remediation: "Extract the literal union to a named type and use that type in the callback parameter.",
+  category: "maintainability",
+  limitations: ["Only callback types nested in an exported type alias or exported interface are reported."],
+  examples: [
+    { id: "named-domain", title: "Name the callback domain", outcome: "no-match", files: [{ path: "src/options.ts", source: "export type Boundary = 'seeded' | 'queued'; export interface Options { done?: (boundary: Boundary) => void; }" }], focusPath: "src/options.ts", expectedCount: 0, public: true },
+    { id: "inline-domain", title: "Do not inline a public callback domain", outcome: "match", files: [{ path: "src/options.ts", source: "export interface Options { done?: (boundary: 'seeded' | 'queued') => void; }" }], focusPath: "src/options.ts", expectedCount: 1, public: true }
+  ]
+};
+function isLiteralUnion(node) {
+  return node.type === import_utils68.AST_NODE_TYPES.TSUnionType && node.types.length >= 2 && node.types.every((part) => part.type === import_utils68.AST_NODE_TYPES.TSLiteralType);
+}
+function exportedContract(node) {
+  let current = node;
+  while (current !== void 0) {
+    if (current.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration) return true;
+    if (current.type === import_utils68.AST_NODE_TYPES.Program) return false;
+    current = current.parent ?? void 0;
+  }
+  return false;
+}
+var prefer_named_callback_domain_default = createRule({
+  name: "prefer-named-callback-domain",
+  documentation: PREFER_NAMED_CALLBACK_DOMAIN_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Name literal-union domains used by callbacks in exported contracts." },
+    schema: [],
+    messages: { nameCallbackDomain: "Extract this inline callback literal union to a named domain type." }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      TSFunctionType(node) {
+        if (!exportedContract(node)) return;
+        for (const parameter of node.params) {
+          if (parameter.type !== import_utils68.AST_NODE_TYPES.TSParameterProperty && parameter.typeAnnotation !== void 0 && isLiteralUnion(parameter.typeAnnotation.typeAnnotation)) {
+            context.report({ node: parameter.typeAnnotation.typeAnnotation, messageId: "nameCallbackDomain" });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-named-complex-return-type.ts
+var import_utils69 = require("@typescript-eslint/utils");
 var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
   summary: "Prefer a named contract for structurally complex function return types.",
   rationale: "A large inline return annotation hides a reusable domain concept and makes signatures difficult to scan.",
@@ -11712,7 +11972,7 @@ var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
   ]
 };
 function unwrap4(node) {
-  if (node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeArguments?.params.length === 1) {
+  if (node.type === import_utils69.AST_NODE_TYPES.TSTypeReference && node.typeArguments?.params.length === 1) {
     const [inner] = node.typeArguments.params;
     if (inner !== void 0) return unwrap4(inner);
   }
@@ -11726,9 +11986,9 @@ function report(context, node) {
 }
 function isComplex(node) {
   const type = unwrap4(node);
-  if (type.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) return type.members.length >= 3;
-  if (type.type !== import_utils66.AST_NODE_TYPES.TSUnionType || type.types.length < 3) return false;
-  return type.types.every((member) => unwrap4(member).type === import_utils66.AST_NODE_TYPES.TSTypeLiteral);
+  if (type.type === import_utils69.AST_NODE_TYPES.TSTypeLiteral) return type.members.length >= 3;
+  if (type.type !== import_utils69.AST_NODE_TYPES.TSUnionType || type.types.length < 3) return false;
+  return type.types.every((member) => unwrap4(member).type === import_utils69.AST_NODE_TYPES.TSTypeLiteral);
 }
 var prefer_named_complex_return_type_default = createRule({
   name: "prefer-named-complex-return-type",
@@ -11755,7 +12015,7 @@ var prefer_named_complex_return_type_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-var import_utils67 = require("@typescript-eslint/utils");
+var import_utils70 = require("@typescript-eslint/utils");
 var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
@@ -11769,7 +12029,7 @@ var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   ]
 };
 function requireUuid(node) {
-  return node?.type === import_utils67.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils67.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
+  return node?.type === import_utils70.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils70.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils70.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -11791,7 +12051,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return import_utils67.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -11813,37 +12073,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 === import_utils67.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils67.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === import_utils70.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils70.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === import_utils67.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+          } else if (specifier.type === import_utils70.AST_NODE_TYPES.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== import_utils67.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils67.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== import_utils70.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils70.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === import_utils67.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils70.AST_NODE_TYPES.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== import_utils67.AST_NODE_TYPES.ObjectPattern) return;
+        if (node.id.type !== import_utils70.AST_NODE_TYPES.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === import_utils67.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils67.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils67.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils67.AST_NODE_TYPES.Identifier) {
+          if (property.type === import_utils70.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils70.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils70.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils70.AST_NODE_TYPES.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === import_utils67.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils70.AST_NODE_TYPES.Identifier) {
           const variable2 = resolve(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
-        if (node.callee.type !== import_utils67.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils67.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils67.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils70.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils70.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve(node.callee.object);
@@ -11854,7 +12114,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-node-crypto-hash.ts
-var import_utils68 = require("@typescript-eslint/utils");
+var import_utils71 = require("@typescript-eslint/utils");
 var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   summary: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
   rationale: "A createHash-update-digest chain allocates mutable streaming state for a single in-memory value; Node's built-in hash function expresses the one-shot operation directly and can use its optimized fast path.",
@@ -11870,33 +12130,33 @@ var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   ]
 };
 function memberName3(node) {
-  if (!node.computed && node.property.type === import_utils68.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils68.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+  if (!node.computed && node.property.type === import_utils71.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
     return node.property.value;
   }
   return null;
 }
 function isCryptoLoader(node, resolve) {
-  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression || node.arguments.length !== 1) return false;
+  if (node.type !== import_utils71.AST_NODE_TYPES.CallExpression || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
-  if (argument === void 0 || argument.type === import_utils68.AST_NODE_TYPES.SpreadElement || !isCryptoSpecifier(argument)) {
+  if (argument === void 0 || argument.type === import_utils71.AST_NODE_TYPES.SpreadElement || !isCryptoSpecifier(argument)) {
     return false;
   }
-  if (node.callee.type === import_utils68.AST_NODE_TYPES.Identifier) {
+  if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier) {
     return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve);
   }
-  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils68.AST_NODE_TYPES.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve) && memberName3(node.callee) === "getBuiltinModule";
+  return node.callee.type === import_utils71.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils71.AST_NODE_TYPES.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve) && memberName3(node.callee) === "getBuiltinModule";
 }
 function isCryptoSpecifier(node) {
-  return node.type === import_utils68.AST_NODE_TYPES.Literal && (node.value === "crypto" || node.value === "node:crypto");
+  return node.type === import_utils71.AST_NODE_TYPES.Literal && (node.value === "crypto" || node.value === "node:crypto");
 }
 function isUnshadowedBuiltinIdentifier(identifier, resolve) {
   const variable = resolve(identifier);
   return variable === null || variable.defs.length === 0;
 }
 function propertyName3(node) {
-  if (!node.computed && node.key.type === import_utils68.AST_NODE_TYPES.Identifier) return node.key.name;
-  if (node.key.type === import_utils68.AST_NODE_TYPES.Literal && typeof node.key.value === "string") {
+  if (!node.computed && node.key.type === import_utils71.AST_NODE_TYPES.Identifier) return node.key.name;
+  if (node.key.type === import_utils71.AST_NODE_TYPES.Literal && typeof node.key.value === "string") {
     return node.key.value;
   }
   return null;
@@ -11910,7 +12170,7 @@ var prefer_node_crypto_hash_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return import_utils68.ASTUtils.findVariable(
+      return import_utils71.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -11923,9 +12183,9 @@ var prefer_node_crypto_hash_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "crypto" && node.source.value !== "node:crypto") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils68.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils68.AST_NODE_TYPES.ImportDefaultSpecifier) {
+          if (specifier.type === import_utils71.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils71.AST_NODE_TYPES.ImportDefaultSpecifier) {
             record(specifier.local, namespaceBindings);
-          } else if (specifier.type === import_utils68.AST_NODE_TYPES.ImportSpecifier && importedName5(specifier.imported) === "createHash") {
+          } else if (specifier.type === import_utils71.AST_NODE_TYPES.ImportSpecifier && importedName5(specifier.imported) === "createHash") {
             record(specifier.local, directBindings);
           }
         }
@@ -11934,13 +12194,13 @@ var prefer_node_crypto_hash_default = createRule({
         if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve)) {
           return;
         }
-        if (node.id.type === import_utils68.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils71.AST_NODE_TYPES.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== import_utils68.AST_NODE_TYPES.ObjectPattern) return;
+        if (node.id.type !== import_utils71.AST_NODE_TYPES.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === import_utils68.AST_NODE_TYPES.Property && propertyName3(property) === "createHash" && property.value.type === import_utils68.AST_NODE_TYPES.Identifier) {
+          if (property.type === import_utils71.AST_NODE_TYPES.Property && propertyName3(property) === "createHash" && property.value.type === import_utils71.AST_NODE_TYPES.Identifier) {
             record(property.value, directBindings);
           }
         }
@@ -11948,10 +12208,10 @@ var prefer_node_crypto_hash_default = createRule({
       CallExpression(node) {
         if (!isMemberCall(node, "digest")) return;
         const update = node.callee.object;
-        if (update.type !== import_utils68.AST_NODE_TYPES.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
+        if (update.type !== import_utils71.AST_NODE_TYPES.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
           return;
         const create = update.callee.object;
-        if (create.type !== import_utils68.AST_NODE_TYPES.CallExpression || create.arguments.length !== 1 || create.arguments[0]?.type !== import_utils68.AST_NODE_TYPES.Literal || typeof create.arguments[0].value !== "string" || !isCreateHashCall(
+        if (create.type !== import_utils71.AST_NODE_TYPES.CallExpression || create.arguments.length !== 1 || create.arguments[0]?.type !== import_utils71.AST_NODE_TYPES.Literal || typeof create.arguments[0].value !== "string" || !isCreateHashCall(
           create,
           directBindings,
           namespaceBindings,
@@ -11964,27 +12224,27 @@ var prefer_node_crypto_hash_default = createRule({
   }
 });
 function importedName5(node) {
-  return node.type === import_utils68.AST_NODE_TYPES.Identifier ? node.name : node.value;
+  return node.type === import_utils71.AST_NODE_TYPES.Identifier ? node.name : node.value;
 }
 function isMemberCall(node, name) {
-  return node.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && memberName3(node.callee) === name;
+  return node.callee.type === import_utils71.AST_NODE_TYPES.MemberExpression && memberName3(node.callee) === name;
 }
 function isCreateHashCall(node, directBindings, namespaceBindings, resolve) {
-  if (node.callee.type === import_utils68.AST_NODE_TYPES.Identifier) {
+  if (node.callee.type === import_utils71.AST_NODE_TYPES.Identifier) {
     const variable2 = resolve(node.callee);
     return variable2 !== null && directBindings.has(variable2);
   }
-  if (node.callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression || memberName3(node.callee) !== "createHash") {
+  if (node.callee.type !== import_utils71.AST_NODE_TYPES.MemberExpression || memberName3(node.callee) !== "createHash") {
     return false;
   }
   if (isCryptoLoader(node.callee.object, resolve)) return true;
-  if (node.callee.object.type !== import_utils68.AST_NODE_TYPES.Identifier) return false;
+  if (node.callee.object.type !== import_utils71.AST_NODE_TYPES.Identifier) return false;
   const variable = resolve(node.callee.object);
   return variable !== null && namespaceBindings.has(variable);
 }
 
 // src/rules/prefer-node-fs-promises.ts
-var import_utils69 = require("@typescript-eslint/utils");
+var import_utils72 = require("@typescript-eslint/utils");
 var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
   summary: "Prefer promise-based Node.js filesystem APIs over synchronous calls in production modules.",
   rationale: "Synchronous filesystem work blocks the event loop and can stall unrelated daemon, server, and worker tasks.",
@@ -12001,30 +12261,30 @@ var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
   ]
 };
 function memberName4(node) {
-  if (!node.computed && node.property.type === import_utils69.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+  if (!node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
     return node.property.value;
   }
   return null;
 }
 function unwrapAwait2(node) {
-  return node.type === import_utils69.AST_NODE_TYPES.AwaitExpression ? node.argument : node;
+  return node.type === import_utils72.AST_NODE_TYPES.AwaitExpression ? node.argument : node;
 }
 function isFsLoader(node) {
   const expression = unwrapAwait2(node);
-  if (expression.type === import_utils69.AST_NODE_TYPES.ImportExpression) return isFsSpecifier(expression.source);
-  if (expression.type !== import_utils69.AST_NODE_TYPES.CallExpression || expression.arguments.length !== 1) return false;
+  if (expression.type === import_utils72.AST_NODE_TYPES.ImportExpression) return isFsSpecifier(expression.source);
+  if (expression.type !== import_utils72.AST_NODE_TYPES.CallExpression || expression.arguments.length !== 1) return false;
   const [argument] = expression.arguments;
-  if (argument === void 0 || argument.type === import_utils69.AST_NODE_TYPES.SpreadElement || !isFsSpecifier(argument)) return false;
-  if (expression.callee.type === import_utils69.AST_NODE_TYPES.Identifier) return expression.callee.name === "require";
-  return expression.callee.type === import_utils69.AST_NODE_TYPES.MemberExpression && expression.callee.object.type === import_utils69.AST_NODE_TYPES.Identifier && expression.callee.object.name === "process" && memberName4(expression.callee) === "getBuiltinModule";
+  if (argument === void 0 || argument.type === import_utils72.AST_NODE_TYPES.SpreadElement || !isFsSpecifier(argument)) return false;
+  if (expression.callee.type === import_utils72.AST_NODE_TYPES.Identifier) return expression.callee.name === "require";
+  return expression.callee.type === import_utils72.AST_NODE_TYPES.MemberExpression && expression.callee.object.type === import_utils72.AST_NODE_TYPES.Identifier && expression.callee.object.name === "process" && memberName4(expression.callee) === "getBuiltinModule";
 }
 function isFsSpecifier(node) {
-  return node.type === import_utils69.AST_NODE_TYPES.Literal && (node.value === "node:fs" || node.value === "fs");
+  return node.type === import_utils72.AST_NODE_TYPES.Literal && (node.value === "node:fs" || node.value === "fs");
 }
 function propertyName4(node) {
-  if (!node.computed && node.key.type === import_utils69.AST_NODE_TYPES.Identifier) return node.key.name;
-  if (node.key.type === import_utils69.AST_NODE_TYPES.Literal && typeof node.key.value === "string") return node.key.value;
+  if (!node.computed && node.key.type === import_utils72.AST_NODE_TYPES.Identifier) return node.key.name;
+  if (node.key.type === import_utils72.AST_NODE_TYPES.Literal && typeof node.key.value === "string") return node.key.value;
   return null;
 }
 var prefer_node_fs_promises_default = createRule({
@@ -12049,11 +12309,11 @@ var prefer_node_fs_promises_default = createRule({
         if (node.source.value !== "node:fs" && node.source.value !== "fs") return;
         const synchronousImports = [];
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils69.AST_NODE_TYPES.ImportDefaultSpecifier) {
+          if (specifier.type === import_utils72.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils72.AST_NODE_TYPES.ImportDefaultSpecifier) {
             namespaces.add(specifier.local.name);
             continue;
           }
-          if (specifier.type === import_utils69.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils69.AST_NODE_TYPES.Identifier && specifier.imported.name.endsWith("Sync")) synchronousImports.push(specifier.imported.name);
+          if (specifier.type === import_utils72.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils72.AST_NODE_TYPES.Identifier && specifier.imported.name.endsWith("Sync")) synchronousImports.push(specifier.imported.name);
         }
         if (synchronousImports.length > 0) {
           context.report({
@@ -12064,15 +12324,15 @@ var prefer_node_fs_promises_default = createRule({
         }
       },
       VariableDeclarator(node) {
-        if (node.init === null || !isFsLoader(node.init) && (node.init.type !== import_utils69.AST_NODE_TYPES.Identifier || !namespaces.has(node.init.name)))
+        if (node.init === null || !isFsLoader(node.init) && (node.init.type !== import_utils72.AST_NODE_TYPES.Identifier || !namespaces.has(node.init.name)))
           return;
-        if (node.id.type === import_utils69.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils72.AST_NODE_TYPES.Identifier) {
           namespaces.add(node.id.name);
           return;
         }
-        if (node.id.type !== import_utils69.AST_NODE_TYPES.ObjectPattern) return;
+        if (node.id.type !== import_utils72.AST_NODE_TYPES.ObjectPattern) return;
         const synchronousImports = node.id.properties.flatMap((property) => {
-          if (property.type !== import_utils69.AST_NODE_TYPES.Property) return [];
+          if (property.type !== import_utils72.AST_NODE_TYPES.Property) return [];
           const name = propertyName4(property);
           return name?.endsWith("Sync") === true ? [name] : [];
         });
@@ -12088,7 +12348,7 @@ var prefer_node_fs_promises_default = createRule({
         const name = memberName4(node);
         if (name?.endsWith("Sync") !== true) return;
         const object = unwrapAwait2(node.object);
-        if (object.type === import_utils69.AST_NODE_TYPES.Identifier && namespaces.has(object.name) || isFsLoader(object)) {
+        if (object.type === import_utils72.AST_NODE_TYPES.Identifier && namespaces.has(object.name) || isFsLoader(object)) {
           context.report({ node, messageId: "preferAsyncFs", data: { name } });
         }
       }
@@ -12097,7 +12357,7 @@ var prefer_node_fs_promises_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils70 = require("@typescript-eslint/utils");
+var import_utils73 = require("@typescript-eslint/utils");
 var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -12113,33 +12373,33 @@ var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName5(node) {
   const key = node.key;
   if (node.computed) return null;
-  if (key.type === import_utils70.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils70.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils73.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils73.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function isArrayType(node) {
-  if (node.type === import_utils70.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils70.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils70.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils73.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils73.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils73.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function nullableProperty(node) {
   if (node.optional) return null;
   const name = propertyName5(node);
   const annotation = node.typeAnnotation?.typeAnnotation;
-  if (name === null || annotation?.type !== import_utils70.AST_NODE_TYPES.TSUnionType) return null;
+  if (name === null || annotation?.type !== import_utils73.AST_NODE_TYPES.TSUnionType) return null;
   const concrete = annotation.types.filter(
-    (member) => member.type !== import_utils70.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils70.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type !== import_utils73.AST_NODE_TYPES.TSNullKeyword && member.type !== import_utils73.AST_NODE_TYPES.TSUndefinedKeyword
   );
   if (concrete.length === 0 || !concrete.every(isArrayType)) return null;
-  const acceptsNull = annotation.types.some((member) => member.type === import_utils70.AST_NODE_TYPES.TSNullKeyword);
+  const acceptsNull = annotation.types.some((member) => member.type === import_utils73.AST_NODE_TYPES.TSNullKeyword);
   const acceptsUndefined = annotation.types.some(
-    (member) => member.type === import_utils70.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type === import_utils73.AST_NODE_TYPES.TSUndefinedKeyword
   );
   if (!acceptsNull && !acceptsUndefined) return null;
   return { name, node, acceptsNull, acceptsUndefined };
 }
 function shapeProperties(members) {
   return members.flatMap((member) => {
-    if (member.type !== import_utils70.AST_NODE_TYPES.TSPropertySignature) return [];
+    if (member.type !== import_utils73.AST_NODE_TYPES.TSPropertySignature) return [];
     const property = nullableProperty(member);
     return property === null ? [] : [property];
   });
@@ -12147,14 +12407,14 @@ function shapeProperties(members) {
 function typeIndex(program) {
   const index = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const exported = statement.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration;
+    const exported = statement.type === import_utils73.AST_NODE_TYPES.ExportNamedDeclaration;
     const declaration = exported ? statement.declaration : statement;
-    if (declaration?.type === import_utils70.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    if (declaration?.type === import_utils73.AST_NODE_TYPES.TSInterfaceDeclaration) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.body.body)
       });
-    } else if (declaration?.type === import_utils70.AST_NODE_TYPES.TSTypeAliasDeclaration && declaration.typeAnnotation.type === import_utils70.AST_NODE_TYPES.TSTypeLiteral) {
+    } else if (declaration?.type === import_utils73.AST_NODE_TYPES.TSTypeAliasDeclaration && declaration.typeAnnotation.type === import_utils73.AST_NODE_TYPES.TSTypeLiteral) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.typeAnnotation.members)
@@ -12164,42 +12424,42 @@ function typeIndex(program) {
   return index;
 }
 function emptyArray(node) {
-  return node.type === import_utils70.AST_NODE_TYPES.ArrayExpression && node.elements.length === 0;
+  return node.type === import_utils73.AST_NODE_TYPES.ArrayExpression && node.elements.length === 0;
 }
 function sameAccess(node, access) {
   if (access.kind === "identifier") {
-    return node.type === import_utils70.AST_NODE_TYPES.Identifier && node.name === access.name;
+    return node.type === import_utils73.AST_NODE_TYPES.Identifier && node.name === access.name;
   }
-  return node.type === import_utils70.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils70.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils70.AST_NODE_TYPES.Identifier && node.property.name === access.property;
+  return node.type === import_utils73.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils73.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils73.AST_NODE_TYPES.Identifier && node.property.name === access.property;
 }
 function isNullGuard(node, access) {
-  if (node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
-  if (node.type !== import_utils70.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
+  if (node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
+  if (node.type !== import_utils73.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
-  const nullish = (value) => value.type === import_utils70.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils70.AST_NODE_TYPES.Identifier && value.name === "undefined";
+  const nullish = (value) => value.type === import_utils73.AST_NODE_TYPES.Literal && value.value === null || value.type === import_utils73.AST_NODE_TYPES.Identifier && value.name === "undefined";
   return sameAccess(node.left, access) && nullish(node.right) || sameAccess(node.right, access) && nullish(node.left);
 }
 function isEmptyGuard(node, access) {
-  if (node.type === import_utils70.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
-  if (node.type !== import_utils70.AST_NODE_TYPES.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
+  if (node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
+  if (node.type !== import_utils73.AST_NODE_TYPES.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
     return false;
   }
-  const zero = (value) => value.type === import_utils70.AST_NODE_TYPES.Literal && value.value === 0;
+  const zero = (value) => value.type === import_utils73.AST_NODE_TYPES.Literal && value.value === 0;
   return memberLengthOf(node.left, access) && zero(node.right) || memberLengthOf(node.right, access) && zero(node.left);
 }
 function memberLengthOf(node, access) {
-  const target = node.type === import_utils70.AST_NODE_TYPES.ChainExpression ? node.expression : node;
-  return target.type === import_utils70.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils70.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+  const target = node.type === import_utils73.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+  return target.type === import_utils73.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils73.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
 }
 function optionalMemberLengthOf(node, access) {
-  return node.type === import_utils70.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils70.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
+  return node.type === import_utils73.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils73.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
-  if (fn.body.type !== import_utils70.AST_NODE_TYPES.BlockStatement) return false;
+  if (fn.body.type !== import_utils73.AST_NODE_TYPES.BlockStatement) return false;
   const first = fn.body.body[0];
-  if (first?.type !== import_utils70.AST_NODE_TYPES.IfStatement) return false;
-  const terminating = first.consequent.type === import_utils70.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils70.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils70.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils70.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils70.AST_NODE_TYPES.ThrowStatement);
+  if (first?.type !== import_utils73.AST_NODE_TYPES.IfStatement) return false;
+  const terminating = first.consequent.type === import_utils73.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils73.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils73.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils73.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils73.AST_NODE_TYPES.ThrowStatement);
   if (!terminating) return false;
   if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
   return contains(first.test, visitorKeys, (node) => isNullGuard(node, access)) && contains(first.test, visitorKeys, (node) => isEmptyGuard(node, access));
@@ -12217,29 +12477,29 @@ function contains(node, visitorKeys, predicate) {
 function belongsToFunction(node, fn) {
   let current = node;
   while (current !== void 0 && current !== fn) {
-    if (current !== node && (current.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils70.AST_NODE_TYPES.FunctionExpression)) return false;
+    if (current !== node && (current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression)) return false;
     current = current.parent;
   }
   return current === fn;
 }
 function directlyCoalesced(node) {
   const parent = node.parent;
-  return parent?.type === import_utils70.AST_NODE_TYPES.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
+  return parent?.type === import_utils73.AST_NODE_TYPES.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = import_utils73.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = import_utils73.ASTUtils.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
     const parent = reference.identifier.parent;
-    if (parent?.type === import_utils70.AST_NODE_TYPES.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === import_utils70.AST_NODE_TYPES.Identifier && parent.property.name === property) return [parent];
+    if (parent?.type === import_utils73.AST_NODE_TYPES.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === import_utils73.AST_NODE_TYPES.Identifier && parent.property.name === property) return [parent];
     return [];
   });
   return accesses.length > 0 && accesses.every((access) => access !== null && directlyCoalesced(access));
@@ -12265,8 +12525,8 @@ var prefer_non_nullable_collection_default = createRule({
     let shapes = /* @__PURE__ */ new Map();
     const evidence = /* @__PURE__ */ new Map();
     function propertiesFor(annotation) {
-      if (annotation?.type === import_utils70.AST_NODE_TYPES.TSTypeLiteral) return shapeProperties(annotation.members);
-      if (annotation?.type === import_utils70.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils70.AST_NODE_TYPES.Identifier) {
+      if (annotation?.type === import_utils73.AST_NODE_TYPES.TSTypeLiteral) return shapeProperties(annotation.members);
+      if (annotation?.type === import_utils73.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils73.AST_NODE_TYPES.Identifier) {
         const shape = shapes.get(annotation.typeName.name);
         return shape?.exported === false ? shape.properties : [];
       }
@@ -12279,21 +12539,21 @@ var prefer_non_nullable_collection_default = createRule({
     }
     function checkFunction(fn) {
       for (const rawParameter of fn.params) {
-        const parameter = rawParameter.type === import_utils70.AST_NODE_TYPES.AssignmentPattern ? rawParameter.left : rawParameter;
-        if (parameter.type === import_utils70.AST_NODE_TYPES.ObjectPattern) {
+        const parameter = rawParameter.type === import_utils73.AST_NODE_TYPES.AssignmentPattern ? rawParameter.left : rawParameter;
+        if (parameter.type === import_utils73.AST_NODE_TYPES.ObjectPattern) {
           const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
           for (const property of properties2) {
             const bindingProperty = parameter.properties.find(
-              (entry) => entry.type === import_utils70.AST_NODE_TYPES.Property && !entry.computed && entry.key.type === import_utils70.AST_NODE_TYPES.Identifier && entry.key.name === property.name
+              (entry) => entry.type === import_utils73.AST_NODE_TYPES.Property && !entry.computed && entry.key.type === import_utils73.AST_NODE_TYPES.Identifier && entry.key.name === property.name
             );
             if (bindingProperty === void 0) continue;
             const value = bindingProperty.value;
-            const binding = value.type === import_utils70.AST_NODE_TYPES.AssignmentPattern ? value.left : value;
-            if (binding.type !== import_utils70.AST_NODE_TYPES.Identifier) {
+            const binding = value.type === import_utils73.AST_NODE_TYPES.AssignmentPattern ? value.left : value;
+            if (binding.type !== import_utils73.AST_NODE_TYPES.Identifier) {
               record(property, false);
               continue;
             }
-            if (value.type === import_utils70.AST_NODE_TYPES.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
+            if (value.type === import_utils73.AST_NODE_TYPES.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
               record(property, true);
               continue;
             }
@@ -12305,7 +12565,7 @@ var prefer_non_nullable_collection_default = createRule({
           }
           continue;
         }
-        if (parameter.type !== import_utils70.AST_NODE_TYPES.Identifier) continue;
+        if (parameter.type !== import_utils73.AST_NODE_TYPES.Identifier) continue;
         const properties = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
         for (const property of properties) {
           const access = {
@@ -12342,7 +12602,7 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-nullish-filter-predicate.ts
-var import_utils71 = require("@typescript-eslint/utils");
+var import_utils74 = require("@typescript-eslint/utils");
 var import_typescript = __toESM(require("typescript"), 1);
 var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   summary: "Prefer an explicit nullish predicate when `filter(Boolean)` removes only nullish values but does not narrow the result type.",
@@ -12386,7 +12646,7 @@ var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   ]
 };
 function isUnshadowedBoolean(node, context) {
-  const variable = import_utils71.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = import_utils74.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isBuiltinArrayFilter(node, services) {
@@ -12445,7 +12705,7 @@ function isProvablyTruthy(type, checker) {
 }
 function availableParameterName(node, context) {
   for (const name of ["value", "item", "element", "candidate"]) {
-    if (import_utils71.ASTUtils.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+    if (import_utils74.ASTUtils.findVariable(context.sourceCode.getScope(node), name) === null) return name;
   }
   return null;
 }
@@ -12467,7 +12727,7 @@ var prefer_nullish_filter_predicate_default = createRule({
     if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let services;
     try {
-      services = import_utils71.ESLintUtils.getParserServices(context);
+      services = import_utils74.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -12476,7 +12736,7 @@ var prefer_nullish_filter_predicate_default = createRule({
       CallExpression(node) {
         const callee = node.callee;
         const callback = node.arguments[0];
-        if (node.arguments.length !== 1 || callback?.type !== import_utils71.AST_NODE_TYPES.Identifier || callback.name !== "Boolean" || callee.type !== import_utils71.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils71.AST_NODE_TYPES.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
+        if (node.arguments.length !== 1 || callback?.type !== import_utils74.AST_NODE_TYPES.Identifier || callback.name !== "Boolean" || callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
         const elementType = arrayElementType(callee.object, services);
         const checker = services.program.getTypeChecker();
         if (elementType === null || !isNullishPlusTruthy(elementType, checker)) return;
@@ -12498,7 +12758,7 @@ var prefer_nullish_filter_predicate_default = createRule({
 });
 
 // src/rules/prefer-await-in-async-return.ts
-var import_utils72 = require("@typescript-eslint/utils");
+var import_utils75 = require("@typescript-eslint/utils");
 var ts4 = __toESM(require("typescript"), 1);
 var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
   summary: "Prefer explicit `await` when an async function directly returns one typed Promise `.then` transform.",
@@ -12540,10 +12800,10 @@ var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
 };
 function directAsyncReturnOwner(node) {
   const parent = node.parent;
-  if (parent.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
+  if (parent.type === import_utils75.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node) {
     return parent.async && !parent.generator ? parent : null;
   }
-  if (parent.type !== import_utils72.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
+  if (parent.type !== import_utils75.AST_NODE_TYPES.ReturnStatement || parent.argument !== node) {
     return null;
   }
   let owner = parent.parent;
@@ -12553,15 +12813,15 @@ function directAsyncReturnOwner(node) {
   return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
-  return node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils72.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils75.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils75.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils75.AST_NODE_TYPES.FunctionExpression;
 }
 function promiseThenReceiver(node) {
   const callee = node.callee;
-  if (callee.type !== import_utils72.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils72.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
+  if (callee.type !== import_utils75.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils75.AST_NODE_TYPES.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
     return null;
   }
   const callback = node.arguments[0];
-  if (callback === void 0 || callback.type !== import_utils72.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils72.AST_NODE_TYPES.FunctionExpression) {
+  if (callback === void 0 || callback.type !== import_utils75.AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== import_utils75.AST_NODE_TYPES.FunctionExpression) {
     return null;
   }
   return callee.object;
@@ -12602,32 +12862,32 @@ var prefer_await_in_async_return_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils72.ESLintUtils.getParserServices(context);
+      services = import_utils75.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = import_utils75.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
-      if (parent.type !== import_utils72.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils72.AST_NODE_TYPES.Identifier) return false;
-      const variable = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      if (parent.type !== import_utils75.AST_NODE_TYPES.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== import_utils75.AST_NODE_TYPES.Identifier) return false;
+      const variable = import_utils75.ASTUtils.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
       return variable !== null && frameworkLoaders.has(variable);
     };
     return {
       ImportDeclaration(node) {
         if (node.source.value === "react") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils72.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils72.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils75.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils75.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
           }
         }
         if (node.source.value === "next/dynamic") {
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils72.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+            if (specifier.type === import_utils75.AST_NODE_TYPES.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
           }
         }
       },
@@ -12645,7 +12905,7 @@ var prefer_await_in_async_return_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils73 = require("@typescript-eslint/utils");
+var import_utils76 = require("@typescript-eslint/utils");
 var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
   summary: "Require Zod (or similar) schema validation on `response.json()` / `JSON.parse()` results before property access.",
   rationale: "External JSON is untrusted at runtime even when its expected TypeScript shape is known statically.",
@@ -12660,9 +12920,9 @@ var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
 var unwrap5 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils73.AST_NODE_TYPES.TSAsExpression || current.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils76.AST_NODE_TYPES.TSAsExpression || current.type === import_utils76.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils76.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils76.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils73.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils76.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -12677,23 +12937,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap5(node);
-  return inner !== null && inner.type === import_utils73.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils73.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === import_utils76.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils76.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node, isKnownLocalText) => {
   let current = unwrap5(node);
   if (current === null) return false;
-  if (current.type === import_utils73.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils76.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap5(current.argument);
   }
-  if (current === null || current.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils76.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap5(current.callee);
-  if (callee === null || callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils76.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap5(callee.property);
-  if (property === null || property.type !== import_utils73.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils76.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -12703,17 +12963,17 @@ var isRawPayloadSource = (node, isKnownLocalText) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap5(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils73.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
+  return property.name === "parse" && object !== null && object.type === import_utils76.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isDirectLocalFileRead = (node) => {
   let current = unwrap5(node);
-  if (current?.type === import_utils73.AST_NODE_TYPES.AwaitExpression) {
+  if (current?.type === import_utils76.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap5(current.argument);
   }
-  if (current?.type !== import_utils73.AST_NODE_TYPES.CallExpression) return false;
+  if (current?.type !== import_utils76.AST_NODE_TYPES.CallExpression) return false;
   const callee = unwrap5(current.callee);
-  const name = callee?.type === import_utils73.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils73.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils73.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+  const name = callee?.type === import_utils76.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils76.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils76.AST_NODE_TYPES.Identifier ? callee.property.name : null;
   return name !== null && FILE_READ_RE.test(name);
 };
 var isLocalFileRead = (node) => {
@@ -12740,15 +13000,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 !== import_utils73.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils76.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils73.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils76.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils73.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils76.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils73.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils76.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -12767,22 +13027,22 @@ 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 === import_utils73.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils73.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils73.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils73.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils73.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils76.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils76.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils76.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils76.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils76.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils73.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils76.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils73.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils76.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils76.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils76.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils76.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils73.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils76.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "bigint",
@@ -12793,13 +13053,13 @@ var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "undefined"
 ]);
 var bindingValidationPolarity = (test, bindingName) => {
-  if (test.type === import_utils73.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils76.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = bindingValidationPolarity(test.argument, bindingName);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils73.AST_NODE_TYPES.BinaryExpression) {
-    const typeofName = (node) => node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils73.AST_NODE_TYPES.Identifier ? node.argument.name : null;
-    const literalType = (node) => node.type === import_utils73.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+  if (test.type === import_utils76.AST_NODE_TYPES.BinaryExpression) {
+    const typeofName = (node) => node.type === import_utils76.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils76.AST_NODE_TYPES.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
     const matches = typeofName(test.left) === bindingName && literalType(test.right) !== null || typeofName(test.right) === bindingName && literalType(test.left) !== null;
     if (!matches) return null;
     if (test.operator === "===" || test.operator === "==") {
@@ -12807,9 +13067,9 @@ var bindingValidationPolarity = (test, bindingName) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils73.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils73.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils76.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils76.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils76.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils76.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils76.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
-var plainMemberAccess = (node) => node.type === import_utils73.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils73.AST_NODE_TYPES.Identifier && node.property.type === import_utils73.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
+var plainMemberAccess = (node) => node.type === import_utils76.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils76.AST_NODE_TYPES.Identifier && node.property.type === import_utils76.AST_NODE_TYPES.Identifier ? { object: node.object.name, property: node.property.name } : null;
 var isSamePlainMember = (node, access) => {
   const candidate2 = plainMemberAccess(node);
   return candidate2 !== null && candidate2.object === access.object && candidate2.property === access.property;
@@ -12817,19 +13077,19 @@ var isSamePlainMember = (node, access) => {
 var nodeWithin2 = (node, container) => node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
 var isUseWithinValidatedBranch = (node, bindingName) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils76.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils76.AST_NODE_TYPES.IfStatement) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils76.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils76.AST_NODE_TYPES.FunctionExpression || current.type === import_utils76.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
@@ -12837,32 +13097,32 @@ var isUseWithinValidatedBranch = (node, bindingName) => {
 };
 var isMemberUseWithinValidatedBranch = (node, access) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
+    if (current.type === import_utils76.AST_NODE_TYPES.ConditionalExpression) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
+    if (current.type === import_utils76.AST_NODE_TYPES.IfStatement) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
+    if (current.type === import_utils76.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils76.AST_NODE_TYPES.FunctionExpression || current.type === import_utils76.AST_NODE_TYPES.ArrowFunctionExpression) {
       return false;
     }
   }
   return false;
 };
 var memberValidationPolarity = (test, access) => {
-  if (test.type === import_utils73.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+  if (test.type === import_utils76.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
     const inner = memberValidationPolarity(test.argument, access);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === import_utils73.AST_NODE_TYPES.BinaryExpression) {
-    const isMatchingTypeof = (node) => node.type === import_utils73.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === import_utils73.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+  if (test.type === import_utils76.AST_NODE_TYPES.BinaryExpression) {
+    const isMatchingTypeof = (node) => node.type === import_utils76.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
+    const isPrimitiveType = (node) => node.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
     if (!(isMatchingTypeof(test.left) && isPrimitiveType(test.right) || isMatchingTypeof(test.right) && isPrimitiveType(test.left))) {
       return null;
     }
@@ -12871,15 +13131,15 @@ var memberValidationPolarity = (test, access) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === import_utils73.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils73.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils73.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils73.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === import_utils76.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== import_utils76.AST_NODE_TYPES.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === import_utils76.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils76.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils76.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
 var isFullyValidatedExtractedBinding = (member, source, context) => {
   const isValidationReference = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if ((current.type === import_utils73.AST_NODE_TYPES.BinaryExpression || current.type === import_utils73.AST_NODE_TYPES.CallExpression || current.type === import_utils73.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+      if ((current.type === import_utils76.AST_NODE_TYPES.BinaryExpression || current.type === import_utils76.AST_NODE_TYPES.CallExpression || current.type === import_utils76.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
         return true;
       }
-      if (current.type !== import_utils73.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils73.AST_NODE_TYPES.MemberExpression && current.type !== import_utils73.AST_NODE_TYPES.CallExpression) {
+      if (current.type !== import_utils76.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils76.AST_NODE_TYPES.MemberExpression && current.type !== import_utils76.AST_NODE_TYPES.CallExpression) {
         return false;
       }
     }
@@ -12887,7 +13147,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   };
   const isGuardedUse = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if (current.type === import_utils73.AST_NODE_TYPES.ConditionalExpression) {
+      if (current.type === import_utils76.AST_NODE_TYPES.ConditionalExpression) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12896,7 +13156,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils73.AST_NODE_TYPES.IfStatement) {
+      if (current.type === import_utils76.AST_NODE_TYPES.IfStatement) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -12905,14 +13165,14 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === import_utils73.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils73.AST_NODE_TYPES.FunctionExpression || current.type === import_utils73.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (current.type === import_utils76.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils76.AST_NODE_TYPES.FunctionExpression || current.type === import_utils76.AST_NODE_TYPES.ArrowFunctionExpression) {
         return false;
       }
     }
     return false;
   };
   const declarator = member.parent;
-  if (declarator.type !== import_utils73.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils73.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils73.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
+  if (declarator.type !== import_utils76.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils76.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils76.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
     return false;
   }
   const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
@@ -12920,7 +13180,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   let hasValueUse = false;
   for (const reference of extracted.references) {
     const identifier = reference.identifier;
-    if (identifier.type !== import_utils73.AST_NODE_TYPES.Identifier) return false;
+    if (identifier.type !== import_utils76.AST_NODE_TYPES.Identifier) return false;
     if (nodeWithin2(identifier, declarator)) continue;
     if (isValidationReference(identifier)) continue;
     hasValueUse = true;
@@ -12933,17 +13193,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils73.AST_NODE_TYPES.UnaryExpression:
-      case import_utils73.AST_NODE_TYPES.LogicalExpression:
-      case import_utils73.AST_NODE_TYPES.ChainExpression:
+      case import_utils76.AST_NODE_TYPES.UnaryExpression:
+      case import_utils76.AST_NODE_TYPES.LogicalExpression:
+      case import_utils76.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils73.AST_NODE_TYPES.IfStatement:
-      case import_utils73.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils73.AST_NODE_TYPES.WhileStatement:
-      case import_utils73.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils73.AST_NODE_TYPES.ForStatement:
+      case import_utils76.AST_NODE_TYPES.IfStatement:
+      case import_utils76.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils76.AST_NODE_TYPES.WhileStatement:
+      case import_utils76.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils76.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -12953,7 +13213,7 @@ var isGuardTestPosition = (node) => {
 };
 var unvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap5(node);
-  if (unwrapped === null || unwrapped.type !== import_utils73.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils76.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -12982,7 +13242,7 @@ var prefer_schema_for_api_payload_default = createRule({
     const localFileTextVariables = /* @__PURE__ */ new Set();
     const localFileTextRef = (node, scope) => {
       const unwrapped = unwrap5(node);
-      if (unwrapped?.type !== import_utils73.AST_NODE_TYPES.Identifier) return null;
+      if (unwrapped?.type !== import_utils76.AST_NODE_TYPES.Identifier) return null;
       const variable = findVariable2(scope, unwrapped.name);
       return variable !== null && localFileTextVariables.has(variable) ? variable : null;
     };
@@ -13051,7 +13311,7 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils73.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils76.AST_NODE_TYPES.Identifier) {
           const variable = context.sourceCode.getDeclaredVariables(node)[0];
           if (variable !== void 0) {
             updateLocalFileText(variable, node.init, scope);
@@ -13059,7 +13319,7 @@ var prefer_schema_for_api_payload_default = createRule({
           trackInitializer(node, scope);
           return;
         }
-        if (node.id.type === import_utils73.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils73.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils76.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils76.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.init,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -13076,7 +13336,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils73.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils76.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           const isLocalText = (candidate2) => localFileTextRef(candidate2, scope) !== null;
@@ -13090,7 +13350,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils73.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils73.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils76.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils76.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(
             node.right,
             (candidate2) => localFileTextRef(candidate2, scope) !== null
@@ -13110,15 +13370,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils73.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils76.AST_NODE_TYPES.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 === import_utils73.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils76.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap5(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils73.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils76.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -13135,14 +13395,14 @@ var prefer_schema_for_api_payload_default = createRule({
           (candidate2) => localFileTextRef(candidate2, scope) !== null
         )) {
           const parent = node.parent;
-          if (parent.type === import_utils73.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils73.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils76.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils76.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        const variable = obj?.type === import_utils73.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
-        if (variable !== null && obj?.type === import_utils73.AST_NODE_TYPES.Identifier) {
+        const variable = obj?.type === import_utils76.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null && obj?.type === import_utils76.AST_NODE_TYPES.Identifier) {
           if (isUseWithinValidatedBranch(node, obj.name)) {
             return;
           }
@@ -13162,7 +13422,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-shared-zod-enum.ts
-var import_utils74 = require("@typescript-eslint/utils");
+var import_utils77 = require("@typescript-eslint/utils");
 var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
   summary: "Give literal Zod enum domains one reusable module-level schema.",
   rationale: "Inline or repeated literal domains hide a reusable contract and allow equivalent fields to drift independently.",
@@ -13176,24 +13436,24 @@ var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
 };
 function literalDomain(node) {
   const [argument] = node.arguments;
-  if (argument?.type !== import_utils74.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2) return null;
+  if (argument?.type !== import_utils77.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2) return null;
   const values = [];
   for (const element of argument.elements) {
-    if (element?.type !== import_utils74.AST_NODE_TYPES.Literal || typeof element.value !== "string") return null;
+    if (element?.type !== import_utils77.AST_NODE_TYPES.Literal || typeof element.value !== "string") return null;
     values.push(element.value);
   }
   return values;
 }
 function isModuleLevelNamedSchema(node) {
   let current = node;
-  while (current.parent?.type === import_utils74.AST_NODE_TYPES.MemberExpression && current.parent.object === current) {
+  while (current.parent?.type === import_utils77.AST_NODE_TYPES.MemberExpression && current.parent.object === current) {
     current = current.parent;
-    if (current.parent?.type === import_utils74.AST_NODE_TYPES.CallExpression && current.parent.callee === current) current = current.parent;
+    if (current.parent?.type === import_utils77.AST_NODE_TYPES.CallExpression && current.parent.callee === current) current = current.parent;
   }
   const declarator = current.parent;
-  if (declarator?.type !== import_utils74.AST_NODE_TYPES.VariableDeclarator || declarator.init !== current || declarator.id.type !== import_utils74.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils74.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declarator?.type !== import_utils77.AST_NODE_TYPES.VariableDeclarator || declarator.init !== current || declarator.id.type !== import_utils77.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils77.AST_NODE_TYPES.VariableDeclaration) return false;
   const declarationParent = declarator.parent.parent;
-  return declarationParent.type === import_utils74.AST_NODE_TYPES.Program || declarationParent.type === import_utils74.AST_NODE_TYPES.ExportNamedDeclaration && declarationParent.parent.type === import_utils74.AST_NODE_TYPES.Program;
+  return declarationParent.type === import_utils77.AST_NODE_TYPES.Program || declarationParent.type === import_utils77.AST_NODE_TYPES.ExportNamedDeclaration && declarationParent.parent.type === import_utils77.AST_NODE_TYPES.Program;
 }
 var prefer_shared_zod_enum_default = createRule({
   name: "prefer-shared-zod-enum",
@@ -13215,11 +13475,11 @@ var prefer_shared_zod_enum_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils74.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils74.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils74.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") zodBindings.add(specifier.local.name);
+          if (specifier.type === import_utils77.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils77.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils77.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils77.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") zodBindings.add(specifier.local.name);
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils74.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils74.AST_NODE_TYPES.Identifier || !zodBindings.has(node.callee.object.name) || node.callee.property.type !== import_utils74.AST_NODE_TYPES.Identifier || node.callee.property.name !== "enum") return;
+        if (node.callee.type !== import_utils77.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils77.AST_NODE_TYPES.Identifier || !zodBindings.has(node.callee.object.name) || node.callee.property.type !== import_utils77.AST_NODE_TYPES.Identifier || node.callee.property.name !== "enum") return;
         const domain = literalDomain(node);
         if (domain === null) return;
         const key = JSON.stringify(domain);
@@ -13233,7 +13493,7 @@ var prefer_shared_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-switch-for-repeated-equality.ts
-var import_utils75 = require("@typescript-eslint/utils");
+var import_utils78 = require("@typescript-eslint/utils");
 var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   summary: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
   rationale: "A switch makes finite dispatch cases visually uniform and easier to extend without duplicating the discriminant.",
@@ -13250,17 +13510,17 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   ]
 };
 function discriminantText(sourceCode, test) {
-  if (test.type !== import_utils75.AST_NODE_TYPES.BinaryExpression || test.operator !== "===") return null;
+  if (test.type !== import_utils78.AST_NODE_TYPES.BinaryExpression || test.operator !== "===") return null;
   const leftIsCase = isCaseValue(test.left);
   const rightIsCase = isCaseValue(test.right);
   if (leftIsCase === rightIsCase) return null;
   return sourceCode.getText(leftIsCase ? test.right : test.left);
 }
 function isCaseValue(node) {
-  if (node.type === import_utils75.AST_NODE_TYPES.Literal) return true;
-  if (node.type === import_utils75.AST_NODE_TYPES.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
-  if (node.type !== import_utils75.AST_NODE_TYPES.MemberExpression || node.computed) return false;
-  return node.property.type === import_utils75.AST_NODE_TYPES.Identifier && (node.object.type === import_utils75.AST_NODE_TYPES.Identifier || isCaseValue(node.object));
+  if (node.type === import_utils78.AST_NODE_TYPES.Literal) return true;
+  if (node.type === import_utils78.AST_NODE_TYPES.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
+  if (node.type !== import_utils78.AST_NODE_TYPES.MemberExpression || node.computed) return false;
+  return node.property.type === import_utils78.AST_NODE_TYPES.Identifier && (node.object.type === import_utils78.AST_NODE_TYPES.Identifier || isCaseValue(node.object));
 }
 var prefer_switch_for_repeated_equality_default = createRule({
   name: "prefer-switch-for-repeated-equality",
@@ -13277,12 +13537,12 @@ var prefer_switch_for_repeated_equality_default = createRule({
   create(context) {
     return {
       IfStatement(node) {
-        if (node.parent.type === import_utils75.AST_NODE_TYPES.IfStatement && node.parent.alternate === node) return;
+        if (node.parent.type === import_utils78.AST_NODE_TYPES.IfStatement && node.parent.alternate === node) return;
         const first = discriminantText(context.sourceCode, node.test);
         if (first === null) return;
         let count = 1;
         let current = node.alternate;
-        while (current?.type === import_utils75.AST_NODE_TYPES.IfStatement) {
+        while (current?.type === import_utils78.AST_NODE_TYPES.IfStatement) {
           if (discriminantText(context.sourceCode, current.test) !== first) return;
           count += 1;
           current = current.alternate;
@@ -13296,7 +13556,7 @@ var prefer_switch_for_repeated_equality_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils76 = require("@typescript-eslint/utils");
+var import_utils79 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -13408,7 +13668,7 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils76.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils79.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -13418,8 +13678,8 @@ var isInsideSvg = (node) => {
 };
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils76.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils76.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils76.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils79.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils79.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils79.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -13445,7 +13705,7 @@ function isSvgLikeElementName(name) {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils76.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils76.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils76.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils76.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils79.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils79.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils79.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils79.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -13579,12 +13839,12 @@ var expandWorkspaceGlob = (root, glob) => {
   return (0, import_fs.readdirSync)(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => (0, import_path.join)(parent, entry.name));
 };
 var propName = (key) => {
-  if (key.type === import_utils76.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils76.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils79.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils79.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== import_utils76.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils76.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils76.AST_NODE_TYPES.ExportAllDeclaration) {
+  if (statement.type !== import_utils79.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils79.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils79.AST_NODE_TYPES.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -13637,27 +13897,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils76.AST_NODE_TYPES.Literal:
+        case import_utils79.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils76.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils79.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils76.AST_NODE_TYPES.ArrayExpression:
+        case import_utils79.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils76.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils79.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils76.AST_NODE_TYPES.ObjectExpression:
+        case import_utils79.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils76.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils79.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils76.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils79.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils76.AST_NODE_TYPES.LogicalExpression:
+        case import_utils79.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -13665,32 +13925,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === import_utils79.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         report2(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils76.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils76.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils76.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils79.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils79.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils79.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils76.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === import_utils79.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils79.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === import_utils76.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils79.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils76.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils79.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils76.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils79.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -13700,9 +13960,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 !== import_utils76.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils79.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils76.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils79.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -13716,7 +13976,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils76.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === import_utils79.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -13729,7 +13989,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils77 = require("@typescript-eslint/utils");
+var import_utils80 = require("@typescript-eslint/utils");
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
   summary: "Prefer Next.js Server Actions over /api/* mutations.",
   rationale: "Server Actions preserve typed application calls and avoid an internal JSON request-response boundary.",
@@ -13918,7 +14178,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils78 = require("@typescript-eslint/utils");
+var import_utils81 = require("@typescript-eslint/utils");
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
@@ -13943,11 +14203,11 @@ var PREFER_WHOLE_OBJECT_ASSERTION_DOCUMENTATION = {
 };
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils78.AST_NODE_TYPES.Literal:
+    case import_utils81.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils78.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils81.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils78.AST_NODE_TYPES.UnaryExpression:
+    case import_utils81.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -13955,15 +14215,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils78.AST_NODE_TYPES.Identifier:
-    case import_utils78.AST_NODE_TYPES.ThisExpression:
+    case import_utils81.AST_NODE_TYPES.Identifier:
+    case import_utils81.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils78.AST_NODE_TYPES.MemberExpression:
+    case import_utils81.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils78.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils81.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -13971,7 +14231,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils78.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils81.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -13979,8 +14239,8 @@ function literalIndex(node) {
 function propertyAccess(node) {
   const path = [];
   let current = node;
-  while (current.type === import_utils78.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
-    if (current.property.type !== import_utils78.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+  while (current.type === import_utils81.AST_NODE_TYPES.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== import_utils81.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
     path.unshift(current.property.name);
     current = current.object;
   }
@@ -14008,24 +14268,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils78.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils81.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils78.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils81.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils78.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils78.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils81.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils81.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils78.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils78.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils81.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils81.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== import_utils78.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils81.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -14054,7 +14314,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 === import_utils78.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils81.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -14195,7 +14455,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-var import_utils79 = require("@typescript-eslint/utils");
+var import_utils82 = require("@typescript-eslint/utils");
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -14216,67 +14476,67 @@ var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
 function staticMemberName5(node) {
-  if (!node.computed && node.property.type === import_utils79.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils79.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils82.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function importedName6(identifier, context, modules) {
-  const variable = import_utils79.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = import_utils82.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
-    if (definition.node.type !== import_utils79.AST_NODE_TYPES.ImportSpecifier) continue;
+    if (definition.node.type !== import_utils82.AST_NODE_TYPES.ImportSpecifier) continue;
     const declaration = definition.node.parent;
-    if (declaration.type !== import_utils79.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
+    if (declaration.type !== import_utils82.AST_NODE_TYPES.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     const imported = definition.node.imported;
-    return imported.type === import_utils79.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
+    return imported.type === import_utils82.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
   }
   return null;
 }
 function isDirectTestCallback2(node, context) {
-  if (node.type !== import_utils79.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils79.AST_NODE_TYPES.FunctionExpression) return false;
+  if (node.type !== import_utils82.AST_NODE_TYPES.ArrowFunctionExpression && node.type !== import_utils82.AST_NODE_TYPES.FunctionExpression) return false;
   const call = node.parent;
-  if (call?.type !== import_utils79.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
+  if (call?.type !== import_utils82.AST_NODE_TYPES.CallExpression || !call.arguments.includes(node)) return false;
   const root = testRoot2(call.callee);
   return root !== null && TEST_NAMES2.has(importedName6(root, context, TEST_MODULES4) ?? "");
 }
 function testRoot2(callee) {
-  if (callee.type === import_utils79.AST_NODE_TYPES.Identifier) return callee;
-  if (callee.type !== import_utils79.AST_NODE_TYPES.MemberExpression) return null;
+  if (callee.type === import_utils82.AST_NODE_TYPES.Identifier) return callee;
+  if (callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression) return null;
   const modifier = staticMemberName5(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
-  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
+  if (node.type === import_utils82.AST_NODE_TYPES.TSAsExpression || node.type === import_utils82.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils82.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils82.AST_NODE_TYPES.TSNonNullExpression) return isStatic(node.expression);
   switch (node.type) {
-    case import_utils79.AST_NODE_TYPES.Literal:
+    case import_utils82.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils79.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils82.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils79.AST_NODE_TYPES.UnaryExpression:
+    case import_utils82.AST_NODE_TYPES.UnaryExpression:
       return (node.operator === "+" || node.operator === "-") && isStatic(node.argument);
-    case import_utils79.AST_NODE_TYPES.ArrayExpression:
-      return node.elements.every((item) => item !== null && item.type !== import_utils79.AST_NODE_TYPES.SpreadElement && isStatic(item));
-    case import_utils79.AST_NODE_TYPES.ObjectExpression:
-      return node.properties.every((property) => property.type === import_utils79.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils79.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
+    case import_utils82.AST_NODE_TYPES.ArrayExpression:
+      return node.elements.every((item) => item !== null && item.type !== import_utils82.AST_NODE_TYPES.SpreadElement && isStatic(item));
+    case import_utils82.AST_NODE_TYPES.ObjectExpression:
+      return node.properties.every((property) => property.type === import_utils82.AST_NODE_TYPES.Property && !property.computed && property.kind === "init" && property.value.type !== import_utils82.AST_NODE_TYPES.AssignmentPattern && isStatic(property.value));
     default:
       return false;
   }
 }
 function staticShape(node) {
-  if (node.type === import_utils79.AST_NODE_TYPES.TSAsExpression || node.type === import_utils79.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils79.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils79.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
+  if (node.type === import_utils82.AST_NODE_TYPES.TSAsExpression || node.type === import_utils82.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils82.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils82.AST_NODE_TYPES.TSNonNullExpression) return staticShape(node.expression);
   switch (node.type) {
-    case import_utils79.AST_NODE_TYPES.Literal:
+    case import_utils82.AST_NODE_TYPES.Literal:
       return `literal:${typeof node.value}`;
-    case import_utils79.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils82.AST_NODE_TYPES.TemplateLiteral:
       return "template";
-    case import_utils79.AST_NODE_TYPES.UnaryExpression:
+    case import_utils82.AST_NODE_TYPES.UnaryExpression:
       return `unary:${node.operator}:${staticShape(node.argument)}`;
-    case import_utils79.AST_NODE_TYPES.ArrayExpression:
-      return `array(${node.elements.map((item) => item === null || item.type === import_utils79.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
-    case import_utils79.AST_NODE_TYPES.ObjectExpression:
+    case import_utils82.AST_NODE_TYPES.ArrayExpression:
+      return `array(${node.elements.map((item) => item === null || item.type === import_utils82.AST_NODE_TYPES.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
+    case import_utils82.AST_NODE_TYPES.ObjectExpression:
       return `object(${node.properties.map((property) => {
-        if (property.type !== import_utils79.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils79.AST_NODE_TYPES.AssignmentPattern) return "invalid";
-        const key = property.key.type === import_utils79.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
+        if (property.type !== import_utils82.AST_NODE_TYPES.Property || property.computed || property.value.type === import_utils82.AST_NODE_TYPES.AssignmentPattern) return "invalid";
+        const key = property.key.type === import_utils82.AST_NODE_TYPES.Identifier ? property.key.name : String(property.key.value);
         return `${key}:${staticShape(property.value)}`;
       }).join(",")})`;
     default:
@@ -14284,16 +14544,16 @@ function staticShape(node) {
   }
 }
 function assertionShape(statement, context) {
-  if (statement.type !== import_utils79.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils79.AST_NODE_TYPES.CallExpression) return null;
+  if (statement.type !== import_utils82.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils82.AST_NODE_TYPES.CallExpression) return null;
   const matcherCall = statement.expression;
-  if (matcherCall.callee.type !== import_utils79.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils79.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
+  if (matcherCall.callee.type !== import_utils82.AST_NODE_TYPES.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== import_utils82.AST_NODE_TYPES.Identifier || matcherCall.arguments.length !== 1) return null;
   const matcher = matcherCall.callee.property.name;
   if (SNAPSHOT_MATCHERS.test(matcher)) return null;
   const chain = expectCallFromMatcher(matcherCall.callee);
-  if (chain === null || chain.call.callee.type !== import_utils79.AST_NODE_TYPES.Identifier || importedName6(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
+  if (chain === null || chain.call.callee.type !== import_utils82.AST_NODE_TYPES.Identifier || importedName6(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
   const observed = chain.call.arguments[0];
   const expected = matcherCall.arguments[0];
-  if (observed?.type !== import_utils79.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils79.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils79.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils79.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
+  if (observed?.type !== import_utils82.AST_NODE_TYPES.CallExpression || observed.callee.type !== import_utils82.AST_NODE_TYPES.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === import_utils82.AST_NODE_TYPES.SpreadElement || !isStatic(arg)) || expected?.type === import_utils82.AST_NODE_TYPES.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
   const skeleton = `${observed.callee.name}/${observed.arguments.map((item) => staticShape(item)).join(",")}/${chain.modifiers.join(".")}/${matcher}/${staticShape(expected)}`;
   const values = [...observed.arguments, expected].map((item) => context.sourceCode.getText(item)).join("\0");
   return { statement, skeleton, values };
@@ -14301,13 +14561,13 @@ function assertionShape(statement, context) {
 function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
-  while (receiver.type === import_utils79.AST_NODE_TYPES.MemberExpression) {
+  while (receiver.type === import_utils82.AST_NODE_TYPES.MemberExpression) {
     const modifier = staticMemberName5(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
   }
-  return receiver.type === import_utils79.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
+  return receiver.type === import_utils82.AST_NODE_TYPES.CallExpression ? { call: receiver, modifiers } : null;
 }
 var repeated_static_call_cases_default = createRule({
   name: "repeated-static-call-cases",
@@ -14327,7 +14587,7 @@ var repeated_static_call_cases_default = createRule({
     return {
       "CallExpression > ArrowFunctionExpression, CallExpression > FunctionExpression"(node) {
         const call = node.parent;
-        if (call?.type === import_utils79.AST_NODE_TYPES.CallExpression) {
+        if (call?.type === import_utils82.AST_NODE_TYPES.CallExpression) {
           const duplicate = duplicateTestBodyCandidate(call, sourceCode);
           if (duplicate !== null && duplicate.body === node) {
             const groups = duplicateGroups.get(duplicate.container) ?? /* @__PURE__ */ new Map();
@@ -14337,7 +14597,7 @@ var repeated_static_call_cases_default = createRule({
             duplicateGroups.set(duplicate.container, groups);
           }
         }
-        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils79.AST_NODE_TYPES.BlockStatement) return;
+        if (!isDirectTestCallback2(node, context) || node.body.type !== import_utils82.AST_NODE_TYPES.BlockStatement) return;
         let run = [];
         const flush = () => {
           if (run.length >= MIN_CASES2 && new Set(run.map((item) => item.values)).size > 1) {
@@ -14378,7 +14638,7 @@ var repeated_static_call_cases_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils80 = require("@typescript-eslint/utils");
+var import_utils83 = require("@typescript-eslint/utils");
 var PREFER_ZOD_INFER_DOCUMENTATION = {
   summary: "Derive a type from its Zod schema with `z.infer` instead of hand-writing a twin declaration beside it.",
   rationale: "A derived type stays synchronized when the runtime schema changes.",
@@ -14431,47 +14691,47 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils80.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils80.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils80.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils80.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils80.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils80.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils80.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils80.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils80.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils80.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils80.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils80.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils80.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils80.AST_NODE_TYPES.TSArrayType, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils80.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils80.AST_NODE_TYPES.TSTypeLiteral, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils80.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils80.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils80.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference, import_utils80.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils80.AST_NODE_TYPES.TSUnionType, import_utils80.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils80.AST_NODE_TYPES.TSIntersectionType, import_utils80.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils83.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils83.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils83.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils83.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils83.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils83.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils83.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils83.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils83.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils83.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils83.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils83.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils83.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils83.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils83.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils83.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils83.AST_NODE_TYPES.TSArrayType, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils83.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils83.AST_NODE_TYPES.TSTypeLiteral, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils83.AST_NODE_TYPES.TSTypeLiteral, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils83.AST_NODE_TYPES.TSTypeLiteral, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils83.AST_NODE_TYPES.TSTypeReference, import_utils83.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils83.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils83.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils83.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils83.AST_NODE_TYPES.TSUnionType, import_utils83.AST_NODE_TYPES.TSTypeReference, import_utils83.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils83.AST_NODE_TYPES.TSUnionType, import_utils83.AST_NODE_TYPES.TSTypeReference, import_utils83.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils83.AST_NODE_TYPES.TSUnionType, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils83.AST_NODE_TYPES.TSUnionType, import_utils83.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils83.AST_NODE_TYPES.TSIntersectionType, import_utils83.AST_NODE_TYPES.TSTypeReference]
 };
 function primitiveLiteralKey(node) {
-  if (node.type !== import_utils80.AST_NODE_TYPES.Literal) {
+  if (node.type !== import_utils83.AST_NODE_TYPES.Literal) {
     return null;
   }
   if (node.value === null) {
@@ -14503,13 +14763,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "literal") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils83.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils80.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils83.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map(
-          (element) => element === null || element.type === import_utils80.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
+          (element) => element === null || element.type === import_utils83.AST_NODE_TYPES.SpreadElement ? null : primitiveLiteralKey(element)
         )
       );
     }
@@ -14517,13 +14777,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "enum") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
+    if (argument === void 0 || argument.type === import_utils83.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
-    if (argument.type === import_utils80.AST_NODE_TYPES.ArrayExpression) {
+    if (argument.type === import_utils83.AST_NODE_TYPES.ArrayExpression) {
       return exactDomain(
         argument.elements.map((element) => {
-          if (element === null || element.type === import_utils80.AST_NODE_TYPES.SpreadElement) {
+          if (element === null || element.type === import_utils83.AST_NODE_TYPES.SpreadElement) {
             return null;
           }
           const key = primitiveLiteralKey(element);
@@ -14531,10 +14791,10 @@ function staticZodDomain(leaf, call) {
         })
       );
     }
-    if (argument.type === import_utils80.AST_NODE_TYPES.ObjectExpression) {
+    if (argument.type === import_utils83.AST_NODE_TYPES.ObjectExpression) {
       return exactDomain(
         argument.properties.map((property) => {
-          if (property.type !== import_utils80.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
+          if (property.type !== import_utils83.AST_NODE_TYPES.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
             return null;
           }
           const key = primitiveLiteralKey(property.value);
@@ -14561,15 +14821,15 @@ function sameDomain(left, right) {
   return true;
 }
 function isExportedDeclaration(node) {
-  return node.parent?.type === import_utils80.AST_NODE_TYPES.ExportNamedDeclaration;
+  return node.parent?.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration;
 }
 function isModuleLevelConst(node) {
   const declaration = node.parent;
-  if (declaration.type !== import_utils80.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== import_utils83.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === import_utils80.AST_NODE_TYPES.Program || container.type === import_utils80.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils80.AST_NODE_TYPES.Program;
+  return container.type === import_utils83.AST_NODE_TYPES.Program || container.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils83.AST_NODE_TYPES.Program;
 }
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -14578,20 +14838,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils83.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils80.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils83.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils80.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils83.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils80.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils83.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -14625,18 +14885,18 @@ function leafAgrees(field, annotation) {
     return null;
   }
   if (leaf === "date") {
-    return core.type === import_utils80.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils80.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
+    return core.type === import_utils83.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils83.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
   }
   return expected.includes(core.type);
 }
 function typeLiteralDomain(annotation) {
-  const members = annotation.type === import_utils80.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
+  const members = annotation.type === import_utils83.AST_NODE_TYPES.TSUnionType ? annotation.types : [annotation];
   const keys = [];
   for (const member of members) {
-    if (member.type === import_utils80.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils83.AST_NODE_TYPES.TSNullKeyword) {
       continue;
     }
-    if (member.type !== import_utils80.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils83.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     keys.push(primitiveLiteralKey(member.literal));
@@ -14644,11 +14904,11 @@ function typeLiteralDomain(annotation) {
   return exactDomain(keys);
 }
 function staticStringUnionDomain(node) {
-  if (node.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils83.AST_NODE_TYPES.TSUnionType) {
     return null;
   }
   const keys = node.types.map((member) => {
-    if (member.type !== import_utils80.AST_NODE_TYPES.TSLiteralType) {
+    if (member.type !== import_utils83.AST_NODE_TYPES.TSLiteralType) {
       return null;
     }
     const key = primitiveLiteralKey(member.literal);
@@ -14716,14 +14976,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils80.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils83.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils80.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils80.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils83.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils83.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils80.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils83.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -14732,14 +14992,14 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName2(call) {
       const callee = call.callee;
-      return callee.type === import_utils80.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils80.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils83.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils83.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
       }
       for (const specifier of node.specifiers) {
-        if (specifier.type === import_utils80.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils80.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils80.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils80.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+        if (specifier.type === import_utils83.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils83.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils83.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils83.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
           zodNamespaces.add(specifier.local.name);
         }
       }
@@ -14749,13 +15009,13 @@ var prefer_zod_infer_default = createRule({
       let current = node;
       let leaf = null;
       let leafCall = null;
-      while (current.type === import_utils80.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils83.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils80.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils80.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils83.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils83.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils80.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils83.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           leafCall = current;
           break;
@@ -14786,20 +15046,20 @@ var prefer_zod_infer_default = createRule({
       return domain instanceof Set && domain.size >= 2 ? domain : null;
     }
     function inferredSchemaName(node) {
-      if (node.type !== import_utils80.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils80.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils80.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
+      if (node.type !== import_utils83.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils83.AST_NODE_TYPES.TSQualifiedName || node.typeName.left.type !== import_utils83.AST_NODE_TYPES.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
         return null;
       }
       const arguments_ = node.typeArguments?.params ?? [];
       const [argument] = arguments_;
-      return arguments_.length === 1 && argument?.type === import_utils80.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils80.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
+      return arguments_.length === 1 && argument?.type === import_utils83.AST_NODE_TYPES.TSTypeQuery && argument.exprName.type === import_utils83.AST_NODE_TYPES.Identifier ? argument.exprName.name : null;
     }
     function recordLiteralUnions(members, owner, ownerName, exported) {
       for (const member of members) {
-        if (member.type !== import_utils80.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
+        if (member.type !== import_utils83.AST_NODE_TYPES.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
           continue;
         }
         const key = member.key;
-        const propertyName7 = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const propertyName7 = key.type === import_utils83.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils83.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (propertyName7 === null) {
           continue;
         }
@@ -14809,7 +15069,7 @@ var prefer_zod_infer_default = createRule({
         }
         const annotation = member.typeAnnotation.typeAnnotation;
         const domain = staticStringUnionDomain(annotation);
-        if (domain === null || annotation.type !== import_utils80.AST_NODE_TYPES.TSUnionType) {
+        if (domain === null || annotation.type !== import_utils83.AST_NODE_TYPES.TSUnionType) {
           continue;
         }
         literalUnionOccurrences.push({
@@ -14840,16 +15100,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils80.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils83.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils80.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils83.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils83.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils83.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14860,11 +15120,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils80.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils83.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils80.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils80.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils83.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils83.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -14879,8 +15139,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils80.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils80.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils83.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils83.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -14888,11 +15148,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils80.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils83.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils80.AST_NODE_TYPES.TSUnionType || node.type === import_utils80.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils83.AST_NODE_TYPES.TSUnionType || node.type === import_utils83.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -14936,7 +15196,7 @@ var prefer_zod_infer_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          if (statement.type === import_utils80.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type === import_utils83.AST_NODE_TYPES.ImportDeclaration) {
             recordZodImport(statement);
           }
         }
@@ -14945,7 +15205,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils80.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils83.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -14962,14 +15222,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils80.AST_NODE_TYPES.Identifier && node.property.type === import_utils80.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils83.AST_NODE_TYPES.Identifier && node.property.type === import_utils83.AST_NODE_TYPES.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 === import_utils80.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils80.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils80.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils83.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils83.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils83.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -15001,7 +15261,7 @@ var prefer_zod_infer_default = createRule({
             typeName: node.id.name
           });
         }
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils80.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils83.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -15100,7 +15360,7 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils81 = require("@typescript-eslint/utils");
+var import_utils84 = require("@typescript-eslint/utils");
 var import_typescript2 = __toESM(require("typescript"), 1);
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   summary: "Require an empty switch default to call `assertNever` so discriminated unions remain exhaustive at compile time.",
@@ -15113,14 +15373,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils81.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils81.AST_NODE_TYPES.BreakStatement) {
+  if (statement.type === import_utils84.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils84.AST_NODE_TYPES.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === import_utils81.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils81.AST_NODE_TYPES.TSInterfaceDeclaration) {
+  if (statement.type === import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === import_utils81.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils84.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -15136,7 +15396,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 === import_utils81.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils84.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -15192,7 +15452,7 @@ var require_assert_never_default = createRule({
   create(context) {
     let services;
     try {
-      services = import_utils81.ESLintUtils.getParserServices(context);
+      services = import_utils84.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -15219,7 +15479,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils82 = require("@typescript-eslint/utils");
+var import_utils85 = require("@typescript-eslint/utils");
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -15245,14 +15505,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils82.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils85.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils82.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils85.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils82.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils82.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils85.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils85.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -15262,7 +15522,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === import_utils82.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils82.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils82.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils82.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils85.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils85.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils85.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils85.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -15300,30 +15560,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils82.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils85.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils82.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils85.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils82.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils82.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils82.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils85.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils85.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils85.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = import_utils82.ASTUtils.findVariable(
+      const variable = import_utils85.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
       if (variable?.defs.length !== 1) return false;
       const definition = variable.defs[0];
-      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils82.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== import_utils85.AST_NODE_TYPES.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
         return false;
       }
       for (const reference of variable.references) {
         const ref = reference.identifier;
         if (ref === identifier || ref === definition.name) continue;
         const member = ref.parent;
-        if (member.type !== import_utils82.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils82.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils82.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== import_utils85.AST_NODE_TYPES.MemberExpression || member.object !== ref || member.computed || member.property.type !== import_utils85.AST_NODE_TYPES.Identifier || member.property.name === "signal" || member.parent.type !== import_utils85.AST_NODE_TYPES.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -15338,7 +15598,7 @@ var require_fetch_timeout_default = createRule({
         if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils82.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === import_utils85.AST_NODE_TYPES.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -15347,7 +15607,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-var import_utils83 = require("@typescript-eslint/utils");
+var import_utils86 = require("@typescript-eslint/utils");
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
   summary: "Require exported concrete classes with public behavior to declare a contract.",
   rationale: "Consumers coupled only to a concrete class cannot substitute implementations or state the supported public capability independently of implementation details.",
@@ -15391,23 +15651,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === import_utils83.AST_NODE_TYPES.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils83.AST_NODE_TYPES.PrivateIdentifier;
+    if (member.type === import_utils86.AST_NODE_TYPES.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== import_utils86.AST_NODE_TYPES.PrivateIdentifier;
     }
-    if (member.type !== import_utils83.AST_NODE_TYPES.PropertyDefinition || member.static)
+    if (member.type !== import_utils86.AST_NODE_TYPES.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils83.AST_NODE_TYPES.PrivateIdentifier) return false;
-    return member.value?.type === import_utils83.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils83.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils83.AST_NODE_TYPES.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === import_utils86.AST_NODE_TYPES.PrivateIdentifier) return false;
+    return member.value?.type === import_utils86.AST_NODE_TYPES.ArrowFunctionExpression || member.value?.type === import_utils86.AST_NODE_TYPES.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === import_utils86.AST_NODE_TYPES.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === import_utils83.AST_NODE_TYPES.ClassDeclaration) {
+  const declaration = statement.type === import_utils86.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === import_utils86.AST_NODE_TYPES.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== import_utils83.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration?.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils83.AST_NODE_TYPES.Identifier && item.init?.type === import_utils83.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === import_utils86.AST_NODE_TYPES.Identifier && item.init?.type === import_utils86.AST_NODE_TYPES.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -15438,7 +15698,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = /* @__PURE__ */ new Map();
         for (const statement of program.body) {
-          if (statement.type === import_utils83.AST_NODE_TYPES.ExportNamedDeclaration) {
+          if (statement.type === import_utils86.AST_NODE_TYPES.ExportNamedDeclaration) {
             for (const binding of classBindings(statement)) {
               exported.set(binding.declaration, binding.name);
             }
@@ -15447,18 +15707,18 @@ var require_interface_for_exported_class_default = createRule({
               if (specifier.exportKind === "type") continue;
               const candidate2 = classes.get(specifier.local.name);
               if (candidate2 === void 0) continue;
-              const exportedName = specifier.exported.type === import_utils83.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+              const exportedName = specifier.exported.type === import_utils86.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
               exported.set(candidate2, exportedName);
             }
             continue;
           }
-          if (statement.type !== import_utils83.AST_NODE_TYPES.ExportDefaultDeclaration) continue;
-          if (statement.declaration.type === import_utils83.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils83.AST_NODE_TYPES.ClassExpression) {
+          if (statement.type !== import_utils86.AST_NODE_TYPES.ExportDefaultDeclaration) continue;
+          if (statement.declaration.type === import_utils86.AST_NODE_TYPES.ClassDeclaration || statement.declaration.type === import_utils86.AST_NODE_TYPES.ClassExpression) {
             exported.set(
               statement.declaration,
               statement.declaration.id?.name ?? "default"
             );
-          } else if (statement.declaration.type === import_utils83.AST_NODE_TYPES.Identifier) {
+          } else if (statement.declaration.type === import_utils86.AST_NODE_TYPES.Identifier) {
             const candidate2 = classes.get(statement.declaration.name);
             if (candidate2 !== void 0) {
               exported.set(candidate2, statement.declaration.name);
@@ -15466,7 +15726,7 @@ var require_interface_for_exported_class_default = createRule({
           }
         }
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils83.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === import_utils86.AST_NODE_TYPES.Identifier && abstractBases.has(declaration.superClass.name);
           if (declaration.abstract || declaration.implements.length > 0 || extendsLocalAbstractBase || !hasPublicInstanceBehavior(declaration)) continue;
           context.report({
             node: declaration.id ?? declaration,
@@ -15480,7 +15740,7 @@ var require_interface_for_exported_class_default = createRule({
 });
 
 // src/rules/require-port-for-service.ts
-var import_utils84 = require("@typescript-eslint/utils");
+var import_utils87 = require("@typescript-eslint/utils");
 var REQUIRE_PORT_FOR_SERVICE_DOCUMENTATION = {
   summary: "Advise when an exported service with injected collaborators has public methods not covered by its declared ports.",
   rationale: "A declared port keeps consumers coupled to the service capability instead of its concrete implementation.",
@@ -15505,45 +15765,45 @@ var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
 var staticMemberName6 = (member) => {
-  if (member.property.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils84.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils84.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === import_utils87.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === import_utils87.AST_NODE_TYPES.Identifier) return member.property.name;
+  return member.computed && member.property.type === import_utils87.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils87.AST_NODE_TYPES.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 === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils84.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils87.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils87.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils84.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils84.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils87.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils87.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils87.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils84.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils87.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils84.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils84.AST_NODE_TYPES.TSNullKeyword
+      (member) => member.type !== import_utils87.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils87.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils84.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils87.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils84.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils84.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils87.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils87.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === import_utils84.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils84.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils87.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils87.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils87.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils87.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -15554,18 +15814,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils87.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils87.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils84.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils84.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils87.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils87.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils84.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils87.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils87.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils87.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -15594,10 +15854,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils84.AST_NODE_TYPES.ClassExpression || current.type === import_utils84.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils84.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils84.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils84.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils84.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils84.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils84.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils84.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (current.type === import_utils87.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils87.AST_NODE_TYPES.FunctionExpression || current.type === import_utils87.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils87.AST_NODE_TYPES.ClassExpression || current.type === import_utils87.AST_NODE_TYPES.ClassDeclaration) continue;
+      const expression = current.type === import_utils87.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === import_utils87.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils87.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils87.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== import_utils87.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils87.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils87.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -15610,14 +15870,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils84.AST_NODE_TYPES.TSAsExpression || source.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils84.AST_NODE_TYPES.NewExpression) {
+      while (source.type === import_utils87.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils87.AST_NODE_TYPES.TSAsExpression || source.type === import_utils87.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils87.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
+      if (source.type === import_utils87.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils84.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils87.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === import_utils84.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils84.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils87.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils87.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -15635,7 +15895,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared, storedMemberFieldsFrom)) {
-      const fields = parameter.type === import_utils84.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === import_utils87.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
       if (fields.length === 0) continue;
       if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
       if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -15650,8 +15910,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils84.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils87.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils87.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -15660,9 +15920,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === import_utils84.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils84.AST_NODE_TYPES.Identifier) return [];
+  if (target.type === import_utils87.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils87.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils87.AST_NODE_TYPES.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -15678,9 +15938,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils84.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils84.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils84.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils87.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils87.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils87.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -15692,11 +15952,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils84.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils87.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils87.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils84.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils87.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils87.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -15706,21 +15966,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === import_utils84.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils87.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils84.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils84.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils87.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils87.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils84.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils87.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils84.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils84.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils84.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils87.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils87.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils87.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils84.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils84.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils87.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils87.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -15747,19 +16007,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils84.AST_NODE_TYPES.ChainExpression || callee.type === import_utils84.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils84.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === import_utils87.AST_NODE_TYPES.ChainExpression || callee.type === import_utils87.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils87.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils87.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils87.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
+  return callee.type === import_utils87.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === import_utils84.AST_NODE_TYPES.ChainExpression || node.type === import_utils84.AST_NODE_TYPES.TSAsExpression || node.type === import_utils84.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils84.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils84.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils84.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils84.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === import_utils87.AST_NODE_TYPES.ChainExpression || node.type === import_utils87.AST_NODE_TYPES.TSAsExpression || node.type === import_utils87.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils87.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils87.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+  return node.type === import_utils87.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils87.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils84.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils84.AST_NODE_TYPES.ClassExpression || current.type === import_utils84.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils84.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils84.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils87.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils87.AST_NODE_TYPES.ClassExpression || current.type === import_utils87.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils87.AST_NODE_TYPES.FunctionExpression) return;
+    if (current.type === import_utils87.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -15772,14 +16032,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils84.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils84.AST_NODE_TYPES.MethodDefinition) {
+    if (member.type === import_utils87.AST_NODE_TYPES.StaticBlock || member.static) continue;
+    if (member.type === import_utils87.AST_NODE_TYPES.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== import_utils84.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
+    if (member.type !== import_utils87.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === import_utils84.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === import_utils87.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -15799,26 +16059,26 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils87.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === import_utils84.AST_NODE_TYPES.PropertyDefinition) {
+    if (member.type === import_utils87.AST_NODE_TYPES.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) continue;
-      if (member.value?.type !== import_utils84.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils84.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils84.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils84.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
+      if (member.key.type === import_utils87.AST_NODE_TYPES.PrivateIdentifier) continue;
+      if (member.value?.type !== import_utils87.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils87.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils87.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils87.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === import_utils87.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
       continue;
     }
-    if (member.type !== import_utils84.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils87.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils84.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils84.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils87.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils87.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -15826,13 +16086,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === import_utils87.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
   );
   if (methods.length === 0) return false;
   return methods.every((member) => {
     const result = member.value.returnType?.typeAnnotation;
     if (result === void 0) return false;
-    const returnsOwnType = result.type === import_utils84.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils87.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils87.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -15840,10 +16100,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils84.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils84.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils87.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils87.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils84.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils87.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -15865,43 +16125,43 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils87.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils84.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils84.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils87.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils87.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === import_utils84.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils84.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils87.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils87.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== import_utils84.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils87.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== import_utils84.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
-          if (member.type === import_utils84.AST_NODE_TYPES.TSMethodSignature) {
+          if (member.type !== import_utils87.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils87.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== import_utils87.AST_NODE_TYPES.Identifier) continue;
+          if (member.type === import_utils87.AST_NODE_TYPES.TSMethodSignature) {
             callables2.add(member.key.name);
             continue;
           }
-          if (member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils87.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils84.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils84.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === import_utils87.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils87.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils87.AST_NODE_TYPES.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 !== import_utils84.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== import_utils87.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== import_utils84.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils84.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils84.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils84.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils84.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils84.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      if (member.type !== import_utils87.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils87.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== import_utils87.AST_NODE_TYPES.Identifier) continue;
+      if (member.type === import_utils87.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils87.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils87.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -15909,7 +16169,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils84.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils87.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -15936,7 +16196,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils84.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils87.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -15948,7 +16208,7 @@ function hasServicePort(node, methods, classes, interfaces) {
   if (node.implements.length === 0) return false;
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== import_utils84.AST_NODE_TYPES.Identifier) return true;
+    if (implementation.expression.type !== import_utils87.AST_NODE_TYPES.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -15991,7 +16251,7 @@ var require_port_for_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils84.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === import_utils87.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -16026,7 +16286,7 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-sql-access-class.ts
-var import_utils85 = require("@typescript-eslint/utils");
+var import_utils88 = require("@typescript-eslint/utils");
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -16120,9 +16380,9 @@ var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
   ]
 };
 function memberName5(node) {
-  if (!node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Identifier)
+  if (!node.computed && node.property.type === import_utils88.AST_NODE_TYPES.Identifier)
     return node.property.name;
-  if (node.computed && node.property.type === import_utils85.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
+  if (node.computed && node.property.type === import_utils88.AST_NODE_TYPES.Literal && typeof node.property.value === "string")
     return node.property.value;
   return null;
 }
@@ -16134,89 +16394,89 @@ function isDatabaseOperation(method, receiver) {
   return BUILDER_SHORT_TERMINALS.has(method) && expressionCallsBuilder(receiver);
 }
 function databaseReceiver(node) {
-  if (node.type === import_utils85.AST_NODE_TYPES.Identifier)
+  if (node.type === import_utils88.AST_NODE_TYPES.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+  if (node.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return false;
   const name = memberName5(node);
   return name === "DB" || name !== null && DATABASE_NAMES.test(name);
 }
 function databaseRootMember(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils88.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils88.AST_NODE_TYPES.TSAsExpression || current.type === import_utils88.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils88.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return null;
+    if (current.type === import_utils88.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
-      if (current.object.type === import_utils85.AST_NODE_TYPES.ThisExpression)
+    if (current.type === import_utils88.AST_NODE_TYPES.MemberExpression) {
+      if (current.object.type === import_utils88.AST_NODE_TYPES.ThisExpression)
         return memberName5(current);
       current = current.object;
       continue;
     }
-    return current.type === import_utils85.AST_NODE_TYPES.Identifier ? current.name : null;
+    return current.type === import_utils88.AST_NODE_TYPES.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils88.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils88.AST_NODE_TYPES.TSAsExpression || current.type === import_utils88.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils88.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils88.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils88.AST_NODE_TYPES.MemberExpression) {
       const name = memberName5(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === import_utils85.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === import_utils88.AST_NODE_TYPES.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils85.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === import_utils88.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.TSAsExpression || current.type === import_utils85.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils85.AST_NODE_TYPES.TSTypeAssertion) {
+    if (current.type === import_utils88.AST_NODE_TYPES.TSAsExpression || current.type === import_utils88.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils88.AST_NODE_TYPES.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === import_utils85.AST_NODE_TYPES.CallExpression) {
-      if (current.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type === import_utils88.AST_NODE_TYPES.CallExpression) {
+      if (current.callee.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return false;
       const name = memberName5(current.callee);
       if (name !== null && BUILDER_METHODS.has(name)) return true;
       current = current.callee.object;
       continue;
     }
-    if (current.type !== import_utils85.AST_NODE_TYPES.MemberExpression) return false;
+    if (current.type !== import_utils88.AST_NODE_TYPES.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === import_utils85.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils85.AST_NODE_TYPES.ClassExpression)
+    if (current.type === import_utils88.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils88.AST_NODE_TYPES.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -16225,25 +16485,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === import_utils85.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === import_utils88.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
   );
   if (constructor === void 0) return injected;
   const parameters = /* @__PURE__ */ new Set();
   for (const parameter of constructor.value.params) {
     for (const name of parameterNames(parameter)) parameters.add(name);
-    if (parameter.type !== import_utils85.AST_NODE_TYPES.TSParameterProperty) continue;
-    const value = parameter.parameter.type === import_utils85.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === import_utils85.AST_NODE_TYPES.Identifier) injected.add(value.name);
+    if (parameter.type !== import_utils88.AST_NODE_TYPES.TSParameterProperty) continue;
+    const value = parameter.parameter.type === import_utils88.AST_NODE_TYPES.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === import_utils88.AST_NODE_TYPES.Identifier) injected.add(value.name);
   }
   const body2 = constructor.value.body;
   if (body2 === null) return injected;
   for (const statement of body2.body) {
-    if (statement.type !== import_utils85.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils85.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") continue;
+    if (statement.type !== import_utils88.AST_NODE_TYPES.ExpressionStatement || statement.expression.type !== import_utils88.AST_NODE_TYPES.AssignmentExpression || statement.expression.operator !== "=") continue;
     const { left, right } = statement.expression;
-    if (left.type !== import_utils85.AST_NODE_TYPES.MemberExpression) continue;
+    if (left.type !== import_utils88.AST_NODE_TYPES.MemberExpression) continue;
     const target = thisRootMember(left);
     if (target === null) continue;
-    const source = right.type === import_utils85.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils85.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils85.AST_NODE_TYPES.Identifier ? right.object.name : null;
+    const source = right.type === import_utils88.AST_NODE_TYPES.Identifier ? right.name : right.type === import_utils88.AST_NODE_TYPES.MemberExpression && right.object.type === import_utils88.AST_NODE_TYPES.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   return injected;
@@ -16251,26 +16511,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === import_utils85.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils88.AST_NODE_TYPES.MemberExpression) {
     const name = memberName5(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === import_utils85.AST_NODE_TYPES.ThisExpression ? root : null;
+  return current.type === import_utils88.AST_NODE_TYPES.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === import_utils85.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
-  if (value.type === import_utils85.AST_NODE_TYPES.AssignmentPattern) value = value.left;
-  if (value.type === import_utils85.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== import_utils85.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === import_utils88.AST_NODE_TYPES.TSParameterProperty) value = value.parameter;
+  if (value.type === import_utils88.AST_NODE_TYPES.AssignmentPattern) value = value.left;
+  if (value.type === import_utils88.AST_NODE_TYPES.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== import_utils88.AST_NODE_TYPES.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === import_utils85.AST_NODE_TYPES.RestElement)
-        return property.argument.type === import_utils85.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === import_utils85.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-      return target.type === import_utils85.AST_NODE_TYPES.Identifier ? [target.name] : [];
+      if (property.type === import_utils88.AST_NODE_TYPES.RestElement)
+        return property.argument.type === import_utils88.AST_NODE_TYPES.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === import_utils88.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+      return target.type === import_utils88.AST_NODE_TYPES.Identifier ? [target.name] : [];
     })
   );
 }
@@ -16293,7 +16553,7 @@ var require_sql_access_class_default = createRule({
       return {};
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils85.AST_NODE_TYPES.MemberExpression)
+        if (node.callee.type !== import_utils88.AST_NODE_TYPES.MemberExpression)
           return;
         const method = memberName5(node.callee);
         if (method === null || !isDatabaseOperation(method, node.callee.object))
@@ -16310,7 +16570,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils86 = require("@typescript-eslint/utils");
+var import_utils89 = require("@typescript-eslint/utils");
 var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
   summary: "Require Next.js middleware and proxy matcher configuration to contain only build-time literals.",
   rationale: "Next.js must statically analyze matcher values at build time; computed values are ignored.",
@@ -16323,34 +16583,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === import_utils86.AST_NODE_TYPES.TSAsExpression || node.type === import_utils86.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils86.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils86.AST_NODE_TYPES.TSTypeAssertion) {
+  if (node.type === import_utils89.AST_NODE_TYPES.TSAsExpression || node.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils89.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === import_utils86.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils89.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils86.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils89.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils86.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils89.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils86.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils89.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils86.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils89.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils86.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils86.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils89.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils89.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName6(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils86.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils89.AST_NODE_TYPES.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -16373,19 +16633,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils86.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils89.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils86.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils89.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== import_utils86.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils89.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils86.AST_NODE_TYPES.Property || propertyName6(property) !== "matcher" || property.value.type === import_utils86.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils89.AST_NODE_TYPES.Property || propertyName6(property) !== "matcher" || property.value.type === import_utils89.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -16399,7 +16659,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-var import_utils87 = require("@typescript-eslint/utils");
+var import_utils90 = require("@typescript-eslint/utils");
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "react-hook-form useForm call without defaultValues",
   rationale: "Without an explicit initial value, fields can change from uncontrolled to controlled as data arrives, reset behavior becomes ambiguous, and the form's initial shape no longer documents the values users can edit.",
@@ -16453,13 +16713,13 @@ var require_use_form_default_values_default = createRule({
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "useForm") continue;
-          const variable = import_utils87.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = import_utils90.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
           if (variable) importedHooks.add(variable);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== "Identifier") return;
-        const variable = import_utils87.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = import_utils90.ASTUtils.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
         const options = node.arguments[0];
         if (!variable || !importedHooks.has(variable) || options !== void 0 && options.type !== "ObjectExpression" || hasDefaultValues(options)) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -16469,7 +16729,7 @@ var require_use_form_default_values_default = createRule({
 });
 
 // src/rules/require-use-server-in-actions-file.ts
-var import_utils88 = require("@typescript-eslint/utils");
+var import_utils91 = require("@typescript-eslint/utils");
 var ACTION_MODULE_RE = /(?:^|\/)app\/.*\/(?:actions|[^/]+-actions)\.[cm]?[jt]s$/u;
 var REQUIRE_USE_SERVER_IN_ACTIONS_FILE_DOCUMENTATION = {
   summary: "route action module missing the use server directive",
@@ -16535,7 +16795,7 @@ var require_use_server_in_actions_file_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils89 = require("@typescript-eslint/utils");
+var import_utils92 = require("@typescript-eslint/utils");
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
   rationale: "FormData values are untrusted strings or files and need runtime validation before use.",
@@ -16560,14 +16820,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils89.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils92.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils89.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils92.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils89.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils92.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -16576,12 +16836,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils92.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils89.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils89.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils92.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils92.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -16602,7 +16862,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => import_utils89.ASTUtils.findVariable(
+    const resolvedBinding = (identifier) => import_utils92.ASTUtils.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -16612,16 +16872,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils89.AST_NODE_TYPES.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils92.AST_NODE_TYPES.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === import_utils89.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils89.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils89.AST_NODE_TYPES.Literal || init?.type === import_utils89.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils89.AST_NODE_TYPES.FunctionExpression;
+      return init?.type === import_utils92.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils92.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils92.AST_NODE_TYPES.Literal || init?.type === import_utils92.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils92.AST_NODE_TYPES.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== import_utils89.AST_NODE_TYPES.CallExpression) return false;
+      if (node.type !== import_utils92.AST_NODE_TYPES.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== import_utils89.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils89.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils92.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -16630,14 +16890,14 @@ var require_zod_form_validation_default = createRule({
       return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
     };
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils89.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils92.AST_NODE_TYPES.Identifier) return false;
       const conventionalName = /formdata/i.test(node.name);
       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 === import_utils89.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils92.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -16648,8 +16908,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils89.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils89.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils92.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -16665,16 +16925,16 @@ var require_zod_form_validation_default = createRule({
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils89.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils89.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils92.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils92.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === import_utils89.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils89.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils89.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils89.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+      while ((parent.type === import_utils92.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils92.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils92.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils92.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === import_utils89.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils89.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils92.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils92.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -16683,7 +16943,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === import_utils89.AST_NODE_TYPES.BlockStatement || parent.type === import_utils89.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils92.AST_NODE_TYPES.BlockStatement || parent.type === import_utils92.AST_NODE_TYPES.Program) {
           return current;
         }
         current = parent;
@@ -16692,12 +16952,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === import_utils89.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils89.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      return callee.type === import_utils92.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils92.AST_NODE_TYPES.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils89.AST_NODE_TYPES.LogicalExpression || current.type === import_utils89.AST_NODE_TYPES.ConditionalExpression) {
+        if (current.type === import_utils92.AST_NODE_TYPES.LogicalExpression || current.type === import_utils92.AST_NODE_TYPES.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -16707,7 +16967,7 @@ var require_zod_form_validation_default = createRule({
     const isAwaitedBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils89.AST_NODE_TYPES.AwaitExpression) return true;
+        if (current.type === import_utils92.AST_NODE_TYPES.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -16720,7 +16980,7 @@ var require_zod_form_validation_default = createRule({
       if (declarationStatement === null || validationStatement === null || declarationStatement.parent !== validationStatement.parent || validationStatement.range[0] <= declarationStatement.range[1] || hasConditionalAncestorBeforeStatement(parse2, validationStatement)) {
         return null;
       }
-      if (validationStatement.type !== import_utils89.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils89.AST_NODE_TYPES.ExpressionStatement) {
+      if (validationStatement.type !== import_utils92.AST_NODE_TYPES.VariableDeclaration && validationStatement.type !== import_utils92.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -16732,16 +16992,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === import_utils89.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === import_utils92.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== import_utils89.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== import_utils92.AST_NODE_TYPES.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === import_utils89.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === import_utils92.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils89.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils89.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils92.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils92.AST_NODE_TYPES.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -16752,23 +17012,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === import_utils89.AST_NODE_TYPES.ReturnStatement || node.type === import_utils89.AST_NODE_TYPES.ThrowStatement) {
+      if (node.type === import_utils92.AST_NODE_TYPES.ReturnStatement || node.type === import_utils92.AST_NODE_TYPES.ThrowStatement) {
         return true;
       }
-      if (node.type !== import_utils89.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== import_utils92.AST_NODE_TYPES.BlockStatement || node.body.length === 0) return false;
       const last = node.body.at(-1);
       return last !== void 0 && blockTerminates(last);
     };
     const narrowingIf = (identifier) => {
       const comparison = identifier.parent;
-      if (comparison?.type !== import_utils89.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils89.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== import_utils92.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils92.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === import_utils89.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === import_utils92.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === import_utils89.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === import_utils92.AST_NODE_TYPES.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -16788,7 +17048,7 @@ var require_zod_form_validation_default = createRule({
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
       const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
-        (identifier) => identifier.type === import_utils89.AST_NODE_TYPES.Identifier
+        (identifier) => identifier.type === import_utils92.AST_NODE_TYPES.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -16814,7 +17074,7 @@ var require_zod_form_validation_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils89.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils89.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils89.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils89.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils92.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils92.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils92.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils92.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -16835,7 +17095,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils90 = require("@typescript-eslint/utils");
+var import_utils93 = require("@typescript-eslint/utils");
 var STORE_INSERT_REQUIRES_ON_CONFLICT_DOCUMENTATION = {
   summary: "Require embedded inserts in explicitly replayable callables to carry conflict handling.",
   rationale: "A callable named as an enqueue, seed, migration, schedule, ensure, or upsert promises replay safety.",
@@ -16899,7 +17159,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils91 = require("@typescript-eslint/utils");
+var import_utils94 = require("@typescript-eslint/utils");
 var STEPDOWN_DOCUMENTATION = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -16919,7 +17179,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === import_utils91.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils91.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils94.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils94.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils94.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true, makeFix) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -17016,8 +17276,8 @@ function moduleScope(context, program) {
   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 === import_utils91.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils91.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils94.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils94.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -17041,7 +17301,7 @@ function moduleScope(context, program) {
       const nearestFunction2 = [...ancestors].reverse().find(isFunction);
       const parent = identifier.parent;
       const callerDefinition = nearestFunction2 === void 0 ? void 0 : byFunction.get(nearestFunction2);
-      if (callerDefinition === void 0 || parent.type !== import_utils91.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== import_utils94.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -17056,38 +17316,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils91.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils94.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils94.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils91.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils94.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils91.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils94.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils91.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils94.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils91.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils94.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils94.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils94.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils94.AST_NODE_TYPES.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 === import_utils91.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils91.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils91.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils94.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils94.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils94.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils91.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils94.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils91.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === import_utils94.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -17100,21 +17360,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils91.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (node.key.type === import_utils94.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === import_utils94.AST_NODE_TYPES.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils91.AST_NODE_TYPES.Identifier ? import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === import_utils94.AST_NODE_TYPES.Identifier ? import_utils94.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils91.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== import_utils94.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
+  if (node.property.type === import_utils94.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils94.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils94.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils94.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils94.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils94.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk2(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -17130,7 +17390,7 @@ function walk2(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils91.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils94.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -17138,8 +17398,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== import_utils91.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils91.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils94.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils94.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -17148,7 +17408,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils91.AST_NODE_TYPES.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === import_utils94.AST_NODE_TYPES.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -17157,11 +17417,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils94.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === import_utils91.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils91.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils94.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils94.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils94.AST_NODE_TYPES.Identifier) {
+    const outer = import_utils94.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -17177,27 +17437,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils91.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils91.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils91.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils91.AST_NODE_TYPES.ThisExpression;
+      while (current?.type === import_utils94.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils94.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils94.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+      return current?.type === import_utils94.AST_NODE_TYPES.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils91.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils91.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils91.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== import_utils94.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils94.AST_NODE_TYPES.AssignmentPattern) return;
+      if (current.type === import_utils94.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils94.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === import_utils94.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
+      const value = current.type === import_utils94.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === import_utils91.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils94.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils91.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils94.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === import_utils91.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === import_utils94.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== import_utils91.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== import_utils94.AST_NODE_TYPES.Identifier) return;
+      const variable = import_utils94.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -17210,16 +17470,16 @@ function classScope(context, node, computedReferenceNames) {
       walk2(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils91.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils91.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
+      if (current.type === import_utils94.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils94.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === import_utils91.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils94.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === import_utils91.AST_NODE_TYPES.Property && property.key.type === import_utils91.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === import_utils94.AST_NODE_TYPES.Property && property.key.type === import_utils94.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils94.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -17227,12 +17487,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils91.AST_NODE_TYPES.Identifier ? import_utils91.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === import_utils94.AST_NODE_TYPES.Identifier ? import_utils94.ASTUtils.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 !== import_utils91.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils94.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -17252,9 +17512,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils91.AST_NODE_TYPES.MethodDefinition || member.type === import_utils91.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils94.AST_NODE_TYPES.MethodDefinition || member.type === import_utils94.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk2(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils91.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils94.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -17306,12 +17566,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case import_utils91.AST_NODE_TYPES.StaticBlock:
+    case import_utils94.AST_NODE_TYPES.StaticBlock:
       return true;
-    case import_utils91.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils91.AST_NODE_TYPES.AccessorProperty:
+    case import_utils94.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils94.AST_NODE_TYPES.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case import_utils91.AST_NODE_TYPES.MethodDefinition:
+    case import_utils94.AST_NODE_TYPES.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -17344,7 +17604,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk2(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils91.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils91.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils94.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils94.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -17353,7 +17613,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-var import_utils92 = require("@typescript-eslint/utils");
+var import_utils95 = require("@typescript-eslint/utils");
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
@@ -17422,20 +17682,20 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === import_utils92.AST_NODE_TYPES.Identifier) return node.property.name;
-  if (node.computed && node.property.type === import_utils92.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === import_utils95.AST_NODE_TYPES.Identifier) return node.property.name;
+  if (node.computed && node.property.type === import_utils95.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap6(node) {
-  if (node.type === import_utils92.AST_NODE_TYPES.AwaitExpression) return unwrap6(node.argument);
-  if (node.type === import_utils92.AST_NODE_TYPES.ChainExpression) return unwrap6(node.expression);
-  if (node.type === import_utils92.AST_NODE_TYPES.TSAsExpression || node.type === import_utils92.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils92.AST_NODE_TYPES.TSTypeAssertion) return unwrap6(node.expression);
+  if (node.type === import_utils95.AST_NODE_TYPES.AwaitExpression) return unwrap6(node.argument);
+  if (node.type === import_utils95.AST_NODE_TYPES.ChainExpression) return unwrap6(node.expression);
+  if (node.type === import_utils95.AST_NODE_TYPES.TSAsExpression || node.type === import_utils95.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils95.AST_NODE_TYPES.TSTypeAssertion) return unwrap6(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap6(node);
-  if (current.type === import_utils92.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
-  if (current.type === import_utils92.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === import_utils95.AST_NODE_TYPES.Literal && typeof current.value === "string") return current.value;
+  if (current.type === import_utils95.AST_NODE_TYPES.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
   return null;
 }
 function importSource(node) {
@@ -17443,7 +17703,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap6(node);
-  if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils92.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils92.AST_NODE_TYPES.SpreadElement) return null;
+  if (current.type !== import_utils95.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils95.AST_NODE_TYPES.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === import_utils95.AST_NODE_TYPES.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -17483,38 +17743,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
-        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
+        if (current.type === import_utils95.AST_NODE_TYPES.Identifier) return visible("paths", current.name);
+        if (current.type === import_utils95.AST_NODE_TYPES.BinaryExpression && current.operator === "+") {
           return sourcePath(current.left) || sourcePath(current.right);
         }
-        if (current.type === import_utils92.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
-        if (current.type === import_utils92.AST_NODE_TYPES.CallExpression || current.type === import_utils92.AST_NODE_TYPES.NewExpression) {
-          return current.arguments.some((argument) => argument.type !== import_utils92.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
+        if (current.type === import_utils95.AST_NODE_TYPES.TemplateLiteral) return current.expressions.some(sourcePath);
+        if (current.type === import_utils95.AST_NODE_TYPES.CallExpression || current.type === import_utils95.AST_NODE_TYPES.NewExpression) {
+          return current.arguments.some((argument) => argument.type !== import_utils95.AST_NODE_TYPES.SpreadElement && sourcePath(argument));
         }
-        if (current.type === import_utils92.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
+        if (current.type === import_utils95.AST_NODE_TYPES.MemberExpression) return sourcePath(current.object);
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap6(node);
-        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== import_utils95.AST_NODE_TYPES.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap6(current.callee);
-        if (callee.type === import_utils92.AST_NODE_TYPES.Identifier) {
+        if (callee.type === import_utils95.AST_NODE_TYPES.Identifier) {
           return visible("fsReaders", callee.name) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return false;
+        if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap6(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils92.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === import_utils95.AST_NODE_TYPES.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap6(node);
-        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
+        if (current.type === import_utils95.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current.name);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils92.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils95.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === import_utils95.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== import_utils95.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
@@ -17522,38 +17782,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap6(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === import_utils92.AST_NODE_TYPES.BinaryExpression || current.type === import_utils92.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === import_utils92.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== import_utils92.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === import_utils95.AST_NODE_TYPES.BinaryExpression || current.type === import_utils95.AST_NODE_TYPES.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === import_utils95.AST_NODE_TYPES.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== import_utils95.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap6(current.callee);
-        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(callee.object);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === import_utils95.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap6(node.callee);
-        if (callee.type === import_utils92.AST_NODE_TYPES.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === import_utils95.AST_NODE_TYPES.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === import_utils95.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap6(callee.object);
-        while (receiver.type === import_utils92.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap6(receiver.object);
-        if (receiver.type === import_utils92.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils92.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === import_utils95.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap6(receiver.object);
+        if (receiver.type === import_utils95.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils95.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === import_utils95.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils92.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils92.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== import_utils95.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === import_utils95.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const rawRegexExtractionOrigins = (node) => {
         const callee = unwrap6(node.callee);
-        if (callee.type !== import_utils92.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        if (callee.type !== import_utils95.AST_NODE_TYPES.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
         const argument = node.arguments[0];
-        if (argument?.type !== import_utils92.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
+        if (argument?.type !== import_utils95.AST_NODE_TYPES.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
         return rawOrigins(callee.object);
       };
       const declare = (name2, state) => {
@@ -17574,15 +17834,15 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap6(node);
-        return current.type === import_utils92.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils92.AST_NODE_TYPES.SpreadElement && sourcePath(element));
+        return current.type === import_utils95.AST_NODE_TYPES.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== import_utils95.AST_NODE_TYPES.SpreadElement && sourcePath(element));
       };
       const declaredNames2 = (node) => {
         const current = unwrap6(node);
-        if (current.type === import_utils92.AST_NODE_TYPES.Identifier) return [current.name];
-        if (current.type === import_utils92.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
-        if (current.type === import_utils92.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
-        if (current.type === import_utils92.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
-        if (current.type === import_utils92.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils92.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
+        if (current.type === import_utils95.AST_NODE_TYPES.Identifier) return [current.name];
+        if (current.type === import_utils95.AST_NODE_TYPES.AssignmentPattern) return declaredNames2(current.left);
+        if (current.type === import_utils95.AST_NODE_TYPES.RestElement) return declaredNames2(current.argument);
+        if (current.type === import_utils95.AST_NODE_TYPES.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
+        if (current.type === import_utils95.AST_NODE_TYPES.ObjectPattern) return current.properties.flatMap((property) => property.type === import_utils95.AST_NODE_TYPES.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
         return [];
       };
       const enterFunction = (node) => {
@@ -17597,8 +17857,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           const source = importSource(node);
           if (source === null || !FS_MODULES.has(source)) return;
           for (const specifier of node.specifiers) {
-            if (specifier.type === import_utils92.AST_NODE_TYPES.ImportSpecifier) {
-              const imported = specifier.imported.type === import_utils92.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === import_utils95.AST_NODE_TYPES.ImportSpecifier) {
+              const imported = specifier.imported.type === import_utils95.AST_NODE_TYPES.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local.name, { fsReader: true });
             } else {
               declare(specifier.local.name, { fsObject: true });
@@ -17610,29 +17870,29 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         VariableDeclarator(node) {
           if (node.init === null) return;
           const required = requireSource(node.init);
-          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils92.AST_NODE_TYPES.Identifier) {
+          if (required !== null && FS_MODULES.has(required) && node.id.type === import_utils95.AST_NODE_TYPES.Identifier) {
             declare(node.id.name, { fsObject: true });
             return;
           }
-          if (node.id.type === import_utils92.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === import_utils95.AST_NODE_TYPES.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== import_utils92.AST_NODE_TYPES.Property || property.value.type !== import_utils92.AST_NODE_TYPES.Identifier) continue;
-              const key = property.key.type === import_utils92.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils92.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
+              if (property.type !== import_utils95.AST_NODE_TYPES.Property || property.value.type !== import_utils95.AST_NODE_TYPES.Identifier) continue;
+              const key = property.key.type === import_utils95.AST_NODE_TYPES.Identifier ? property.key.name : property.key.type === import_utils95.AST_NODE_TYPES.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value.name, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== import_utils92.AST_NODE_TYPES.Identifier) return;
+          if (node.id.type !== import_utils95.AST_NODE_TYPES.Identifier) return;
           declare(node.id.name, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === import_utils92.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
+          if (node.left.type === import_utils95.AST_NODE_TYPES.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
         },
         ForOfStatement(node) {
           const right = unwrap6(node.right);
-          const collection = right.type === import_utils92.AST_NODE_TYPES.Identifier && visible("collections", right.name);
-          const left = node.left.type === import_utils92.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === import_utils92.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
+          const collection = right.type === import_utils95.AST_NODE_TYPES.Identifier && visible("collections", right.name);
+          const left = node.left.type === import_utils95.AST_NODE_TYPES.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === import_utils95.AST_NODE_TYPES.Identifier) declare(left.name, { path: true });
         },
         CallExpression(node) {
           const origins = /* @__PURE__ */ new Set([
@@ -17654,7 +17914,7 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/sole-export-matches-filename.ts
-var import_utils93 = require("@typescript-eslint/utils");
+var import_utils96 = require("@typescript-eslint/utils");
 var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
   summary: "Match a module filename to its sole named public runtime export.",
   rationale: "When a module owns one runtime responsibility, matching names make that responsibility directly discoverable.",
@@ -17697,10 +17957,10 @@ function kebabCase(name) {
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === import_utils93.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils93.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils93.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== import_utils93.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration.type === import_utils96.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils96.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== import_utils96.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils93.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === import_utils96.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -17724,31 +17984,31 @@ var sole_export_matches_filename_default = createRule({
         const exports2 = [];
         const publicExports = /* @__PURE__ */ new Set();
         for (const statement of program.body) {
-          if (statement.type === import_utils93.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils93.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
-          if (statement.type === import_utils93.AST_NODE_TYPES.ExportDefaultDeclaration) {
+          if (statement.type === import_utils96.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils96.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return;
+          if (statement.type === import_utils96.AST_NODE_TYPES.ExportDefaultDeclaration) {
             publicExports.add("default");
             const declaration2 = statement.declaration;
-            if ((declaration2.type === import_utils93.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils93.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
+            if ((declaration2.type === import_utils96.AST_NODE_TYPES.ClassDeclaration || declaration2.type === import_utils96.AST_NODE_TYPES.FunctionDeclaration) && declaration2.id !== null) exports2.push({ name: declaration2.id.name, node: declaration2 });
             else return;
           }
-          if (statement.type !== import_utils93.AST_NODE_TYPES.ExportNamedDeclaration) continue;
+          if (statement.type !== import_utils96.AST_NODE_TYPES.ExportNamedDeclaration) continue;
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils93.AST_NODE_TYPES.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils96.AST_NODE_TYPES.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === import_utils93.AST_NODE_TYPES.VariableDeclaration) {
+          if (declaration?.type === import_utils96.AST_NODE_TYPES.VariableDeclaration) {
             for (const item of declaration.declarations) {
-              if (item.id.type === import_utils93.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
+              if (item.id.type === import_utils96.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
             }
           }
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === import_utils93.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === import_utils96.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
           }
           if (statement.exportKind === "type") continue;
           exports2.push(...declarationExport(statement));
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === import_utils93.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === import_utils96.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
             if (specifier.exportKind === "type") continue;
             if (exported === "default") exports2.push({ name: specifier.local.name, node: specifier });
@@ -17806,7 +18066,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/require-pascal-case-zod-schema-name.ts
-var import_utils94 = require("@typescript-eslint/utils");
+var import_utils97 = require("@typescript-eslint/utils");
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
   rationale: "A reusable Zod schema is a runtime type contract. PascalCase mirrors that role; SCREAMING_SNAKE_CASE should remain reserved for scalar values and lookup tables.",
@@ -17938,18 +18198,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils94.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils97.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils94.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils97.AST_NODE_TYPES.Identifier) {
       return current;
     }
-    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils97.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils97.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -17960,13 +18220,13 @@ var chainMemberNames = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === import_utils94.AST_NODE_TYPES.MemberExpression) {
-      if (current.computed || current.property.type !== import_utils94.AST_NODE_TYPES.Identifier) return [];
+    if (current.type === import_utils97.AST_NODE_TYPES.MemberExpression) {
+      if (current.computed || current.property.type !== import_utils97.AST_NODE_TYPES.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === import_utils94.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils97.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -17977,16 +18237,16 @@ var chainMemberNames = (node) => {
 };
 var unwrapExpression4 = (node) => {
   let current = node;
-  while (current.type === import_utils94.AST_NODE_TYPES.TSAsExpression || current.type === import_utils94.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils94.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils94.AST_NODE_TYPES.TSTypeAssertion) {
+  while (current.type === import_utils97.AST_NODE_TYPES.TSAsExpression || current.type === import_utils97.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils97.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils97.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== import_utils94.AST_NODE_TYPES.VariableDeclaration) return false;
+  if (declaration.type !== import_utils97.AST_NODE_TYPES.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === import_utils94.AST_NODE_TYPES.Program || owner.type === import_utils94.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils94.AST_NODE_TYPES.Program;
+  return owner.type === import_utils97.AST_NODE_TYPES.Program || owner.type === import_utils97.AST_NODE_TYPES.ExportNamedDeclaration && owner.parent.type === import_utils97.AST_NODE_TYPES.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -18006,7 +18266,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return import_utils94.ASTUtils.findVariable(
+      return import_utils97.ASTUtils.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -18027,8 +18287,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression4(expression);
-      if (init.type === import_utils94.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
-      if (init.type !== import_utils94.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils94.AST_NODE_TYPES.MemberExpression) {
+      if (init.type === import_utils97.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
+      if (init.type !== import_utils97.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils97.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -18048,7 +18308,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils94.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils94.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils94.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils94.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === import_utils97.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils97.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils97.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils97.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -18057,7 +18317,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
         if (!isModuleDeclarator(node)) return;
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (node.id.type !== import_utils94.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils97.AST_NODE_TYPES.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -18215,6 +18475,9 @@ var RULES = {
   "prefer-shadcn-primitives": prefer_shadcn_primitives_default,
   "prefer-module-level-constant": prefer_module_level_constant_default,
   "prefer-module-level-schema": prefer_module_level_schema_default,
+  "prefer-module-level-refined-schema": prefer_module_level_refined_schema_default,
+  "prefer-multi-value-zod-literal": prefer_multi_value_zod_literal_default,
+  "prefer-named-callback-domain": prefer_named_callback_domain_default,
   "prefer-named-complex-return-type": prefer_named_complex_return_type_default,
   "prefer-native-random-uuid": prefer_native_random_uuid_default,
   "prefer-node-crypto-hash": prefer_node_crypto_hash_default,
@@ -18238,14 +18501,14 @@ 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,
+  stepdown: stepdown_default,
   "source-coupled-test": source_coupled_test_default,
   "sole-export-matches-filename": sole_export_matches_filename_default,
   "require-pascal-case-zod-schema-name": require_pascal_case_zod_schema_name_default
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.16.0"
+  version: "15.17.0"
 };
 var APPLICATION_ONLY_RULES = [
   "no-restricted-library-load",
@@ -18253,6 +18516,9 @@ var APPLICATION_ONLY_RULES = [
   "prefer-shadcn-primitives"
 ];
 var ADVISORY_RULES = [
+  "@sarj/prefer-module-level-refined-schema",
+  "@sarj/prefer-multi-value-zod-literal",
+  "@sarj/prefer-named-callback-domain",
   "@sarj/prefer-named-complex-return-type",
   "@sarj/prefer-node-crypto-hash",
   "@sarj/prefer-node-fs-promises",
@@ -18316,6 +18582,9 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-immutable-module-constant": "error",
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
+  "@sarj/prefer-module-level-refined-schema": "warn",
+  "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
+  "@sarj/prefer-named-callback-domain": "warn",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",
@@ -18403,6 +18672,9 @@ var STRICT_RULES = {
   "@sarj/prefer-immutable-module-constant": "error",
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
+  "@sarj/prefer-module-level-refined-schema": "warn",
+  "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
+  "@sarj/prefer-named-callback-domain": "warn",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",