@sarj/eslint-plugin 15.26.8 → 15.28.0

package/dist/index.js

@@ -15710,8 +15710,134 @@ var prefer_multi_value_zod_literal_default = createRule({
   }
 });
 
+// src/rules/prefer-nominal-id-types.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES75, ASTUtils as ASTUtils35 } from "@typescript-eslint/utils";
+var OPERATIONAL_ROLES = /* @__PURE__ */ new Set([
+  "request",
+  "trace",
+  "span",
+  "correlation",
+  "process",
+  "thread",
+  "timeout",
+  "interval"
+]);
+var MAX_ALIAS_DEPTH = 16;
+var PREFER_NOMINAL_ID_TYPES_DOCUMENTATION = {
+  defaultLevel: "warning",
+  summary: "Distinguish identifier roles sharing primitive types at callable boundaries.",
+  rationale: "Two identifier roles represented by the same primitive accept each other's values, so swapped arguments survive type checking. Transparent aliases do not prevent this.",
+  remediation: "Introduce distinct branded identifier types at a validated domain boundary and use them in the callable contract. Keep wire representations primitive until validation; suppress a required external signature locally with a reason.",
+  category: "correctness",
+  limitations: [
+    "Requires two distinct Id/Ids or _id/_ids parameter roles with the same proven string, number, or homogeneous array carrier. Plural names require array carriers. Scalars and arrays remain distinct; object fields, destructuring, tuples, inferred types and generic aliases are not checked.",
+    "Resolves only scope-correct file-local transparent aliases, up to 16 levels. Intersections, imported types, ambiguous declarations and mixed branded/raw pairs are deliberately skipped.",
+    "Generated files and request, trace, span, correlation, process, thread, timeout and interval identifiers are excluded. Raw wire object schemas are not callable boundaries; required external callable signatures need a local suppression. API and adapter paths are not blanket-excluded."
+  ],
+  examples: [
+    { id: "raw-identifiers", title: "Do not accept interchangeable identifiers", outcome: "match", files: [{ path: "src/store.ts", source: "function load(accountId: string, invoiceId: string): void {}" }], focusPath: "src/store.ts", expectedCount: 1, public: true },
+    { id: "branded-identifiers", title: "Distinguish domain identifiers", outcome: "no-match", files: [{ path: "src/store.ts", source: "type AccountId = string & { readonly account: unique symbol }; type InvoiceId = string & { readonly invoice: unique symbol }; function load(accountId: AccountId, invoiceId: InvoiceId): void {}" }], focusPath: "src/store.ts", expectedCount: 0, public: true }
+  ]
+};
+function arrayCarrier(carrier) {
+  if (carrier === "string") return "string[]";
+  if (carrier === "number") return "number[]";
+  return void 0;
+}
+function isNullish(node) {
+  return node.type === AST_NODE_TYPES75.TSUndefinedKeyword || node.type === AST_NODE_TYPES75.TSNullKeyword || node.type === AST_NODE_TYPES75.TSLiteralType && node.literal.type === AST_NODE_TYPES75.Literal && node.literal.value === null;
+}
+function referenceCarrier(node, context, depth) {
+  if (node.typeName.type !== AST_NODE_TYPES75.Identifier) return void 0;
+  const variable = ASTUtils35.findVariable(context.sourceCode.getScope(node), node.typeName.name);
+  const definitions = variable?.defs ?? [];
+  const args = node.typeArguments?.params;
+  if (definitions.length === 0 && ["Array", "ReadonlyArray"].includes(node.typeName.name) && args?.length === 1) {
+    return arrayCarrier(rawCarrier(args[0], context, depth + 1));
+  }
+  if (args !== void 0 || definitions.length !== 1) return void 0;
+  const declaration = definitions[0]?.node;
+  if (declaration?.type !== AST_NODE_TYPES75.TSTypeAliasDeclaration || declaration.typeParameters !== void 0) return void 0;
+  return rawCarrier(declaration.typeAnnotation, context, depth + 1);
+}
+function rawCarrier(node, context, depth = 0) {
+  if (node === void 0 || depth >= MAX_ALIAS_DEPTH) return void 0;
+  switch (node.type) {
+    case AST_NODE_TYPES75.TSStringKeyword:
+      return "string";
+    case AST_NODE_TYPES75.TSNumberKeyword:
+      return "number";
+    case AST_NODE_TYPES75.TSArrayType:
+      return arrayCarrier(rawCarrier(node.elementType, context, depth + 1));
+    case AST_NODE_TYPES75.TSTypeOperator:
+      return node.operator === "readonly" ? rawCarrier(node.typeAnnotation, context, depth + 1) : void 0;
+    case AST_NODE_TYPES75.TSUnionType: {
+      const members = node.types.filter((member) => !isNullish(member));
+      if (members.length !== 1) return void 0;
+      return rawCarrier(members[0], context, depth + 1);
+    }
+    case AST_NODE_TYPES75.TSTypeReference:
+      return referenceCarrier(node, context, depth);
+    default:
+      return void 0;
+  }
+}
+function checkBoundary(node, context) {
+  const roles = /* @__PURE__ */ new Map();
+  for (const parameter of node.params) {
+    const identifier = parameterIdentifier(parameter);
+    if (identifier?.typeAnnotation === void 0) continue;
+    const role = identifierRole(identifier.name);
+    if (role === void 0) continue;
+    const carrier = rawCarrier(identifier.typeAnnotation.typeAnnotation, context);
+    if (carrier === void 0 || /(?:Ids|_ids)$/u.test(identifier.name) && !carrier.endsWith("[]")) continue;
+    const previous = roles.get(carrier);
+    if (previous !== void 0 && previous !== role) {
+      context.report({ node: identifier, messageId: "preferNominalIds" });
+      return;
+    }
+    roles.set(carrier, role);
+  }
+}
+function identifierRole(name) {
+  const match = /^(.*?)(?:Ids?|_ids?)$/u.exec(name);
+  const stem4 = match?.[1];
+  if (stem4 === void 0 || stem4.length === 0) return void 0;
+  const role = stem4.replaceAll("_", "").toLowerCase();
+  return OPERATIONAL_ROLES.has(role) ? void 0 : role;
+}
+function parameterIdentifier(parameter) {
+  if (parameter.type === AST_NODE_TYPES75.Identifier) return parameter;
+  if (parameter.type === AST_NODE_TYPES75.AssignmentPattern && parameter.left.type === AST_NODE_TYPES75.Identifier) return parameter.left;
+  if (parameter.type === AST_NODE_TYPES75.TSParameterProperty) return parameterIdentifier(parameter.parameter);
+  return void 0;
+}
+var prefer_nominal_id_types_default = createRule({
+  name: "prefer-nominal-id-types",
+  documentation: PREFER_NOMINAL_ID_TYPES_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    docs: { description: "Distinguish identifier roles sharing primitive types at callable boundaries." },
+    schema: [],
+    messages: { preferNominalIds: "Distinct identifier roles share an interchangeable primitive type. Use distinct branded identifier types at this callable boundary." }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      ArrowFunctionExpression: (node) => checkBoundary(node, context),
+      FunctionDeclaration: (node) => checkBoundary(node, context),
+      FunctionExpression: (node) => checkBoundary(node, context),
+      TSDeclareFunction: (node) => checkBoundary(node, context),
+      TSEmptyBodyFunctionExpression: (node) => checkBoundary(node, context),
+      TSFunctionType: (node) => checkBoundary(node, context),
+      TSMethodSignature: (node) => checkBoundary(node, context)
+    };
+  }
+});
+
 // src/rules/prefer-named-callback-domain.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES75 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES76 } from "@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.",
@@ -15724,13 +15850,13 @@ var PREFER_NAMED_CALLBACK_DOMAIN_DOCUMENTATION = {
   ]
 };
 function isLiteralUnion(node) {
-  return node.type === AST_NODE_TYPES75.TSUnionType && node.types.length >= 2 && node.types.every((part) => part.type === AST_NODE_TYPES75.TSLiteralType);
+  return node.type === AST_NODE_TYPES76.TSUnionType && node.types.length >= 2 && node.types.every((part) => part.type === AST_NODE_TYPES76.TSLiteralType);
 }
 function exportedContract(node) {
   let current = node;
   while (current !== void 0) {
-    if (current.type === AST_NODE_TYPES75.TSTypeAliasDeclaration || current.type === AST_NODE_TYPES75.TSInterfaceDeclaration) return current.parent.type === AST_NODE_TYPES75.ExportNamedDeclaration;
-    if (current.type === AST_NODE_TYPES75.Program) return false;
+    if (current.type === AST_NODE_TYPES76.TSTypeAliasDeclaration || current.type === AST_NODE_TYPES76.TSInterfaceDeclaration) return current.parent.type === AST_NODE_TYPES76.ExportNamedDeclaration;
+    if (current.type === AST_NODE_TYPES76.Program) return false;
     current = current.parent ?? void 0;
   }
   return false;
@@ -15751,7 +15877,7 @@ var prefer_named_callback_domain_default = createRule({
       TSFunctionType(node) {
         if (!exportedContract(node)) return;
         for (const parameter of node.params) {
-          if (parameter.type !== AST_NODE_TYPES75.TSParameterProperty && parameter.typeAnnotation !== void 0 && isLiteralUnion(parameter.typeAnnotation.typeAnnotation)) {
+          if (parameter.type !== AST_NODE_TYPES76.TSParameterProperty && parameter.typeAnnotation !== void 0 && isLiteralUnion(parameter.typeAnnotation.typeAnnotation)) {
             context.report({ node: parameter.typeAnnotation.typeAnnotation, messageId: "nameCallbackDomain" });
           }
         }
@@ -15761,7 +15887,7 @@ var prefer_named_callback_domain_default = createRule({
 });
 
 // src/rules/prefer-named-complex-return-type.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES76 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES77 } from "@typescript-eslint/utils";
 var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Prefer a named contract for structurally complex function return types.",
@@ -15778,7 +15904,7 @@ var PREFER_NAMED_COMPLEX_RETURN_TYPE_DOCUMENTATION = {
   ]
 };
 function unwrap5(node) {
-  if (node.type === AST_NODE_TYPES76.TSTypeReference && node.typeArguments?.params.length === 1) {
+  if (node.type === AST_NODE_TYPES77.TSTypeReference && node.typeArguments?.params.length === 1) {
     const [inner] = node.typeArguments.params;
     if (inner !== void 0) return unwrap5(inner);
   }
@@ -15792,9 +15918,9 @@ function report(context, node) {
 }
 function isComplex(node) {
   const type = unwrap5(node);
-  if (type.type === AST_NODE_TYPES76.TSTypeLiteral) return type.members.length >= 3;
-  if (type.type !== AST_NODE_TYPES76.TSUnionType || type.types.length < 3) return false;
-  return type.types.every((member) => unwrap5(member).type === AST_NODE_TYPES76.TSTypeLiteral);
+  if (type.type === AST_NODE_TYPES77.TSTypeLiteral) return type.members.length >= 3;
+  if (type.type !== AST_NODE_TYPES77.TSUnionType || type.types.length < 3) return false;
+  return type.types.every((member) => unwrap5(member).type === AST_NODE_TYPES77.TSTypeLiteral);
 }
 var prefer_named_complex_return_type_default = createRule({
   name: "prefer-named-complex-return-type",
@@ -15821,7 +15947,7 @@ var prefer_named_complex_return_type_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils35 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES78, ASTUtils as ASTUtils36 } from "@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.",
@@ -15835,7 +15961,7 @@ var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   ]
 };
 function requireUuid(node) {
-  return node?.type === AST_NODE_TYPES77.CallExpression && node.callee.type === AST_NODE_TYPES77.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES77.Literal && node.arguments[0].value === "uuid";
+  return node?.type === AST_NODE_TYPES78.CallExpression && node.callee.type === AST_NODE_TYPES78.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES78.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -15857,14 +15983,14 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve2(identifier) {
-      return ASTUtils35.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils36.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve2(identifier);
       if (variable !== null) destination.add(variable);
     }
     function report2(node) {
-      const globalBinding = ASTUtils35.findVariable(context.sourceCode.getScope(node), "globalThis");
+      const globalBinding = ASTUtils36.findVariable(context.sourceCode.getScope(node), "globalThis");
       const canSuggest = (globalBinding?.defs.length ?? 0) === 0 && context.sourceCode.getCommentsInside(node).length === 0;
       context.report({
         node,
@@ -15881,37 +16007,37 @@ var prefer_native_random_uuid_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "uuid") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES77.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES77.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === AST_NODE_TYPES78.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES78.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === AST_NODE_TYPES77.ImportNamespaceSpecifier) {
+          } else if (specifier.type === AST_NODE_TYPES78.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== AST_NODE_TYPES77.CallExpression || node.init.callee.type !== AST_NODE_TYPES77.Identifier || (resolve2(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== AST_NODE_TYPES78.CallExpression || node.init.callee.type !== AST_NODE_TYPES78.Identifier || (resolve2(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === AST_NODE_TYPES77.Identifier) {
+        if (node.id.type === AST_NODE_TYPES78.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES77.ObjectPattern) return;
+        if (node.id.type !== AST_NODE_TYPES78.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === AST_NODE_TYPES77.Property && !property.computed && (property.key.type === AST_NODE_TYPES77.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES77.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES77.Identifier) {
+          if (property.type === AST_NODE_TYPES78.Property && !property.computed && (property.key.type === AST_NODE_TYPES78.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES78.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES78.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === AST_NODE_TYPES77.Identifier) {
+        if (node.callee.type === AST_NODE_TYPES78.Identifier) {
           const variable2 = resolve2(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report2(node);
           return;
         }
-        if (node.callee.type !== AST_NODE_TYPES77.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES77.Identifier || node.callee.property.type !== AST_NODE_TYPES77.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== AST_NODE_TYPES78.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES78.Identifier || node.callee.property.type !== AST_NODE_TYPES78.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve2(node.callee.object);
@@ -15922,7 +16048,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-node-crypto-hash.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES78, ASTUtils as ASTUtils36 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES79, ASTUtils as ASTUtils37 } from "@typescript-eslint/utils";
 var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
@@ -15941,33 +16067,33 @@ var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   ]
 };
 function memberName5(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES78.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES78.Literal && typeof node.property.value === "string") {
+  if (!node.computed && node.property.type === AST_NODE_TYPES79.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES79.Literal && typeof node.property.value === "string") {
     return node.property.value;
   }
   return null;
 }
 function isCryptoLoader(node, resolve2) {
-  if (node.type !== AST_NODE_TYPES78.CallExpression || node.arguments.length !== 1) return false;
+  if (node.type !== AST_NODE_TYPES79.CallExpression || node.arguments.length !== 1) return false;
   const [argument] = node.arguments;
-  if (argument === void 0 || argument.type === AST_NODE_TYPES78.SpreadElement || !isCryptoSpecifier(argument)) {
+  if (argument === void 0 || argument.type === AST_NODE_TYPES79.SpreadElement || !isCryptoSpecifier(argument)) {
     return false;
   }
-  if (node.callee.type === AST_NODE_TYPES78.Identifier) {
+  if (node.callee.type === AST_NODE_TYPES79.Identifier) {
     return node.callee.name === "require" && isUnshadowedBuiltinIdentifier(node.callee, resolve2);
   }
-  return node.callee.type === AST_NODE_TYPES78.MemberExpression && node.callee.object.type === AST_NODE_TYPES78.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve2) && memberName5(node.callee) === "getBuiltinModule";
+  return node.callee.type === AST_NODE_TYPES79.MemberExpression && node.callee.object.type === AST_NODE_TYPES79.Identifier && node.callee.object.name === "process" && isUnshadowedBuiltinIdentifier(node.callee.object, resolve2) && memberName5(node.callee) === "getBuiltinModule";
 }
 function isCryptoSpecifier(node) {
-  return node.type === AST_NODE_TYPES78.Literal && (node.value === "crypto" || node.value === "node:crypto");
+  return node.type === AST_NODE_TYPES79.Literal && (node.value === "crypto" || node.value === "node:crypto");
 }
 function isUnshadowedBuiltinIdentifier(identifier, resolve2) {
   const variable = resolve2(identifier);
   return variable === null || variable.defs.length === 0;
 }
 function propertyName3(node) {
-  if (!node.computed && node.key.type === AST_NODE_TYPES78.Identifier) return node.key.name;
-  if (node.key.type === AST_NODE_TYPES78.Literal && typeof node.key.value === "string") {
+  if (!node.computed && node.key.type === AST_NODE_TYPES79.Identifier) return node.key.name;
+  if (node.key.type === AST_NODE_TYPES79.Literal && typeof node.key.value === "string") {
     return node.key.value;
   }
   return null;
@@ -15981,7 +16107,7 @@ var prefer_node_crypto_hash_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve2(identifier) {
-      return ASTUtils36.findVariable(
+      return ASTUtils37.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -15994,9 +16120,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 === AST_NODE_TYPES78.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES78.ImportDefaultSpecifier) {
+          if (specifier.type === AST_NODE_TYPES79.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES79.ImportDefaultSpecifier) {
             record(specifier.local, namespaceBindings);
-          } else if (specifier.type === AST_NODE_TYPES78.ImportSpecifier && importedName6(specifier.imported) === "createHash") {
+          } else if (specifier.type === AST_NODE_TYPES79.ImportSpecifier && importedName6(specifier.imported) === "createHash") {
             record(specifier.local, directBindings);
           }
         }
@@ -16005,13 +16131,13 @@ var prefer_node_crypto_hash_default = createRule({
         if (node.parent.kind !== "const" || node.init === null || !isCryptoLoader(node.init, resolve2)) {
           return;
         }
-        if (node.id.type === AST_NODE_TYPES78.Identifier) {
+        if (node.id.type === AST_NODE_TYPES79.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES78.ObjectPattern) return;
+        if (node.id.type !== AST_NODE_TYPES79.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === AST_NODE_TYPES78.Property && propertyName3(property) === "createHash" && property.value.type === AST_NODE_TYPES78.Identifier) {
+          if (property.type === AST_NODE_TYPES79.Property && propertyName3(property) === "createHash" && property.value.type === AST_NODE_TYPES79.Identifier) {
             record(property.value, directBindings);
           }
         }
@@ -16019,10 +16145,10 @@ var prefer_node_crypto_hash_default = createRule({
       CallExpression(node) {
         if (!isMemberCall(node, "digest")) return;
         const update = node.callee.object;
-        if (update.type !== AST_NODE_TYPES78.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
+        if (update.type !== AST_NODE_TYPES79.CallExpression || update.arguments.length !== 1 || !isMemberCall(update, "update"))
           return;
         const create = update.callee.object;
-        if (create.type !== AST_NODE_TYPES78.CallExpression || create.arguments.length !== 1 || create.arguments[0]?.type !== AST_NODE_TYPES78.Literal || typeof create.arguments[0].value !== "string" || !isCreateHashCall(
+        if (create.type !== AST_NODE_TYPES79.CallExpression || create.arguments.length !== 1 || create.arguments[0]?.type !== AST_NODE_TYPES79.Literal || typeof create.arguments[0].value !== "string" || !isCreateHashCall(
           create,
           directBindings,
           namespaceBindings,
@@ -16035,27 +16161,27 @@ var prefer_node_crypto_hash_default = createRule({
   }
 });
 function importedName6(node) {
-  return node.type === AST_NODE_TYPES78.Identifier ? node.name : node.value;
+  return node.type === AST_NODE_TYPES79.Identifier ? node.name : node.value;
 }
 function isMemberCall(node, name) {
-  return node.callee.type === AST_NODE_TYPES78.MemberExpression && memberName5(node.callee) === name;
+  return node.callee.type === AST_NODE_TYPES79.MemberExpression && memberName5(node.callee) === name;
 }
 function isCreateHashCall(node, directBindings, namespaceBindings, resolve2) {
-  if (node.callee.type === AST_NODE_TYPES78.Identifier) {
+  if (node.callee.type === AST_NODE_TYPES79.Identifier) {
     const variable2 = resolve2(node.callee);
     return variable2 !== null && directBindings.has(variable2);
   }
-  if (node.callee.type !== AST_NODE_TYPES78.MemberExpression || memberName5(node.callee) !== "createHash") {
+  if (node.callee.type !== AST_NODE_TYPES79.MemberExpression || memberName5(node.callee) !== "createHash") {
     return false;
   }
   if (isCryptoLoader(node.callee.object, resolve2)) return true;
-  if (node.callee.object.type !== AST_NODE_TYPES78.Identifier) return false;
+  if (node.callee.object.type !== AST_NODE_TYPES79.Identifier) return false;
   const variable = resolve2(node.callee.object);
   return variable !== null && namespaceBindings.has(variable);
 }
 
 // src/rules/prefer-node-fs-promises.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES79, ASTUtils as ASTUtils37 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES80, ASTUtils as ASTUtils38 } from "@typescript-eslint/utils";
 var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Prefer promise-based Node.js filesystem APIs over synchronous calls in production modules.",
@@ -16074,30 +16200,30 @@ var PREFER_NODE_FS_PROMISES_DOCUMENTATION = {
   ]
 };
 function memberName6(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES79.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES79.Literal && typeof node.property.value === "string") {
+  if (!node.computed && node.property.type === AST_NODE_TYPES80.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES80.Literal && typeof node.property.value === "string") {
     return node.property.value;
   }
   return null;
 }
 function unwrapAwait2(node) {
-  return node.type === AST_NODE_TYPES79.AwaitExpression ? node.argument : node;
+  return node.type === AST_NODE_TYPES80.AwaitExpression ? node.argument : node;
 }
 function isFsLoader(node, isGlobal) {
   const expression = unwrapAwait2(node);
-  if (expression.type === AST_NODE_TYPES79.ImportExpression) return isFsSpecifier(expression.source);
-  if (expression.type !== AST_NODE_TYPES79.CallExpression || expression.arguments.length !== 1) return false;
+  if (expression.type === AST_NODE_TYPES80.ImportExpression) return isFsSpecifier(expression.source);
+  if (expression.type !== AST_NODE_TYPES80.CallExpression || expression.arguments.length !== 1) return false;
   const [argument] = expression.arguments;
-  if (argument === void 0 || argument.type === AST_NODE_TYPES79.SpreadElement || !isFsSpecifier(argument)) return false;
-  if (expression.callee.type === AST_NODE_TYPES79.Identifier) return expression.callee.name === "require" && isGlobal(expression.callee);
-  return expression.callee.type === AST_NODE_TYPES79.MemberExpression && expression.callee.object.type === AST_NODE_TYPES79.Identifier && expression.callee.object.name === "process" && isGlobal(expression.callee.object) && memberName6(expression.callee) === "getBuiltinModule";
+  if (argument === void 0 || argument.type === AST_NODE_TYPES80.SpreadElement || !isFsSpecifier(argument)) return false;
+  if (expression.callee.type === AST_NODE_TYPES80.Identifier) return expression.callee.name === "require" && isGlobal(expression.callee);
+  return expression.callee.type === AST_NODE_TYPES80.MemberExpression && expression.callee.object.type === AST_NODE_TYPES80.Identifier && expression.callee.object.name === "process" && isGlobal(expression.callee.object) && memberName6(expression.callee) === "getBuiltinModule";
 }
 function isFsSpecifier(node) {
-  return node.type === AST_NODE_TYPES79.Literal && (node.value === "node:fs" || node.value === "fs");
+  return node.type === AST_NODE_TYPES80.Literal && (node.value === "node:fs" || node.value === "fs");
 }
 function propertyName4(node) {
-  if (!node.computed && node.key.type === AST_NODE_TYPES79.Identifier) return node.key.name;
-  if (node.key.type === AST_NODE_TYPES79.Literal && typeof node.key.value === "string") return node.key.value;
+  if (!node.computed && node.key.type === AST_NODE_TYPES80.Identifier) return node.key.name;
+  if (node.key.type === AST_NODE_TYPES80.Literal && typeof node.key.value === "string") return node.key.value;
   return null;
 }
 var prefer_node_fs_promises_default = createRule({
@@ -16117,7 +16243,7 @@ var prefer_node_fs_promises_default = createRule({
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text) || normalizedFilename.includes("src/rules/"))
       return {};
     const namespaces = /* @__PURE__ */ new Set();
-    const bindingOf = (node) => ASTUtils37.findVariable(context.sourceCode.getScope(node), node.name);
+    const bindingOf = (node) => ASTUtils38.findVariable(context.sourceCode.getScope(node), node.name);
     const isGlobal = (node) => {
       const binding = bindingOf(node);
       return binding === null || binding.defs.length === 0;
@@ -16135,11 +16261,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 === AST_NODE_TYPES79.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES79.ImportDefaultSpecifier) {
+          if (specifier.type === AST_NODE_TYPES80.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES80.ImportDefaultSpecifier) {
             recordNamespace(specifier.local);
             continue;
           }
-          if (specifier.type === AST_NODE_TYPES79.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES79.Identifier && specifier.imported.name.endsWith("Sync")) synchronousImports.push(specifier.imported.name);
+          if (specifier.type === AST_NODE_TYPES80.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES80.Identifier && specifier.imported.name.endsWith("Sync")) synchronousImports.push(specifier.imported.name);
         }
         if (synchronousImports.length > 0) {
           context.report({
@@ -16150,15 +16276,15 @@ var prefer_node_fs_promises_default = createRule({
         }
       },
       VariableDeclarator(node) {
-        if (node.init === null || !isFsLoader(node.init, isGlobal) && (node.init.type !== AST_NODE_TYPES79.Identifier || !isNamespace(node.init)))
+        if (node.init === null || !isFsLoader(node.init, isGlobal) && (node.init.type !== AST_NODE_TYPES80.Identifier || !isNamespace(node.init)))
           return;
-        if (node.id.type === AST_NODE_TYPES79.Identifier) {
+        if (node.id.type === AST_NODE_TYPES80.Identifier) {
           recordNamespace(node.id);
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES79.ObjectPattern) return;
+        if (node.id.type !== AST_NODE_TYPES80.ObjectPattern) return;
         const synchronousImports = node.id.properties.flatMap((property) => {
-          if (property.type !== AST_NODE_TYPES79.Property) return [];
+          if (property.type !== AST_NODE_TYPES80.Property) return [];
           const name = propertyName4(property);
           return name?.endsWith("Sync") === true ? [name] : [];
         });
@@ -16174,7 +16300,7 @@ var prefer_node_fs_promises_default = createRule({
         const name = memberName6(node);
         if (name?.endsWith("Sync") !== true) return;
         const object = unwrapAwait2(node.object);
-        if (object.type === AST_NODE_TYPES79.Identifier && isNamespace(object) || isFsLoader(object, isGlobal)) {
+        if (object.type === AST_NODE_TYPES80.Identifier && isNamespace(object) || isFsLoader(object, isGlobal)) {
           context.report({ node, messageId: "preferAsyncFs", data: { name } });
         }
       }
@@ -16183,7 +16309,7 @@ var prefer_node_fs_promises_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES80, ASTUtils as ASTUtils38 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES81, ASTUtils as ASTUtils39 } from "@typescript-eslint/utils";
 var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   summary: "Suggest reviewing nullish arrays that use local empty-array defaults or a shared null-or-empty guard.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -16199,33 +16325,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 === AST_NODE_TYPES80.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES80.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES81.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES81.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function isArrayType(node) {
-  if (node.type === AST_NODE_TYPES80.TSArrayType) return true;
-  return node.type === AST_NODE_TYPES80.TSTypeReference && node.typeName.type === AST_NODE_TYPES80.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === AST_NODE_TYPES81.TSArrayType) return true;
+  return node.type === AST_NODE_TYPES81.TSTypeReference && node.typeName.type === AST_NODE_TYPES81.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 !== AST_NODE_TYPES80.TSUnionType) return null;
+  if (name === null || annotation?.type !== AST_NODE_TYPES81.TSUnionType) return null;
   const concrete = annotation.types.filter(
-    (member) => member.type !== AST_NODE_TYPES80.TSNullKeyword && member.type !== AST_NODE_TYPES80.TSUndefinedKeyword
+    (member) => member.type !== AST_NODE_TYPES81.TSNullKeyword && member.type !== AST_NODE_TYPES81.TSUndefinedKeyword
   );
   if (concrete.length === 0 || !concrete.every(isArrayType)) return null;
-  const acceptsNull = annotation.types.some((member) => member.type === AST_NODE_TYPES80.TSNullKeyword);
+  const acceptsNull = annotation.types.some((member) => member.type === AST_NODE_TYPES81.TSNullKeyword);
   const acceptsUndefined = annotation.types.some(
-    (member) => member.type === AST_NODE_TYPES80.TSUndefinedKeyword
+    (member) => member.type === AST_NODE_TYPES81.TSUndefinedKeyword
   );
   if (!acceptsNull && !acceptsUndefined) return null;
   return { name, node, acceptsNull, acceptsUndefined };
 }
 function shapeProperties(members) {
   return members.flatMap((member) => {
-    if (member.type !== AST_NODE_TYPES80.TSPropertySignature) return [];
+    if (member.type !== AST_NODE_TYPES81.TSPropertySignature) return [];
     const property = nullableProperty(member);
     return property === null ? [] : [property];
   });
@@ -16233,14 +16359,14 @@ function shapeProperties(members) {
 function typeIndex(program) {
   const index = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const exported = statement.type === AST_NODE_TYPES80.ExportNamedDeclaration;
+    const exported = statement.type === AST_NODE_TYPES81.ExportNamedDeclaration;
     const declaration = exported ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES80.TSInterfaceDeclaration) {
+    if (declaration?.type === AST_NODE_TYPES81.TSInterfaceDeclaration) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.body.body)
       });
-    } else if (declaration?.type === AST_NODE_TYPES80.TSTypeAliasDeclaration && declaration.typeAnnotation.type === AST_NODE_TYPES80.TSTypeLiteral) {
+    } else if (declaration?.type === AST_NODE_TYPES81.TSTypeAliasDeclaration && declaration.typeAnnotation.type === AST_NODE_TYPES81.TSTypeLiteral) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.typeAnnotation.members)
@@ -16250,45 +16376,45 @@ function typeIndex(program) {
   return index;
 }
 function emptyArray(node) {
-  return node.type === AST_NODE_TYPES80.ArrayExpression && node.elements.length === 0;
+  return node.type === AST_NODE_TYPES81.ArrayExpression && node.elements.length === 0;
 }
 function sameAccess(node, access) {
   if (access.kind === "identifier") {
-    return node.type === AST_NODE_TYPES80.Identifier && node.name === access.name;
+    return node.type === AST_NODE_TYPES81.Identifier && node.name === access.name;
   }
-  return node.type === AST_NODE_TYPES80.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES80.Identifier && node.object.name === access.object && node.property.type === AST_NODE_TYPES80.Identifier && node.property.name === access.property;
+  return node.type === AST_NODE_TYPES81.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES81.Identifier && node.object.name === access.object && node.property.type === AST_NODE_TYPES81.Identifier && node.property.name === access.property;
 }
 function memberLengthOf(node, access) {
-  const target = node.type === AST_NODE_TYPES80.ChainExpression ? node.expression : node;
-  return target.type === AST_NODE_TYPES80.MemberExpression && !target.computed && target.property.type === AST_NODE_TYPES80.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+  const target = node.type === AST_NODE_TYPES81.ChainExpression ? node.expression : node;
+  return target.type === AST_NODE_TYPES81.MemberExpression && !target.computed && target.property.type === AST_NODE_TYPES81.Identifier && target.property.name === "length" && sameAccess(target.object, access);
 }
 function optionalMemberLengthOf(node, access) {
-  return node.type === AST_NODE_TYPES80.ChainExpression && node.expression.type === AST_NODE_TYPES80.MemberExpression && node.expression.optional && memberLengthOf(node, access);
+  return node.type === AST_NODE_TYPES81.ChainExpression && node.expression.type === AST_NODE_TYPES81.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
-  if (fn.body.type !== AST_NODE_TYPES80.BlockStatement) return false;
+  if (fn.body.type !== AST_NODE_TYPES81.BlockStatement) return false;
   const first = fn.body.body[0];
-  if (first?.type !== AST_NODE_TYPES80.IfStatement) return false;
-  const terminating = first.consequent.type === AST_NODE_TYPES80.ReturnStatement || first.consequent.type === AST_NODE_TYPES80.ThrowStatement || first.consequent.type === AST_NODE_TYPES80.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === AST_NODE_TYPES80.ReturnStatement || first.consequent.body[0]?.type === AST_NODE_TYPES80.ThrowStatement);
+  if (first?.type !== AST_NODE_TYPES81.IfStatement) return false;
+  const terminating = first.consequent.type === AST_NODE_TYPES81.ReturnStatement || first.consequent.type === AST_NODE_TYPES81.ThrowStatement || first.consequent.type === AST_NODE_TYPES81.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === AST_NODE_TYPES81.ReturnStatement || first.consequent.body[0]?.type === AST_NODE_TYPES81.ThrowStatement);
   if (!terminating) return false;
   if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
-  if (first.test.type === AST_NODE_TYPES80.UnaryExpression && first.test.operator === "!" && optionalMemberLengthOf(first.test.argument, access)) return true;
-  return first.test.type === AST_NODE_TYPES80.LogicalExpression && first.test.operator === "||" && isNullGuard(first.test.left, access) && isEmptyGuard(first.test.right, access);
+  if (first.test.type === AST_NODE_TYPES81.UnaryExpression && first.test.operator === "!" && optionalMemberLengthOf(first.test.argument, access)) return true;
+  return first.test.type === AST_NODE_TYPES81.LogicalExpression && first.test.operator === "||" && isNullGuard(first.test.left, access) && isEmptyGuard(first.test.right, access);
 }
 function isNullGuard(node, access) {
-  if (node.type === AST_NODE_TYPES80.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
-  if (node.type !== AST_NODE_TYPES80.BinaryExpression || !["==", "==="].includes(node.operator)) {
+  if (node.type === AST_NODE_TYPES81.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
+  if (node.type !== AST_NODE_TYPES81.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
-  const nullish = (value) => value.type === AST_NODE_TYPES80.Literal && value.value === null || value.type === AST_NODE_TYPES80.Identifier && value.name === "undefined";
+  const nullish = (value) => value.type === AST_NODE_TYPES81.Literal && value.value === null || value.type === AST_NODE_TYPES81.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 === AST_NODE_TYPES80.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
-  if (node.type !== AST_NODE_TYPES80.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
+  if (node.type === AST_NODE_TYPES81.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
+  if (node.type !== AST_NODE_TYPES81.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
     return false;
   }
-  const zero = (value) => value.type === AST_NODE_TYPES80.Literal && value.value === 0;
+  const zero = (value) => value.type === AST_NODE_TYPES81.Literal && value.value === 0;
   return memberLengthOf(node.left, access) && zero(node.right) || node.operator !== "<=" && memberLengthOf(node.right, access) && zero(node.left);
 }
 function contains(node, visitorKeys, predicate) {
@@ -16298,30 +16424,30 @@ function contains(node, visitorKeys, predicate) {
 function belongsToFunction(node, fn) {
   let current = node;
   while (current !== void 0 && current !== fn) {
-    if (current !== node && (current.type === AST_NODE_TYPES80.ArrowFunctionExpression || current.type === AST_NODE_TYPES80.FunctionDeclaration || current.type === AST_NODE_TYPES80.FunctionExpression)) return false;
+    if (current !== node && (current.type === AST_NODE_TYPES81.ArrowFunctionExpression || current.type === AST_NODE_TYPES81.FunctionDeclaration || current.type === AST_NODE_TYPES81.FunctionExpression)) return false;
     current = current.parent;
   }
   return current === fn;
 }
 function directlyCoalesced(node) {
   const parent = node.parent;
-  return parent?.type === AST_NODE_TYPES80.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
+  return parent?.type === AST_NODE_TYPES81.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = ASTUtils38.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = ASTUtils39.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 = ASTUtils38.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = ASTUtils39.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 === AST_NODE_TYPES80.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === AST_NODE_TYPES80.Identifier && parent.property.name === property) return [parent];
-    return parent?.type === AST_NODE_TYPES80.MemberExpression && parent.object === reference.identifier ? [] : [null];
+    if (parent?.type === AST_NODE_TYPES81.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === AST_NODE_TYPES81.Identifier && parent.property.name === property) return [parent];
+    return parent?.type === AST_NODE_TYPES81.MemberExpression && parent.object === reference.identifier ? [] : [null];
   });
   return accesses.length > 0 && accesses.every((access) => access !== null && directlyCoalesced(access));
 }
@@ -16346,8 +16472,8 @@ var prefer_non_nullable_collection_default = createRule({
     let shapes = /* @__PURE__ */ new Map();
     const evidence = /* @__PURE__ */ new Map();
     function propertiesFor(annotation) {
-      if (annotation?.type === AST_NODE_TYPES80.TSTypeLiteral) return shapeProperties(annotation.members);
-      if (annotation?.type === AST_NODE_TYPES80.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES80.Identifier) {
+      if (annotation?.type === AST_NODE_TYPES81.TSTypeLiteral) return shapeProperties(annotation.members);
+      if (annotation?.type === AST_NODE_TYPES81.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES81.Identifier) {
         const shape = shapes.get(annotation.typeName.name);
         return shape?.exported === false ? shape.properties : [];
       }
@@ -16360,13 +16486,13 @@ var prefer_non_nullable_collection_default = createRule({
     }
     function checkFunction(fn) {
       function checkParameter(rawParameter) {
-        const parameter = rawParameter.type === AST_NODE_TYPES80.AssignmentPattern ? rawParameter.left : rawParameter;
-        if (parameter.type === AST_NODE_TYPES80.ObjectPattern) {
+        const parameter = rawParameter.type === AST_NODE_TYPES81.AssignmentPattern ? rawParameter.left : rawParameter;
+        if (parameter.type === AST_NODE_TYPES81.ObjectPattern) {
           const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
           checkDestructuredProperties(parameter, properties2);
           return;
         }
-        if (parameter.type !== AST_NODE_TYPES80.Identifier) return;
+        if (parameter.type !== AST_NODE_TYPES81.Identifier) return;
         const properties = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
         for (const property of properties) {
           const access = {
@@ -16383,16 +16509,16 @@ var prefer_non_nullable_collection_default = createRule({
       function checkDestructuredProperties(parameter, properties) {
         for (const property of properties) {
           const bindingProperty = parameter.properties.find(
-            (entry) => entry.type === AST_NODE_TYPES80.Property && !entry.computed && entry.key.type === AST_NODE_TYPES80.Identifier && entry.key.name === property.name
+            (entry) => entry.type === AST_NODE_TYPES81.Property && !entry.computed && entry.key.type === AST_NODE_TYPES81.Identifier && entry.key.name === property.name
           );
           if (bindingProperty === void 0) continue;
           const value = bindingProperty.value;
-          const binding = value.type === AST_NODE_TYPES80.AssignmentPattern ? value.left : value;
-          if (binding.type !== AST_NODE_TYPES80.Identifier) {
+          const binding = value.type === AST_NODE_TYPES81.AssignmentPattern ? value.left : value;
+          if (binding.type !== AST_NODE_TYPES81.Identifier) {
             record(property, false);
             continue;
           }
-          if (value.type === AST_NODE_TYPES80.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
+          if (value.type === AST_NODE_TYPES81.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
             record(property, true);
             continue;
           }
@@ -16430,8 +16556,8 @@ var prefer_non_nullable_collection_default = createRule({
 
 // src/rules/prefer-nullish-filter-predicate.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES81,
-  ASTUtils as ASTUtils39,
+  AST_NODE_TYPES as AST_NODE_TYPES82,
+  ASTUtils as ASTUtils40,
   ESLintUtils as ESLintUtils11
 } from "@typescript-eslint/utils";
 import ts9 from "typescript";
@@ -16477,7 +16603,7 @@ var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   ]
 };
 function isUnshadowedBoolean(node, context) {
-  const variable = ASTUtils39.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = ASTUtils40.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isBuiltinArrayFilter(node, services) {
@@ -16536,7 +16662,7 @@ function isProvablyTruthy(type, checker) {
 }
 function availableParameterName(node, context) {
   for (const name of ["value", "item", "element", "candidate"]) {
-    if (ASTUtils39.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+    if (ASTUtils40.findVariable(context.sourceCode.getScope(node), name) === null) return name;
   }
   return null;
 }
@@ -16567,7 +16693,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 !== AST_NODE_TYPES81.Identifier || callback.name !== "Boolean" || callee.type !== AST_NODE_TYPES81.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES81.Identifier || callee.property.name !== "filter" || !isUnshadowedBoolean(callback, context) || !isBuiltinArrayFilter(callee, services)) return;
+        if (node.arguments.length !== 1 || callback?.type !== AST_NODE_TYPES82.Identifier || callback.name !== "Boolean" || callee.type !== AST_NODE_TYPES82.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES82.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;
@@ -16590,9 +16716,9 @@ var prefer_nullish_filter_predicate_default = createRule({
 
 // src/rules/prefer-await-in-async-return.ts
 import {
-  ASTUtils as ASTUtils40,
+  ASTUtils as ASTUtils41,
   ESLintUtils as ESLintUtils12,
-  AST_NODE_TYPES as AST_NODE_TYPES82
+  AST_NODE_TYPES as AST_NODE_TYPES83
 } from "@typescript-eslint/utils";
 import * as ts10 from "typescript";
 var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
@@ -16635,10 +16761,10 @@ var PREFER_AWAIT_IN_ASYNC_RETURN_DOCUMENTATION = {
 };
 function directAsyncReturnOwner(node) {
   const parent = node.parent;
-  if (parent.type === AST_NODE_TYPES82.ArrowFunctionExpression && parent.body === node) {
+  if (parent.type === AST_NODE_TYPES83.ArrowFunctionExpression && parent.body === node) {
     return parent.async && !parent.generator ? parent : null;
   }
-  if (parent.type !== AST_NODE_TYPES82.ReturnStatement || parent.argument !== node) {
+  if (parent.type !== AST_NODE_TYPES83.ReturnStatement || parent.argument !== node) {
     return null;
   }
   let owner = parent.parent;
@@ -16648,15 +16774,15 @@ function directAsyncReturnOwner(node) {
   return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
-  return node.type === AST_NODE_TYPES82.ArrowFunctionExpression || node.type === AST_NODE_TYPES82.FunctionDeclaration || node.type === AST_NODE_TYPES82.FunctionExpression;
+  return node.type === AST_NODE_TYPES83.ArrowFunctionExpression || node.type === AST_NODE_TYPES83.FunctionDeclaration || node.type === AST_NODE_TYPES83.FunctionExpression;
 }
 function promiseThenReceiver(node) {
   const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES82.MemberExpression || callee.computed || callee.optional || callee.property.type !== AST_NODE_TYPES82.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
+  if (callee.type !== AST_NODE_TYPES83.MemberExpression || callee.computed || callee.optional || callee.property.type !== AST_NODE_TYPES83.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
     return null;
   }
   const callback = node.arguments[0];
-  if (callback === void 0 || callback.type !== AST_NODE_TYPES82.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES82.FunctionExpression) {
+  if (callback === void 0 || callback.type !== AST_NODE_TYPES83.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES83.FunctionExpression) {
     return null;
   }
   return callee.object;
@@ -16704,25 +16830,25 @@ var prefer_await_in_async_return_default = createRule({
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = ASTUtils40.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils41.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
-      if (parent.type !== AST_NODE_TYPES82.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES82.Identifier) return false;
-      const variable = ASTUtils40.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      if (parent.type !== AST_NODE_TYPES83.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES83.Identifier) return false;
+      const variable = ASTUtils41.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 === AST_NODE_TYPES82.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES82.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
+            if (specifier.type === AST_NODE_TYPES83.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES83.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 === AST_NODE_TYPES82.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+            if (specifier.type === AST_NODE_TYPES83.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
           }
         }
       },
@@ -16740,7 +16866,7 @@ var prefer_await_in_async_return_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES83, ASTUtils as ASTUtils41 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES84, ASTUtils as ASTUtils42 } from "@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.",
@@ -16760,9 +16886,9 @@ var PREFER_SCHEMA_FOR_API_PAYLOAD_DOCUMENTATION = {
 var unwrap6 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === AST_NODE_TYPES83.TSAsExpression || current.type === AST_NODE_TYPES83.TSTypeAssertion || current.type === AST_NODE_TYPES83.TSNonNullExpression || current.type === AST_NODE_TYPES83.TSSatisfiesExpression) {
+    if (current.type === AST_NODE_TYPES84.TSAsExpression || current.type === AST_NODE_TYPES84.TSTypeAssertion || current.type === AST_NODE_TYPES84.TSNonNullExpression || current.type === AST_NODE_TYPES84.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === AST_NODE_TYPES83.ChainExpression) {
+    } else if (current.type === AST_NODE_TYPES84.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -16777,23 +16903,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap6(node);
-  return inner !== null && inner.type === AST_NODE_TYPES83.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES83.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === AST_NODE_TYPES84.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES84.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node, context, isKnownLocalText) => {
   let current = unwrap6(node);
   if (current === null) return false;
-  if (current.type === AST_NODE_TYPES83.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES84.AwaitExpression) {
     current = unwrap6(current.argument);
   }
-  if (current === null || current.type !== AST_NODE_TYPES83.CallExpression) {
+  if (current === null || current.type !== AST_NODE_TYPES84.CallExpression) {
     return false;
   }
   const callee = unwrap6(current.callee);
-  if (callee === null || callee.type !== AST_NODE_TYPES83.MemberExpression) {
+  if (callee === null || callee.type !== AST_NODE_TYPES84.MemberExpression) {
     return false;
   }
   const property = unwrap6(callee.property);
-  if (property === null || property.type !== AST_NODE_TYPES83.Identifier) {
+  if (property === null || property.type !== AST_NODE_TYPES84.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -16804,34 +16930,34 @@ var isRawPayloadSource = (node, context, isKnownLocalText) => {
   }
   const object = unwrap6(callee.object);
   const input = unwrap6(current.arguments[0]);
-  if (input?.type === AST_NODE_TYPES83.CallExpression && input.arguments.length === 1 && input.callee.type === AST_NODE_TYPES83.MemberExpression && !input.callee.computed && input.callee.object.type === AST_NODE_TYPES83.Identifier && input.callee.object.name === "JSON" && input.callee.property.type === AST_NODE_TYPES83.Identifier && input.callee.property.name === "stringify" && (ASTUtils41.findVariable(context.sourceCode.getScope(input.callee.object), "JSON")?.defs.length ?? 0) === 0) return false;
-  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES83.Identifier && object.name === "JSON" && (ASTUtils41.findVariable(context.sourceCode.getScope(object), "JSON")?.defs.length ?? 0) === 0 && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
+  if (input?.type === AST_NODE_TYPES84.CallExpression && input.arguments.length === 1 && input.callee.type === AST_NODE_TYPES84.MemberExpression && !input.callee.computed && input.callee.object.type === AST_NODE_TYPES84.Identifier && input.callee.object.name === "JSON" && input.callee.property.type === AST_NODE_TYPES84.Identifier && input.callee.property.name === "stringify" && (ASTUtils42.findVariable(context.sourceCode.getScope(input.callee.object), "JSON")?.defs.length ?? 0) === 0) return false;
+  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES84.Identifier && object.name === "JSON" && (ASTUtils42.findVariable(context.sourceCode.getScope(object), "JSON")?.defs.length ?? 0) === 0 && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var isResponseSource = (node, context, seen = /* @__PURE__ */ new Set()) => {
   let current = unwrap6(node);
-  if (current?.type === AST_NODE_TYPES83.AwaitExpression) current = unwrap6(current.argument);
+  if (current?.type === AST_NODE_TYPES84.AwaitExpression) current = unwrap6(current.argument);
   if (current === null || seen.has(current)) return false;
   seen.add(current);
-  const isGlobal = (identifier) => (ASTUtils41.findVariable(context.sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
-  if (current.type === AST_NODE_TYPES83.CallExpression) return current.callee.type === AST_NODE_TYPES83.Identifier && current.callee.name === "fetch" && isGlobal(current.callee);
-  if (current.type === AST_NODE_TYPES83.NewExpression) return current.callee.type === AST_NODE_TYPES83.Identifier && ["Request", "Response"].includes(current.callee.name) && isGlobal(current.callee);
-  if (current.type !== AST_NODE_TYPES83.Identifier) return false;
-  const binding = ASTUtils41.findVariable(context.sourceCode.getScope(current), current.name);
+  const isGlobal = (identifier) => (ASTUtils42.findVariable(context.sourceCode.getScope(identifier), identifier.name)?.defs.length ?? 0) === 0;
+  if (current.type === AST_NODE_TYPES84.CallExpression) return current.callee.type === AST_NODE_TYPES84.Identifier && current.callee.name === "fetch" && isGlobal(current.callee);
+  if (current.type === AST_NODE_TYPES84.NewExpression) return current.callee.type === AST_NODE_TYPES84.Identifier && ["Request", "Response"].includes(current.callee.name) && isGlobal(current.callee);
+  if (current.type !== AST_NODE_TYPES84.Identifier) return false;
+  const binding = ASTUtils42.findVariable(context.sourceCode.getScope(current), current.name);
   if (binding?.defs.length !== 1 || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
   const definition = binding.defs[0];
-  const annotation = definition?.name.type === AST_NODE_TYPES83.Identifier ? definition.name.typeAnnotation?.typeAnnotation : void 0;
-  if (annotation?.type === AST_NODE_TYPES83.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES83.Identifier && ["Request", "Response"].includes(annotation.typeName.name) && isGlobal(annotation.typeName)) return true;
+  const annotation = definition?.name.type === AST_NODE_TYPES84.Identifier ? definition.name.typeAnnotation?.typeAnnotation : void 0;
+  if (annotation?.type === AST_NODE_TYPES84.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES84.Identifier && ["Request", "Response"].includes(annotation.typeName.name) && isGlobal(annotation.typeName)) return true;
   return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init !== null && isResponseSource(definition.node.init, context, seen);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isDirectLocalFileRead = (node) => {
   let current = unwrap6(node);
-  if (current?.type === AST_NODE_TYPES83.AwaitExpression) {
+  if (current?.type === AST_NODE_TYPES84.AwaitExpression) {
     current = unwrap6(current.argument);
   }
-  if (current?.type !== AST_NODE_TYPES83.CallExpression) return false;
+  if (current?.type !== AST_NODE_TYPES84.CallExpression) return false;
   const callee = unwrap6(current.callee);
-  const name = callee?.type === AST_NODE_TYPES83.Identifier ? callee.name : callee?.type === AST_NODE_TYPES83.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES83.Identifier ? callee.property.name : null;
+  const name = callee?.type === AST_NODE_TYPES84.Identifier ? callee.name : callee?.type === AST_NODE_TYPES84.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES84.Identifier ? callee.property.name : null;
   return name !== null && FILE_READ_RE.test(name);
 };
 var isLocalFileRead = (node) => {
@@ -16853,15 +16979,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== AST_NODE_TYPES83.CallExpression) continue;
+    if (current.type !== AST_NODE_TYPES84.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === AST_NODE_TYPES83.MemberExpression) {
+    while (callee.type === AST_NODE_TYPES84.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === AST_NODE_TYPES83.CallExpression) {
+    if (callee.type === AST_NODE_TYPES84.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === AST_NODE_TYPES83.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === AST_NODE_TYPES84.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -16880,22 +17006,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 === AST_NODE_TYPES83.TSAsExpression || parent.type === AST_NODE_TYPES83.TSTypeAssertion || parent.type === AST_NODE_TYPES83.TSNonNullExpression || parent.type === AST_NODE_TYPES83.TSSatisfiesExpression || parent.type === AST_NODE_TYPES83.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === AST_NODE_TYPES84.TSAsExpression || parent.type === AST_NODE_TYPES84.TSTypeAssertion || parent.type === AST_NODE_TYPES84.TSNonNullExpression || parent.type === AST_NODE_TYPES84.TSSatisfiesExpression || parent.type === AST_NODE_TYPES84.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === AST_NODE_TYPES83.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === AST_NODE_TYPES84.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== AST_NODE_TYPES83.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== AST_NODE_TYPES84.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === AST_NODE_TYPES83.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES83.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES83.Identifier && callee.property.name === "isArray") {
+  if (callee.type === AST_NODE_TYPES84.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES84.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES84.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === AST_NODE_TYPES83.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === AST_NODE_TYPES84.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "bigint",
@@ -16906,13 +17032,13 @@ var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "undefined"
 ]);
 var bindingValidationPolarity = (test, bindingName) => {
-  if (test.type === AST_NODE_TYPES83.UnaryExpression && test.operator === "!") {
+  if (test.type === AST_NODE_TYPES84.UnaryExpression && test.operator === "!") {
     const inner = bindingValidationPolarity(test.argument, bindingName);
     return invertValidationPolarity(inner);
   }
-  if (test.type === AST_NODE_TYPES83.BinaryExpression) {
-    const typeofName = (node) => node.type === AST_NODE_TYPES83.UnaryExpression && node.operator === "typeof" && node.argument.type === AST_NODE_TYPES83.Identifier ? node.argument.name : null;
-    const literalType = (node) => node.type === AST_NODE_TYPES83.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+  if (test.type === AST_NODE_TYPES84.BinaryExpression) {
+    const typeofName = (node) => node.type === AST_NODE_TYPES84.UnaryExpression && node.operator === "typeof" && node.argument.type === AST_NODE_TYPES84.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === AST_NODE_TYPES84.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 === "==") {
@@ -16920,9 +17046,9 @@ var bindingValidationPolarity = (test, bindingName) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === AST_NODE_TYPES83.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === AST_NODE_TYPES83.Identifier && test.arguments[0].name === bindingName && test.callee.type === AST_NODE_TYPES83.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES83.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES83.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === AST_NODE_TYPES84.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === AST_NODE_TYPES84.Identifier && test.arguments[0].name === bindingName && test.callee.type === AST_NODE_TYPES84.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES84.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES84.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
-var plainMemberAccess = (node) => node.type === AST_NODE_TYPES83.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES83.Identifier && node.property.type === AST_NODE_TYPES83.Identifier ? { object: node.object.name, property: node.property.name } : null;
+var plainMemberAccess = (node) => node.type === AST_NODE_TYPES84.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES84.Identifier && node.property.type === AST_NODE_TYPES84.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;
@@ -16930,19 +17056,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 === AST_NODE_TYPES83.ConditionalExpression) {
+    if (current.type === AST_NODE_TYPES84.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 === AST_NODE_TYPES83.IfStatement) {
+    if (current.type === AST_NODE_TYPES84.IfStatement) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (validatedBranchContains(node, current, polarity)) {
         return true;
       }
     }
-    if (current.type === AST_NODE_TYPES83.FunctionDeclaration || current.type === AST_NODE_TYPES83.FunctionExpression || current.type === AST_NODE_TYPES83.ArrowFunctionExpression) {
+    if (current.type === AST_NODE_TYPES84.FunctionDeclaration || current.type === AST_NODE_TYPES84.FunctionExpression || current.type === AST_NODE_TYPES84.ArrowFunctionExpression) {
       return false;
     }
   }
@@ -16950,32 +17076,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 === AST_NODE_TYPES83.ConditionalExpression) {
+    if (current.type === AST_NODE_TYPES84.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 === AST_NODE_TYPES83.IfStatement) {
+    if (current.type === AST_NODE_TYPES84.IfStatement) {
       const polarity = memberValidationPolarity(current.test, access);
       if (validatedBranchContains(node, current, polarity)) {
         return true;
       }
     }
-    if (current.type === AST_NODE_TYPES83.FunctionDeclaration || current.type === AST_NODE_TYPES83.FunctionExpression || current.type === AST_NODE_TYPES83.ArrowFunctionExpression) {
+    if (current.type === AST_NODE_TYPES84.FunctionDeclaration || current.type === AST_NODE_TYPES84.FunctionExpression || current.type === AST_NODE_TYPES84.ArrowFunctionExpression) {
       return false;
     }
   }
   return false;
 };
 var memberValidationPolarity = (test, access) => {
-  if (test.type === AST_NODE_TYPES83.UnaryExpression && test.operator === "!") {
+  if (test.type === AST_NODE_TYPES84.UnaryExpression && test.operator === "!") {
     const inner = memberValidationPolarity(test.argument, access);
     return invertValidationPolarity(inner);
   }
-  if (test.type === AST_NODE_TYPES83.BinaryExpression) {
-    const isMatchingTypeof = (node) => node.type === AST_NODE_TYPES83.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === AST_NODE_TYPES83.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+  if (test.type === AST_NODE_TYPES84.BinaryExpression) {
+    const isMatchingTypeof = (node) => node.type === AST_NODE_TYPES84.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
+    const isPrimitiveType = (node) => node.type === AST_NODE_TYPES84.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;
     }
@@ -16984,15 +17110,15 @@ var memberValidationPolarity = (test, access) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === AST_NODE_TYPES83.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== AST_NODE_TYPES83.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === AST_NODE_TYPES83.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES83.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES83.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === AST_NODE_TYPES84.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== AST_NODE_TYPES84.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === AST_NODE_TYPES84.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES84.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES84.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 === AST_NODE_TYPES83.BinaryExpression || current.type === AST_NODE_TYPES83.CallExpression || current.type === AST_NODE_TYPES83.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+      if ((current.type === AST_NODE_TYPES84.BinaryExpression || current.type === AST_NODE_TYPES84.CallExpression || current.type === AST_NODE_TYPES84.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
         return true;
       }
-      if (current.type !== AST_NODE_TYPES83.UnaryExpression && current.type !== AST_NODE_TYPES83.MemberExpression && current.type !== AST_NODE_TYPES83.CallExpression) {
+      if (current.type !== AST_NODE_TYPES84.UnaryExpression && current.type !== AST_NODE_TYPES84.MemberExpression && current.type !== AST_NODE_TYPES84.CallExpression) {
         return false;
       }
     }
@@ -17000,7 +17126,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   };
   const isGuardedUse = (identifier) => isUseWithinValidatedBranch(identifier, identifier.name);
   const declarator = member.parent;
-  if (declarator.type !== AST_NODE_TYPES83.VariableDeclarator || declarator.init !== member || declarator.id.type !== AST_NODE_TYPES83.Identifier || declarator.parent.type !== AST_NODE_TYPES83.VariableDeclaration || declarator.parent.kind !== "const") {
+  if (declarator.type !== AST_NODE_TYPES84.VariableDeclarator || declarator.init !== member || declarator.id.type !== AST_NODE_TYPES84.Identifier || declarator.parent.type !== AST_NODE_TYPES84.VariableDeclaration || declarator.parent.kind !== "const") {
     return false;
   }
   const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
@@ -17008,7 +17134,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   let hasValueUse = false;
   for (const reference of extracted.references) {
     const identifier = reference.identifier;
-    if (identifier.type !== AST_NODE_TYPES83.Identifier) return false;
+    if (identifier.type !== AST_NODE_TYPES84.Identifier) return false;
     if (nodeWithin2(identifier, declarator)) continue;
     if (isValidationReference(identifier)) continue;
     hasValueUse = true;
@@ -17021,17 +17147,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case AST_NODE_TYPES83.UnaryExpression:
-      case AST_NODE_TYPES83.LogicalExpression:
-      case AST_NODE_TYPES83.ChainExpression:
+      case AST_NODE_TYPES84.UnaryExpression:
+      case AST_NODE_TYPES84.LogicalExpression:
+      case AST_NODE_TYPES84.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case AST_NODE_TYPES83.IfStatement:
-      case AST_NODE_TYPES83.ConditionalExpression:
-      case AST_NODE_TYPES83.WhileStatement:
-      case AST_NODE_TYPES83.DoWhileStatement:
-      case AST_NODE_TYPES83.ForStatement:
+      case AST_NODE_TYPES84.IfStatement:
+      case AST_NODE_TYPES84.ConditionalExpression:
+      case AST_NODE_TYPES84.WhileStatement:
+      case AST_NODE_TYPES84.DoWhileStatement:
+      case AST_NODE_TYPES84.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -17041,7 +17167,7 @@ var isGuardTestPosition = (node) => {
 };
 var unvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap6(node);
-  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES83.Identifier) {
+  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES84.Identifier) {
     return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -17073,24 +17199,24 @@ var prefer_schema_for_api_payload_default = createRule({
       if (context.sourceCode.getScope(use).variableScope !== context.sourceCode.getScope(call).variableScope) return false;
       let guard = call;
       let positive = true;
-      while (guard.parent.type === AST_NODE_TYPES83.UnaryExpression && guard.parent.operator === "!") {
+      while (guard.parent.type === AST_NODE_TYPES84.UnaryExpression && guard.parent.operator === "!") {
         positive = !positive;
         guard = guard.parent;
       }
-      while (positive && guard.parent.type === AST_NODE_TYPES83.LogicalExpression && guard.parent.operator === "&&") guard = guard.parent;
+      while (positive && guard.parent.type === AST_NODE_TYPES84.LogicalExpression && guard.parent.operator === "&&") guard = guard.parent;
       const branch = guard.parent;
-      if (branch.type === AST_NODE_TYPES83.IfStatement && branch.test === guard) {
+      if (branch.type === AST_NODE_TYPES84.IfStatement && branch.test === guard) {
         const dominated = ifGuardDominates(use, branch, positive);
         if (dominated !== null) return dominated;
       }
-      if (branch.type === AST_NODE_TYPES83.ConditionalExpression && branch.test === guard) return nodeWithin2(use, positive ? branch.consequent : branch.alternate);
-      if (positive && branch.type === AST_NODE_TYPES83.WhileStatement && branch.test === guard) return nodeWithin2(use, branch.body);
-      if (call.parent.type !== AST_NODE_TYPES83.ExpressionStatement || call.callee.type !== AST_NODE_TYPES83.Identifier || /^(?:is|has)[A-Z]/u.test(call.callee.name)) return false;
+      if (branch.type === AST_NODE_TYPES84.ConditionalExpression && branch.test === guard) return nodeWithin2(use, positive ? branch.consequent : branch.alternate);
+      if (positive && branch.type === AST_NODE_TYPES84.WhileStatement && branch.test === guard) return nodeWithin2(use, branch.body);
+      if (call.parent.type !== AST_NODE_TYPES84.ExpressionStatement || call.callee.type !== AST_NODE_TYPES84.Identifier || /^(?:is|has)[A-Z]/u.test(call.callee.name)) return false;
       return followsInSameContainer(use, call.parent);
     };
     const localFileTextRef = (node, scope) => {
       const unwrapped = unwrap6(node);
-      if (unwrapped?.type !== AST_NODE_TYPES83.Identifier) return null;
+      if (unwrapped?.type !== AST_NODE_TYPES84.Identifier) return null;
       const variable = findVariable2(scope, unwrapped.name);
       return variable !== null && localFileTextVariables.has(variable) ? variable : null;
     };
@@ -17142,19 +17268,19 @@ var prefer_schema_for_api_payload_default = createRule({
       const statement = declarator.parent;
       const block = statement.parent;
       const followsRejectingGuard = (identifier) => {
-        if (block.type !== AST_NODE_TYPES83.BlockStatement && block.type !== AST_NODE_TYPES83.Program) return false;
+        if (block.type !== AST_NODE_TYPES84.BlockStatement && block.type !== AST_NODE_TYPES84.Program) return false;
         if (context.sourceCode.getScope(identifier).variableScope !== context.sourceCode.getScope(declarator).variableScope) return false;
         return block.body.some((candidate2) => {
-          if (candidate2.type !== AST_NODE_TYPES83.IfStatement || candidate2.range[1] >= identifier.range[0] || bindingValidationPolarity(candidate2.test, identifier.name) !== "valid-when-false") return false;
-          const terminal = candidate2.consequent.type === AST_NODE_TYPES83.BlockStatement ? candidate2.consequent.body.at(-1) : candidate2.consequent;
-          return terminal?.type === AST_NODE_TYPES83.ThrowStatement || terminal?.type === AST_NODE_TYPES83.ReturnStatement;
+          if (candidate2.type !== AST_NODE_TYPES84.IfStatement || candidate2.range[1] >= identifier.range[0] || bindingValidationPolarity(candidate2.test, identifier.name) !== "valid-when-false") return false;
+          const terminal = candidate2.consequent.type === AST_NODE_TYPES84.BlockStatement ? candidate2.consequent.body.at(-1) : candidate2.consequent;
+          return terminal?.type === AST_NODE_TYPES84.ThrowStatement || terminal?.type === AST_NODE_TYPES84.ReturnStatement;
         });
       };
       return declared.length > 0 && declared.every(
         (variable) => variable.references.some((reference) => isValidationRead(reference.identifier)) && variable.references.every((reference) => {
           const identifier = reference.identifier;
           if (reference.init === true) return true;
-          if (reference.isWrite() || identifier.type !== AST_NODE_TYPES83.Identifier) return false;
+          if (reference.isWrite() || identifier.type !== AST_NODE_TYPES84.Identifier) return false;
           return isValidationRead(identifier) || isUseWithinValidatedBranch(identifier, identifier.name) || followsRejectingGuard(identifier);
         })
       );
@@ -17174,7 +17300,7 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === AST_NODE_TYPES83.Identifier) {
+        if (node.id.type === AST_NODE_TYPES84.Identifier) {
           const variable = context.sourceCode.getDeclaredVariables(node)[0];
           if (variable !== void 0) {
             updateLocalFileText(variable, node.init, scope);
@@ -17182,7 +17308,7 @@ var prefer_schema_for_api_payload_default = createRule({
           trackInitializer(node, scope);
           return;
         }
-        if (node.id.type === AST_NODE_TYPES83.ObjectPattern || node.id.type === AST_NODE_TYPES83.ArrayPattern) {
+        if (node.id.type === AST_NODE_TYPES84.ObjectPattern || node.id.type === AST_NODE_TYPES84.ArrayPattern) {
           if (isRawPayloadSource(
             node.init,
             context,
@@ -17200,7 +17326,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === AST_NODE_TYPES83.Identifier) {
+        if (node.left.type === AST_NODE_TYPES84.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           const isLocalText = (candidate2) => localFileTextRef(candidate2, scope) !== null;
@@ -17214,7 +17340,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === AST_NODE_TYPES83.ObjectPattern || node.left.type === AST_NODE_TYPES83.ArrayPattern) {
+        if (node.left.type === AST_NODE_TYPES84.ObjectPattern || node.left.type === AST_NODE_TYPES84.ArrayPattern) {
           if (isRawPayloadSource(
             node.right,
             context,
@@ -17235,15 +17361,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES83.Identifier) return;
+        if (node.callee.type !== AST_NODE_TYPES84.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === AST_NODE_TYPES83.SpreadElement) continue;
+          if (arg.type === AST_NODE_TYPES84.SpreadElement) continue;
           const unwrapped = unwrap6(arg);
-          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES83.Identifier) {
+          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES84.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -17267,14 +17393,14 @@ var prefer_schema_for_api_payload_default = createRule({
           (candidate2) => localFileTextRef(candidate2, scope) !== null
         )) {
           const parent = node.parent;
-          if (parent.type === AST_NODE_TYPES83.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES83.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === AST_NODE_TYPES84.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES84.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 === AST_NODE_TYPES83.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
-        if (variable !== null && obj?.type === AST_NODE_TYPES83.Identifier) {
+        const variable = obj?.type === AST_NODE_TYPES84.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null && obj?.type === AST_NODE_TYPES84.Identifier) {
           if (namedGuards.get(variable)?.some((call) => guardDominates(node, call))) return;
           if (isUseWithinValidatedBranch(node, obj.name)) {
             return;
@@ -17302,8 +17428,8 @@ function validatedBranchContains(node, branch, polarity) {
 }
 function followsInSameContainer(use, preceding) {
   let statement = use;
-  while (statement.parent !== void 0 && statement.parent !== preceding.parent && statement.parent.type !== AST_NODE_TYPES83.Program) {
-    if (statement.type === AST_NODE_TYPES83.FunctionDeclaration || statement.type === AST_NODE_TYPES83.FunctionExpression || statement.type === AST_NODE_TYPES83.ArrowFunctionExpression) return false;
+  while (statement.parent !== void 0 && statement.parent !== preceding.parent && statement.parent.type !== AST_NODE_TYPES84.Program) {
+    if (statement.type === AST_NODE_TYPES84.FunctionDeclaration || statement.type === AST_NODE_TYPES84.FunctionExpression || statement.type === AST_NODE_TYPES84.ArrowFunctionExpression) return false;
     statement = statement.parent;
   }
   return statement.parent === preceding.parent && statement.range[0] > preceding.range[1];
@@ -17311,15 +17437,15 @@ function followsInSameContainer(use, preceding) {
 function ifGuardDominates(use, branch, positive) {
   if (positive && nodeWithin2(use, branch.consequent)) return true;
   if (!positive && branch.alternate !== null && nodeWithin2(use, branch.alternate)) return true;
-  const terminal = branch.consequent.type === AST_NODE_TYPES83.BlockStatement ? branch.consequent.body.at(-1) : branch.consequent;
-  if (!positive && (terminal?.type === AST_NODE_TYPES83.ThrowStatement || terminal?.type === AST_NODE_TYPES83.ReturnStatement)) {
+  const terminal = branch.consequent.type === AST_NODE_TYPES84.BlockStatement ? branch.consequent.body.at(-1) : branch.consequent;
+  if (!positive && (terminal?.type === AST_NODE_TYPES84.ThrowStatement || terminal?.type === AST_NODE_TYPES84.ReturnStatement)) {
     return followsInSameContainer(use, branch);
   }
   return null;
 }
 
 // src/rules/prefer-shared-zod-enum.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES84, ASTUtils as ASTUtils42 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES85, ASTUtils as ASTUtils43 } from "@typescript-eslint/utils";
 var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Give repeated literal Zod enum domains one reusable module-level schema.",
@@ -17335,24 +17461,24 @@ var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
 function literalDomain(node) {
   if (node.arguments.length !== 1) return null;
   const [argument] = node.arguments;
-  if (argument?.type !== AST_NODE_TYPES84.ArrayExpression || argument.elements.length < 2) return null;
+  if (argument?.type !== AST_NODE_TYPES85.ArrayExpression || argument.elements.length < 2) return null;
   const values = [];
   for (const element of argument.elements) {
-    if (element?.type !== AST_NODE_TYPES84.Literal || typeof element.value !== "string") return null;
+    if (element?.type !== AST_NODE_TYPES85.Literal || typeof element.value !== "string") return null;
     values.push(element.value);
   }
   return values;
 }
 function isModuleLevelNamedSchema(node) {
   let current = node;
-  while (current.parent?.type === AST_NODE_TYPES84.MemberExpression && current.parent.object === current) {
+  while (current.parent?.type === AST_NODE_TYPES85.MemberExpression && current.parent.object === current) {
     current = current.parent;
-    if (current.parent?.type === AST_NODE_TYPES84.CallExpression && current.parent.callee === current) current = current.parent;
+    if (current.parent?.type === AST_NODE_TYPES85.CallExpression && current.parent.callee === current) current = current.parent;
   }
   const declarator = current.parent;
-  if (declarator?.type !== AST_NODE_TYPES84.VariableDeclarator || declarator.init !== current || declarator.id.type !== AST_NODE_TYPES84.Identifier || declarator.parent.type !== AST_NODE_TYPES84.VariableDeclaration) return false;
+  if (declarator?.type !== AST_NODE_TYPES85.VariableDeclarator || declarator.init !== current || declarator.id.type !== AST_NODE_TYPES85.Identifier || declarator.parent.type !== AST_NODE_TYPES85.VariableDeclaration) return false;
   const declarationParent = declarator.parent.parent;
-  return declarationParent.type === AST_NODE_TYPES84.Program || declarationParent.type === AST_NODE_TYPES84.ExportNamedDeclaration && declarationParent.parent.type === AST_NODE_TYPES84.Program;
+  return declarationParent.type === AST_NODE_TYPES85.Program || declarationParent.type === AST_NODE_TYPES85.ExportNamedDeclaration && declarationParent.parent.type === AST_NODE_TYPES85.Program;
 }
 var prefer_shared_zod_enum_default = createRule({
   name: "prefer-shared-zod-enum",
@@ -17369,20 +17495,20 @@ var prefer_shared_zod_enum_default = createRule({
   create(context) {
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     const zodBindings = /* @__PURE__ */ new Set();
-    const bindingOf = (node) => ASTUtils42.findVariable(context.sourceCode.getScope(node), node.name);
+    const bindingOf = (node) => ASTUtils43.findVariable(context.sourceCode.getScope(node), node.name);
     const candidates = /* @__PURE__ */ new Map();
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES84.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES84.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES84.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES84.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === AST_NODE_TYPES85.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES85.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES85.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES85.Identifier && specifier.imported.name === "z") {
             const binding = bindingOf(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES84.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES84.Identifier || node.callee.property.type !== AST_NODE_TYPES84.Identifier || node.callee.property.name !== "enum") return;
+        if (node.callee.type !== AST_NODE_TYPES85.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES85.Identifier || node.callee.property.type !== AST_NODE_TYPES85.Identifier || node.callee.property.name !== "enum") return;
         const binding = bindingOf(node.callee.object);
         if (binding === null || !zodBindings.has(binding)) return;
         const domain = literalDomain(node);
@@ -17407,7 +17533,7 @@ var prefer_shared_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-switch-for-repeated-equality.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES85 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES86 } from "@typescript-eslint/utils";
 var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Prefer switch over long if/else-if chains that compare one value for strict equality.",
@@ -17426,18 +17552,18 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   ]
 };
 function discriminantText(sourceCode, test) {
-  if (test.type !== AST_NODE_TYPES85.BinaryExpression || test.operator !== "===") return null;
+  if (test.type !== AST_NODE_TYPES86.BinaryExpression || test.operator !== "===") return null;
   const leftIsCase = isCaseValue(test.left);
   const rightIsCase = isCaseValue(test.right);
   if (leftIsCase === rightIsCase) return null;
   const discriminant = leftIsCase ? test.right : test.left;
-  return discriminant.type === AST_NODE_TYPES85.Identifier ? sourceCode.getText(discriminant) : null;
+  return discriminant.type === AST_NODE_TYPES86.Identifier ? sourceCode.getText(discriminant) : null;
 }
 function isCaseValue(node) {
-  if (node.type === AST_NODE_TYPES85.Literal) return true;
-  if (node.type === AST_NODE_TYPES85.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
-  if (node.type !== AST_NODE_TYPES85.MemberExpression || node.computed) return false;
-  return node.property.type === AST_NODE_TYPES85.Identifier && (node.object.type === AST_NODE_TYPES85.Identifier || isCaseValue(node.object));
+  if (node.type === AST_NODE_TYPES86.Literal) return true;
+  if (node.type === AST_NODE_TYPES86.Identifier) return /^[A-Z][A-Z0-9_]*$/u.test(node.name);
+  if (node.type !== AST_NODE_TYPES86.MemberExpression || node.computed) return false;
+  return node.property.type === AST_NODE_TYPES86.Identifier && (node.object.type === AST_NODE_TYPES86.Identifier || isCaseValue(node.object));
 }
 var prefer_switch_for_repeated_equality_default = createRule({
   name: "prefer-switch-for-repeated-equality",
@@ -17454,12 +17580,12 @@ var prefer_switch_for_repeated_equality_default = createRule({
   create(context) {
     return {
       IfStatement(node) {
-        if (node.parent.type === AST_NODE_TYPES85.IfStatement && node.parent.alternate === node) return;
+        if (node.parent.type === AST_NODE_TYPES86.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 === AST_NODE_TYPES85.IfStatement) {
+        while (current?.type === AST_NODE_TYPES86.IfStatement) {
           if (discriminantText(context.sourceCode, current.test) !== first) return;
           count += 1;
           current = current.alternate;
@@ -17473,7 +17599,7 @@ var prefer_switch_for_repeated_equality_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES86 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES87 } from "@typescript-eslint/utils";
 import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname2, join as join2, parse } from "path";
 var PREFER_SEMANTIC_COLORS_DOCUMENTATION = {
@@ -17583,7 +17709,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 === AST_NODE_TYPES86.JSXElement) {
+    if (current.type === AST_NODE_TYPES87.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -17593,8 +17719,8 @@ var isInsideSvg = (node) => {
 };
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === AST_NODE_TYPES86.JSXIdentifier) return name.name;
-  if (name.type === AST_NODE_TYPES86.JSXMemberExpression && name.property.type === AST_NODE_TYPES86.JSXIdentifier) {
+  if (name.type === AST_NODE_TYPES87.JSXIdentifier) return name.name;
+  if (name.type === AST_NODE_TYPES87.JSXMemberExpression && name.property.type === AST_NODE_TYPES87.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -17626,7 +17752,7 @@ function isSvgLikeElementName(name) {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === AST_NODE_TYPES86.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES86.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES86.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES86.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === AST_NODE_TYPES87.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES87.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES87.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES87.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -17758,12 +17884,12 @@ var expandWorkspaceGlob = (root, glob) => {
   return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => join2(parent, entry.name));
 };
 var propName = (key) => {
-  if (key.type === AST_NODE_TYPES86.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES86.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES87.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES87.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsExternalRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== AST_NODE_TYPES86.ImportDeclaration && statement.type !== AST_NODE_TYPES86.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES86.ExportAllDeclaration) {
+  if (statement.type !== AST_NODE_TYPES87.ImportDeclaration && statement.type !== AST_NODE_TYPES87.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES87.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(statement.source.value);
@@ -17888,25 +18014,25 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node, objectKeys = false) => {
       if (node === null) return;
       switch (node.type) {
-        case AST_NODE_TYPES86.Literal:
+        case AST_NODE_TYPES87.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case AST_NODE_TYPES86.TemplateLiteral:
+        case AST_NODE_TYPES87.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case AST_NODE_TYPES86.ArrayExpression:
+        case AST_NODE_TYPES87.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== AST_NODE_TYPES86.SpreadElement) checkClassNode(element, objectKeys);
+            if (element !== null && element.type !== AST_NODE_TYPES87.SpreadElement) checkClassNode(element, objectKeys);
           }
           break;
-        case AST_NODE_TYPES86.ObjectExpression:
+        case AST_NODE_TYPES87.ObjectExpression:
           checkClassProperties(node, objectKeys);
           break;
-        case AST_NODE_TYPES86.ConditionalExpression:
+        case AST_NODE_TYPES87.ConditionalExpression:
           checkClassNode(node.consequent, objectKeys);
           checkClassNode(node.alternate, objectKeys);
           break;
-        case AST_NODE_TYPES86.LogicalExpression:
+        case AST_NODE_TYPES87.LogicalExpression:
           checkClassNode(node.right, objectKeys);
           break;
         default:
@@ -17915,10 +18041,10 @@ var prefer_semantic_colors_default = createRule({
     };
     function checkClassProperties(node, objectKeys) {
       for (const property of node.properties) {
-        if (property.type !== AST_NODE_TYPES86.Property) continue;
+        if (property.type !== AST_NODE_TYPES87.Property) continue;
         if (objectKeys) {
-          if (property.value.type === AST_NODE_TYPES86.Literal && !property.value.value && !("regex" in property.value)) continue;
-          if (!property.computed && property.key.type === AST_NODE_TYPES86.Literal) {
+          if (property.value.type === AST_NODE_TYPES87.Literal && !property.value.value && !("regex" in property.value)) continue;
+          if (!property.computed && property.key.type === AST_NODE_TYPES87.Literal) {
             checkClassNode(property.key);
           }
         } else {
@@ -17927,34 +18053,34 @@ var prefer_semantic_colors_default = createRule({
       }
     }
     const checkColorValueNode = (node) => {
-      if (node.type === AST_NODE_TYPES86.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value.replace(/url\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/giu, "")) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === AST_NODE_TYPES87.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value.replace(/url\(\s*(?:"[^"]*"|'[^']*'|[^)]*)\s*\)/giu, "")) && !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 === AST_NODE_TYPES86.Literal) checkClassNode(node.value);
-        else if (node.value.type === AST_NODE_TYPES86.JSXExpressionContainer) {
-          if (node.value.expression.type !== AST_NODE_TYPES86.JSXEmptyExpression) {
+        if (node.value.type === AST_NODE_TYPES87.Literal) checkClassNode(node.value);
+        else if (node.value.type === AST_NODE_TYPES87.JSXExpressionContainer) {
+          if (node.value.expression.type !== AST_NODE_TYPES87.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES86.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES86.Literal && typeof node.arguments[0].value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === AST_NODE_TYPES87.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES87.Literal && typeof node.arguments[0].value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.arguments[0].value)) {
           importsExternalRenderer = true;
         }
-        if (node.callee.type === AST_NODE_TYPES86.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === AST_NODE_TYPES87.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== AST_NODE_TYPES86.SpreadElement) {
+            if (arg.type !== AST_NODE_TYPES87.SpreadElement) {
               checkClassNode(arg, node.callee.name !== "cva" && node.callee.name !== "tv");
             }
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES86.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === AST_NODE_TYPES87.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -17964,9 +18090,9 @@ var prefer_semantic_colors_default = createRule({
       },
       // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== AST_NODE_TYPES86.Literal) return;
+        if (node.value?.type !== AST_NODE_TYPES87.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === AST_NODE_TYPES86.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === AST_NODE_TYPES87.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -17980,7 +18106,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES86.Literal && typeof node.source.value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === AST_NODE_TYPES87.Literal && typeof node.source.value === "string" && EXTERNAL_RENDERER_MODULE_RE.test(node.source.value)) {
           importsExternalRenderer = true;
         }
       },
@@ -18000,7 +18126,7 @@ function packageWorkspaceGlobs(parsed) {
 }
 
 // src/rules/prefer-server-actions.ts
-import { ASTUtils as ASTUtils43 } from "@typescript-eslint/utils";
+import { ASTUtils as ASTUtils44 } from "@typescript-eslint/utils";
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
   summary: "Prefer Next.js Server Actions over same-origin API mutations.",
   rationale: "Server Actions can remove a hand-written internal API wrapper while retaining typed application calls. Client invocations still cross a network and serialization boundary.",
@@ -18032,7 +18158,7 @@ function resolvesToGlobalFetch(context, identifier) {
 function resolveNode(node, context) {
   if (!node) return null;
   if (node.type !== "Identifier") return node;
-  const variable = ASTUtils43.findVariable(getScope(context, node), node.name);
+  const variable = ASTUtils44.findVariable(getScope(context, node), node.name);
   const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
   if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || variable?.references.some((reference) => reference.isWrite() && reference.init !== true)) return node;
   if (definition.node.init.type === "ObjectExpression" && variable?.references.some((reference) => reference.identifier !== node && reference.init !== true)) return node;
@@ -18041,7 +18167,7 @@ function resolveNode(node, context) {
 function isAxiosClient(node, context, seen = /* @__PURE__ */ new Set()) {
   if (node.type !== "Identifier" || seen.has(node)) return false;
   seen.add(node);
-  const variable = ASTUtils43.findVariable(getScope(context, node), node.name);
+  const variable = ASTUtils44.findVariable(getScope(context, node), node.name);
   const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
   if (definition === void 0 || variable?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
   if (variable?.references.some((reference) => {
@@ -18256,7 +18382,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES87, ASTUtils as ASTUtils44 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES88, ASTUtils as ASTUtils45 } from "@typescript-eslint/utils";
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
@@ -18283,11 +18409,11 @@ var PREFER_WHOLE_OBJECT_ASSERTION_DOCUMENTATION = {
 };
 function literalText(node, getText) {
   switch (node.type) {
-    case AST_NODE_TYPES87.Literal:
+    case AST_NODE_TYPES88.Literal:
       return "regex" in node ? null : getText(node);
-    case AST_NODE_TYPES87.TemplateLiteral:
+    case AST_NODE_TYPES88.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case AST_NODE_TYPES87.UnaryExpression:
+    case AST_NODE_TYPES88.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -18295,15 +18421,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case AST_NODE_TYPES87.Identifier:
-    case AST_NODE_TYPES87.ThisExpression:
+    case AST_NODE_TYPES88.Identifier:
+    case AST_NODE_TYPES88.ThisExpression:
       return true;
-    case AST_NODE_TYPES87.MemberExpression:
+    case AST_NODE_TYPES88.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === AST_NODE_TYPES87.Literal && isPureReceiver(node.object);
+        return node.property.type === AST_NODE_TYPES88.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -18311,7 +18437,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== AST_NODE_TYPES87.Literal || typeof node.value !== "number") {
+  if (node.type !== AST_NODE_TYPES88.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -18319,8 +18445,8 @@ function literalIndex(node) {
 function propertyAccess(node) {
   const path = [];
   let current = node;
-  while (current.type === AST_NODE_TYPES87.MemberExpression && !current.computed && !current.optional) {
-    if (current.property.type !== AST_NODE_TYPES87.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+  while (current.type === AST_NODE_TYPES88.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== AST_NODE_TYPES88.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
     path.unshift(current.property.name);
     current = current.object;
   }
@@ -18347,25 +18473,25 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== AST_NODE_TYPES87.ExpressionStatement) {
+      if (statement.type !== AST_NODE_TYPES88.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== AST_NODE_TYPES87.CallExpression) {
+      if (call.type !== AST_NODE_TYPES88.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== AST_NODE_TYPES87.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES87.Identifier) {
+      if (callee.type !== AST_NODE_TYPES88.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES88.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== AST_NODE_TYPES87.CallExpression || expectCall.callee.type !== AST_NODE_TYPES87.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== AST_NODE_TYPES88.CallExpression || expectCall.callee.type !== AST_NODE_TYPES88.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
       if (!isTestExpect(expectCall.callee)) return null;
-      if (actual === void 0 || actual.type !== AST_NODE_TYPES87.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== AST_NODE_TYPES88.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -18397,7 +18523,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES87.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES88.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -18411,12 +18537,12 @@ var prefer_whole_object_assertion_default = createRule({
       };
     }
     function isTestExpect(callee) {
-      const variable = ASTUtils44.findVariable(sourceCode.getScope(callee), callee.name);
+      const variable = ASTUtils45.findVariable(sourceCode.getScope(callee), callee.name);
       if (variable !== null && variable.defs.some((definition) => {
-        if (definition.node.type !== AST_NODE_TYPES87.ImportSpecifier) return true;
+        if (definition.node.type !== AST_NODE_TYPES88.ImportSpecifier) return true;
         const declaration = definition.node.parent;
         const imported = definition.node.imported;
-        return declaration.type !== AST_NODE_TYPES87.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === AST_NODE_TYPES87.Identifier ? imported.name : imported.value) !== "expect";
+        return declaration.type !== AST_NODE_TYPES88.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === AST_NODE_TYPES88.Identifier ? imported.name : imported.value) !== "expect";
       })) return false;
       return true;
     }
@@ -18541,7 +18667,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES88, ASTUtils as ASTUtils45 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES89, ASTUtils as ASTUtils46 } from "@typescript-eslint/utils";
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Review three or more consecutive static-input call assertions as potential named cases.",
   rationale: "Copy-pasted cases obscure the input table, and a thrown assertion can stop later cases from being reported.",
@@ -18562,67 +18688,67 @@ var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
 function staticMemberName6(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES88.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES88.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === AST_NODE_TYPES89.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES89.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function importedName7(identifier, context, modules) {
-  const variable = ASTUtils45.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = ASTUtils46.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 !== AST_NODE_TYPES88.ImportSpecifier) continue;
+    if (definition.node.type !== AST_NODE_TYPES89.ImportSpecifier) continue;
     const declaration = definition.node.parent;
-    if (declaration.type !== AST_NODE_TYPES88.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
+    if (declaration.type !== AST_NODE_TYPES89.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     const imported = definition.node.imported;
-    return imported.type === AST_NODE_TYPES88.Identifier ? imported.name : String(imported.value);
+    return imported.type === AST_NODE_TYPES89.Identifier ? imported.name : String(imported.value);
   }
   return null;
 }
 function isDirectTestCallback2(node, context) {
-  if (node.type !== AST_NODE_TYPES88.ArrowFunctionExpression && node.type !== AST_NODE_TYPES88.FunctionExpression) return false;
+  if (node.type !== AST_NODE_TYPES89.ArrowFunctionExpression && node.type !== AST_NODE_TYPES89.FunctionExpression) return false;
   const call = node.parent;
-  if (call?.type !== AST_NODE_TYPES88.CallExpression || !call.arguments.includes(node)) return false;
+  if (call?.type !== AST_NODE_TYPES89.CallExpression || !call.arguments.includes(node)) return false;
   const root = testRoot2(call.callee);
   return root !== null && TEST_NAMES2.has(importedName7(root, context, TEST_MODULES4) ?? "");
 }
 function testRoot2(callee) {
-  if (callee.type === AST_NODE_TYPES88.Identifier) return callee;
-  if (callee.type !== AST_NODE_TYPES88.MemberExpression) return null;
+  if (callee.type === AST_NODE_TYPES89.Identifier) return callee;
+  if (callee.type !== AST_NODE_TYPES89.MemberExpression) return null;
   const modifier = staticMemberName6(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
-  if (node.type === AST_NODE_TYPES88.TSAsExpression || node.type === AST_NODE_TYPES88.TSTypeAssertion || node.type === AST_NODE_TYPES88.TSSatisfiesExpression || node.type === AST_NODE_TYPES88.TSNonNullExpression) return isStatic(node.expression);
+  if (node.type === AST_NODE_TYPES89.TSAsExpression || node.type === AST_NODE_TYPES89.TSTypeAssertion || node.type === AST_NODE_TYPES89.TSSatisfiesExpression || node.type === AST_NODE_TYPES89.TSNonNullExpression) return isStatic(node.expression);
   switch (node.type) {
-    case AST_NODE_TYPES88.Literal:
+    case AST_NODE_TYPES89.Literal:
       return true;
-    case AST_NODE_TYPES88.TemplateLiteral:
+    case AST_NODE_TYPES89.TemplateLiteral:
       return node.expressions.length === 0;
-    case AST_NODE_TYPES88.UnaryExpression:
+    case AST_NODE_TYPES89.UnaryExpression:
       return (node.operator === "+" || node.operator === "-") && isStatic(node.argument);
-    case AST_NODE_TYPES88.ArrayExpression:
-      return node.elements.every((item) => item !== null && item.type !== AST_NODE_TYPES88.SpreadElement && isStatic(item));
-    case AST_NODE_TYPES88.ObjectExpression:
-      return node.properties.every((property) => property.type === AST_NODE_TYPES88.Property && !property.computed && property.kind === "init" && property.value.type !== AST_NODE_TYPES88.AssignmentPattern && isStatic(property.value));
+    case AST_NODE_TYPES89.ArrayExpression:
+      return node.elements.every((item) => item !== null && item.type !== AST_NODE_TYPES89.SpreadElement && isStatic(item));
+    case AST_NODE_TYPES89.ObjectExpression:
+      return node.properties.every((property) => property.type === AST_NODE_TYPES89.Property && !property.computed && property.kind === "init" && property.value.type !== AST_NODE_TYPES89.AssignmentPattern && isStatic(property.value));
     default:
       return false;
   }
 }
 function staticShape(node) {
-  if (node.type === AST_NODE_TYPES88.TSAsExpression || node.type === AST_NODE_TYPES88.TSTypeAssertion || node.type === AST_NODE_TYPES88.TSSatisfiesExpression || node.type === AST_NODE_TYPES88.TSNonNullExpression) return staticShape(node.expression);
+  if (node.type === AST_NODE_TYPES89.TSAsExpression || node.type === AST_NODE_TYPES89.TSTypeAssertion || node.type === AST_NODE_TYPES89.TSSatisfiesExpression || node.type === AST_NODE_TYPES89.TSNonNullExpression) return staticShape(node.expression);
   switch (node.type) {
-    case AST_NODE_TYPES88.Literal:
+    case AST_NODE_TYPES89.Literal:
       return `literal:${typeof node.value}`;
-    case AST_NODE_TYPES88.TemplateLiteral:
+    case AST_NODE_TYPES89.TemplateLiteral:
       return "template";
-    case AST_NODE_TYPES88.UnaryExpression:
+    case AST_NODE_TYPES89.UnaryExpression:
       return `unary:${node.operator}:${staticShape(node.argument)}`;
-    case AST_NODE_TYPES88.ArrayExpression:
-      return `array(${node.elements.map((item) => item === null || item.type === AST_NODE_TYPES88.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
-    case AST_NODE_TYPES88.ObjectExpression:
+    case AST_NODE_TYPES89.ArrayExpression:
+      return `array(${node.elements.map((item) => item === null || item.type === AST_NODE_TYPES89.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
+    case AST_NODE_TYPES89.ObjectExpression:
       return `object(${node.properties.map((property) => {
-        if (property.type !== AST_NODE_TYPES88.Property || property.computed || property.value.type === AST_NODE_TYPES88.AssignmentPattern) return "invalid";
-        const key = property.key.type === AST_NODE_TYPES88.Identifier ? property.key.name : String(property.key.value);
+        if (property.type !== AST_NODE_TYPES89.Property || property.computed || property.value.type === AST_NODE_TYPES89.AssignmentPattern) return "invalid";
+        const key = property.key.type === AST_NODE_TYPES89.Identifier ? property.key.name : String(property.key.value);
         return `${key}:${staticShape(property.value)}`;
       }).join(",")})`;
     default:
@@ -18630,18 +18756,18 @@ function staticShape(node) {
   }
 }
 function assertionShape(statement, context, callback) {
-  if (statement.type !== AST_NODE_TYPES88.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES88.CallExpression) return null;
+  if (statement.type !== AST_NODE_TYPES89.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES89.CallExpression) return null;
   const matcherCall = statement.expression;
-  if (matcherCall.callee.type !== AST_NODE_TYPES88.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== AST_NODE_TYPES88.Identifier || matcherCall.arguments.length !== 1) return null;
+  if (matcherCall.callee.type !== AST_NODE_TYPES89.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== AST_NODE_TYPES89.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 !== AST_NODE_TYPES88.Identifier || importedName7(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
+  if (chain === null || chain.call.callee.type !== AST_NODE_TYPES89.Identifier || importedName7(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 !== AST_NODE_TYPES88.CallExpression || observed.callee.type !== AST_NODE_TYPES88.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === AST_NODE_TYPES88.SpreadElement || !isStatic(arg)) || expected?.type === AST_NODE_TYPES88.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
+  if (observed?.type !== AST_NODE_TYPES89.CallExpression || observed.callee.type !== AST_NODE_TYPES89.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === AST_NODE_TYPES89.SpreadElement || !isStatic(arg)) || expected?.type === AST_NODE_TYPES89.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 binding = ASTUtils45.findVariable(context.sourceCode.getScope(observed.callee), observed.callee.name);
+  const binding = ASTUtils46.findVariable(context.sourceCode.getScope(observed.callee), observed.callee.name);
   if (binding?.defs.some(
     (definition) => definition.node.range[0] >= callback.range[0] && definition.node.range[1] <= callback.range[1]
   )) return null;
@@ -18651,13 +18777,13 @@ function assertionShape(statement, context, callback) {
 function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
-  while (receiver.type === AST_NODE_TYPES88.MemberExpression) {
+  while (receiver.type === AST_NODE_TYPES89.MemberExpression) {
     const modifier = staticMemberName6(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
   }
-  return receiver.type === AST_NODE_TYPES88.CallExpression ? { call: receiver, modifiers } : null;
+  return receiver.type === AST_NODE_TYPES89.CallExpression ? { call: receiver, modifiers } : null;
 }
 var repeated_static_call_cases_default = createRule({
   name: "repeated-static-call-cases",
@@ -18677,7 +18803,7 @@ var repeated_static_call_cases_default = createRule({
     return {
       "CallExpression > ArrowFunctionExpression, CallExpression > FunctionExpression"(node) {
         const call = node.parent;
-        if (call?.type === AST_NODE_TYPES88.CallExpression) {
+        if (call?.type === AST_NODE_TYPES89.CallExpression) {
           const duplicate = duplicateTestBodyCandidate(call, sourceCode);
           if (duplicate !== null && duplicate.body === node) {
             const groups = duplicateGroups.get(duplicate.container) ?? /* @__PURE__ */ new Map();
@@ -18687,7 +18813,7 @@ var repeated_static_call_cases_default = createRule({
             duplicateGroups.set(duplicate.container, groups);
           }
         }
-        if (!isDirectTestCallback2(node, context) || node.body.type !== AST_NODE_TYPES88.BlockStatement) return;
+        if (!isDirectTestCallback2(node, context) || node.body.type !== AST_NODE_TYPES89.BlockStatement) return;
         let run = [];
         const flush = () => {
           if (run.length >= MIN_CASES2 && new Set(run.map((item) => item.values)).size > 1) {
@@ -18728,7 +18854,7 @@ var repeated_static_call_cases_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES89 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES90 } from "@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.",
@@ -18792,47 +18918,47 @@ function isPreferZodInferTypeConstraintName(name) {
   return ZOD_TYPE_CONSTRAINTS.has(name);
 }
 var LEAF_NODE_TYPES = {
-  string: [AST_NODE_TYPES89.TSStringKeyword],
-  email: [AST_NODE_TYPES89.TSStringKeyword],
-  url: [AST_NODE_TYPES89.TSStringKeyword],
-  uuid: [AST_NODE_TYPES89.TSStringKeyword],
-  ulid: [AST_NODE_TYPES89.TSStringKeyword],
-  cuid: [AST_NODE_TYPES89.TSStringKeyword],
-  cuid2: [AST_NODE_TYPES89.TSStringKeyword],
-  nanoid: [AST_NODE_TYPES89.TSStringKeyword],
-  iso: [AST_NODE_TYPES89.TSStringKeyword],
-  number: [AST_NODE_TYPES89.TSNumberKeyword],
-  int: [AST_NODE_TYPES89.TSNumberKeyword],
-  float32: [AST_NODE_TYPES89.TSNumberKeyword],
-  float64: [AST_NODE_TYPES89.TSNumberKeyword],
-  boolean: [AST_NODE_TYPES89.TSBooleanKeyword],
-  bigint: [AST_NODE_TYPES89.TSBigIntKeyword],
-  symbol: [AST_NODE_TYPES89.TSSymbolKeyword],
-  any: [AST_NODE_TYPES89.TSAnyKeyword],
-  unknown: [AST_NODE_TYPES89.TSUnknownKeyword],
-  never: [AST_NODE_TYPES89.TSNeverKeyword],
-  void: [AST_NODE_TYPES89.TSVoidKeyword],
-  null: [AST_NODE_TYPES89.TSNullKeyword],
-  undefined: [AST_NODE_TYPES89.TSUndefinedKeyword],
-  literal: [AST_NODE_TYPES89.TSLiteralType],
-  date: [AST_NODE_TYPES89.TSTypeReference],
-  array: [AST_NODE_TYPES89.TSArrayType, AST_NODE_TYPES89.TSTypeReference],
-  tuple: [AST_NODE_TYPES89.TSTupleType],
-  object: [AST_NODE_TYPES89.TSTypeLiteral, AST_NODE_TYPES89.TSTypeReference],
-  strictObject: [AST_NODE_TYPES89.TSTypeLiteral, AST_NODE_TYPES89.TSTypeReference],
-  looseObject: [AST_NODE_TYPES89.TSTypeLiteral, AST_NODE_TYPES89.TSTypeReference],
-  record: [AST_NODE_TYPES89.TSTypeReference, AST_NODE_TYPES89.TSTypeLiteral],
-  map: [AST_NODE_TYPES89.TSTypeReference],
-  set: [AST_NODE_TYPES89.TSTypeReference],
-  promise: [AST_NODE_TYPES89.TSTypeReference],
-  enum: [AST_NODE_TYPES89.TSUnionType, AST_NODE_TYPES89.TSTypeReference, AST_NODE_TYPES89.TSLiteralType],
-  nativeEnum: [AST_NODE_TYPES89.TSUnionType, AST_NODE_TYPES89.TSTypeReference, AST_NODE_TYPES89.TSLiteralType],
-  union: [AST_NODE_TYPES89.TSUnionType, AST_NODE_TYPES89.TSTypeReference],
-  discriminatedUnion: [AST_NODE_TYPES89.TSUnionType, AST_NODE_TYPES89.TSTypeReference],
-  intersection: [AST_NODE_TYPES89.TSIntersectionType, AST_NODE_TYPES89.TSTypeReference]
+  string: [AST_NODE_TYPES90.TSStringKeyword],
+  email: [AST_NODE_TYPES90.TSStringKeyword],
+  url: [AST_NODE_TYPES90.TSStringKeyword],
+  uuid: [AST_NODE_TYPES90.TSStringKeyword],
+  ulid: [AST_NODE_TYPES90.TSStringKeyword],
+  cuid: [AST_NODE_TYPES90.TSStringKeyword],
+  cuid2: [AST_NODE_TYPES90.TSStringKeyword],
+  nanoid: [AST_NODE_TYPES90.TSStringKeyword],
+  iso: [AST_NODE_TYPES90.TSStringKeyword],
+  number: [AST_NODE_TYPES90.TSNumberKeyword],
+  int: [AST_NODE_TYPES90.TSNumberKeyword],
+  float32: [AST_NODE_TYPES90.TSNumberKeyword],
+  float64: [AST_NODE_TYPES90.TSNumberKeyword],
+  boolean: [AST_NODE_TYPES90.TSBooleanKeyword],
+  bigint: [AST_NODE_TYPES90.TSBigIntKeyword],
+  symbol: [AST_NODE_TYPES90.TSSymbolKeyword],
+  any: [AST_NODE_TYPES90.TSAnyKeyword],
+  unknown: [AST_NODE_TYPES90.TSUnknownKeyword],
+  never: [AST_NODE_TYPES90.TSNeverKeyword],
+  void: [AST_NODE_TYPES90.TSVoidKeyword],
+  null: [AST_NODE_TYPES90.TSNullKeyword],
+  undefined: [AST_NODE_TYPES90.TSUndefinedKeyword],
+  literal: [AST_NODE_TYPES90.TSLiteralType],
+  date: [AST_NODE_TYPES90.TSTypeReference],
+  array: [AST_NODE_TYPES90.TSArrayType, AST_NODE_TYPES90.TSTypeReference],
+  tuple: [AST_NODE_TYPES90.TSTupleType],
+  object: [AST_NODE_TYPES90.TSTypeLiteral, AST_NODE_TYPES90.TSTypeReference],
+  strictObject: [AST_NODE_TYPES90.TSTypeLiteral, AST_NODE_TYPES90.TSTypeReference],
+  looseObject: [AST_NODE_TYPES90.TSTypeLiteral, AST_NODE_TYPES90.TSTypeReference],
+  record: [AST_NODE_TYPES90.TSTypeReference, AST_NODE_TYPES90.TSTypeLiteral],
+  map: [AST_NODE_TYPES90.TSTypeReference],
+  set: [AST_NODE_TYPES90.TSTypeReference],
+  promise: [AST_NODE_TYPES90.TSTypeReference],
+  enum: [AST_NODE_TYPES90.TSUnionType, AST_NODE_TYPES90.TSTypeReference, AST_NODE_TYPES90.TSLiteralType],
+  nativeEnum: [AST_NODE_TYPES90.TSUnionType, AST_NODE_TYPES90.TSTypeReference, AST_NODE_TYPES90.TSLiteralType],
+  union: [AST_NODE_TYPES90.TSUnionType, AST_NODE_TYPES90.TSTypeReference],
+  discriminatedUnion: [AST_NODE_TYPES90.TSUnionType, AST_NODE_TYPES90.TSTypeReference],
+  intersection: [AST_NODE_TYPES90.TSIntersectionType, AST_NODE_TYPES90.TSTypeReference]
 };
 function primitiveLiteralKey(node) {
-  if (node.type !== AST_NODE_TYPES89.Literal) {
+  if (node.type !== AST_NODE_TYPES90.Literal) {
     return null;
   }
   if (node.value === null) {
@@ -18864,13 +18990,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "literal") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === AST_NODE_TYPES89.SpreadElement) {
+    if (argument === void 0 || argument.type === AST_NODE_TYPES90.SpreadElement) {
       return null;
     }
-    if (argument.type === AST_NODE_TYPES89.ArrayExpression) {
+    if (argument.type === AST_NODE_TYPES90.ArrayExpression) {
       return exactDomain(
         argument.elements.map(
-          (element) => element === null || element.type === AST_NODE_TYPES89.SpreadElement ? null : primitiveLiteralKey(element)
+          (element) => element === null || element.type === AST_NODE_TYPES90.SpreadElement ? null : primitiveLiteralKey(element)
         )
       );
     }
@@ -18878,13 +19004,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "enum") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === AST_NODE_TYPES89.SpreadElement) {
+    if (argument === void 0 || argument.type === AST_NODE_TYPES90.SpreadElement) {
       return null;
     }
-    if (argument.type === AST_NODE_TYPES89.ArrayExpression) {
+    if (argument.type === AST_NODE_TYPES90.ArrayExpression) {
       return exactDomain(
         argument.elements.map((element) => {
-          if (element === null || element.type === AST_NODE_TYPES89.SpreadElement) {
+          if (element === null || element.type === AST_NODE_TYPES90.SpreadElement) {
             return null;
           }
           const key = primitiveLiteralKey(element);
@@ -18892,10 +19018,10 @@ function staticZodDomain(leaf, call) {
         })
       );
     }
-    if (argument.type === AST_NODE_TYPES89.ObjectExpression) {
+    if (argument.type === AST_NODE_TYPES90.ObjectExpression) {
       return exactDomain(
         argument.properties.map((property) => {
-          if (property.type !== AST_NODE_TYPES89.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
+          if (property.type !== AST_NODE_TYPES90.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
             return null;
           }
           const key = primitiveLiteralKey(property.value);
@@ -18922,19 +19048,19 @@ function sameDomain(left, right) {
   return true;
 }
 function isExportedDeclaration(node) {
-  return node.parent?.type === AST_NODE_TYPES89.ExportNamedDeclaration;
+  return node.parent?.type === AST_NODE_TYPES90.ExportNamedDeclaration;
 }
 function isModuleLevelDeclaration(node) {
   const parent = node.parent;
-  return parent?.type === AST_NODE_TYPES89.Program || parent?.type === AST_NODE_TYPES89.ExportNamedDeclaration && parent.parent.type === AST_NODE_TYPES89.Program;
+  return parent?.type === AST_NODE_TYPES90.Program || parent?.type === AST_NODE_TYPES90.ExportNamedDeclaration && parent.parent.type === AST_NODE_TYPES90.Program;
 }
 function isModuleLevelConst(node) {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES89.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== AST_NODE_TYPES90.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === AST_NODE_TYPES89.Program || container.type === AST_NODE_TYPES89.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES89.Program;
+  return container.type === AST_NODE_TYPES90.Program || container.type === AST_NODE_TYPES90.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES90.Program;
 }
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -18943,20 +19069,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== AST_NODE_TYPES89.TSUnionType) {
+  if (annotation.type !== AST_NODE_TYPES90.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === AST_NODE_TYPES89.TSNullKeyword
+      nullable: annotation.type === AST_NODE_TYPES90.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === AST_NODE_TYPES89.TSNullKeyword) {
+    if (member.type === AST_NODE_TYPES90.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === AST_NODE_TYPES89.TSUndefinedKeyword) {
+    if (member.type === AST_NODE_TYPES90.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -19008,18 +19134,18 @@ function leafAgrees(field, annotation) {
     return null;
   }
   if (leaf === "date") {
-    return core.type === AST_NODE_TYPES89.TSTypeReference && core.typeName.type === AST_NODE_TYPES89.Identifier && core.typeName.name === "Date";
+    return core.type === AST_NODE_TYPES90.TSTypeReference && core.typeName.type === AST_NODE_TYPES90.Identifier && core.typeName.name === "Date";
   }
   return expected.includes(core.type);
 }
 function typeLiteralDomain(annotation) {
-  const members = annotation.type === AST_NODE_TYPES89.TSUnionType ? annotation.types : [annotation];
+  const members = annotation.type === AST_NODE_TYPES90.TSUnionType ? annotation.types : [annotation];
   const keys = [];
   for (const member of members) {
-    if (member.type === AST_NODE_TYPES89.TSNullKeyword) {
+    if (member.type === AST_NODE_TYPES90.TSNullKeyword) {
       continue;
     }
-    if (member.type !== AST_NODE_TYPES89.TSLiteralType) {
+    if (member.type !== AST_NODE_TYPES90.TSLiteralType) {
       return null;
     }
     keys.push(primitiveLiteralKey(member.literal));
@@ -19027,11 +19153,11 @@ function typeLiteralDomain(annotation) {
   return exactDomain(keys);
 }
 function staticStringUnionDomain(node) {
-  if (node.type !== AST_NODE_TYPES89.TSUnionType) {
+  if (node.type !== AST_NODE_TYPES90.TSUnionType) {
     return null;
   }
   const keys = node.types.map((member) => {
-    if (member.type !== AST_NODE_TYPES89.TSLiteralType) {
+    if (member.type !== AST_NODE_TYPES90.TSLiteralType) {
       return null;
     }
     const key = primitiveLiteralKey(member.literal);
@@ -19043,13 +19169,13 @@ function staticStringUnionDomain(node) {
 function twinCallChain(node, zodNamespaces) {
   const chain = [];
   let current = node;
-  while (current.type === AST_NODE_TYPES89.CallExpression) {
+  while (current.type === AST_NODE_TYPES90.CallExpression) {
     const callee = current.callee;
-    if (callee.type !== AST_NODE_TYPES89.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES89.Identifier) {
+    if (callee.type !== AST_NODE_TYPES90.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES90.Identifier) {
       return null;
     }
     chain.push(current);
-    if (callee.object.type === AST_NODE_TYPES89.Identifier) {
+    if (callee.object.type === AST_NODE_TYPES90.Identifier) {
       return zodNamespaces.has(callee.object.name) ? chain.reverse() : null;
     }
     current = callee.object;
@@ -19058,7 +19184,7 @@ function twinCallChain(node, zodNamespaces) {
 }
 function twinMethodName(call) {
   const callee = call.callee;
-  return callee.type === AST_NODE_TYPES89.MemberExpression && callee.property.type === AST_NODE_TYPES89.Identifier ? callee.property.name : "";
+  return callee.type === AST_NODE_TYPES90.MemberExpression && callee.property.type === AST_NODE_TYPES90.Identifier ? callee.property.name : "";
 }
 function twinSchemaFields(initializer, zodNamespaces) {
   const chain = twinCallChain(initializer, zodNamespaces);
@@ -19069,10 +19195,10 @@ function twinSchemaFields(initializer, zodNamespaces) {
   if (baseMethod !== "object" && baseMethod !== "strictObject") return null;
   if (rest.some((call) => !SHAPE_PRESERVING_METHODS.has(twinMethodName(call)))) return null;
   const shape = base.arguments[0];
-  if (shape === void 0 || shape.type !== AST_NODE_TYPES89.ObjectExpression) return null;
+  if (shape === void 0 || shape.type !== AST_NODE_TYPES90.ObjectExpression) return null;
   const fields = /* @__PURE__ */ new Map();
   for (const property of shape.properties) {
-    if (property.type !== AST_NODE_TYPES89.Property || property.computed) return null;
+    if (property.type !== AST_NODE_TYPES90.Property || property.computed) return null;
     const { key } = property;
     const name = staticFieldName(key);
     if (name === null) return null;
@@ -19085,13 +19211,13 @@ function twinSchemaField(node, zodNamespaces) {
   let current = node;
   let leaf = null;
   let leafCall = null;
-  while (current.type === AST_NODE_TYPES89.CallExpression) {
+  while (current.type === AST_NODE_TYPES90.CallExpression) {
     const callee = current.callee;
-    if (callee.type !== AST_NODE_TYPES89.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES89.Identifier) {
+    if (callee.type !== AST_NODE_TYPES90.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES90.Identifier) {
       break;
     }
     const receiver = callee.object;
-    if (receiver.type === AST_NODE_TYPES89.Identifier && zodNamespaces.has(receiver.name)) {
+    if (receiver.type === AST_NODE_TYPES90.Identifier && zodNamespaces.has(receiver.name)) {
       leaf = callee.property.name;
       leafCall = current;
       break;
@@ -19109,18 +19235,18 @@ function twinSchemaField(node, zodNamespaces) {
 }
 function twinTypeMembers(declaration) {
   let members;
-  if (declaration.type === AST_NODE_TYPES89.TSInterfaceDeclaration) {
+  if (declaration.type === AST_NODE_TYPES90.TSInterfaceDeclaration) {
     if (declaration.typeParameters !== void 0 || (declaration.extends?.length ?? 0) > 0) return null;
     members = declaration.body.body;
   } else {
-    if (declaration.typeParameters !== void 0 || declaration.typeAnnotation.type !== AST_NODE_TYPES89.TSTypeLiteral) {
+    if (declaration.typeParameters !== void 0 || declaration.typeAnnotation.type !== AST_NODE_TYPES90.TSTypeLiteral) {
       return null;
     }
     members = declaration.typeAnnotation.members;
   }
   const result = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== AST_NODE_TYPES89.TSPropertySignature || member.computed) return null;
+    if (member.type !== AST_NODE_TYPES90.TSPropertySignature || member.computed) return null;
     const { key } = member;
     const name = staticFieldName(key);
     if (name === null) return null;
@@ -19195,7 +19321,7 @@ var prefer_zod_infer_default = createRule({
         return;
       }
       for (const specifier of node.specifiers) {
-        if (specifier.type === AST_NODE_TYPES89.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES89.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES89.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES89.Identifier && specifier.imported.name === "z") {
+        if (specifier.type === AST_NODE_TYPES90.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES90.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES90.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES90.Identifier && specifier.imported.name === "z") {
           zodNamespaces.add(specifier.local.name);
         }
       }
@@ -19213,20 +19339,20 @@ var prefer_zod_infer_default = createRule({
       return domain instanceof Set && domain.size >= 2 ? domain : null;
     }
     function inferredSchemaName(node) {
-      if (node.type !== AST_NODE_TYPES89.TSTypeReference || node.typeName.type !== AST_NODE_TYPES89.TSQualifiedName || node.typeName.left.type !== AST_NODE_TYPES89.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
+      if (node.type !== AST_NODE_TYPES90.TSTypeReference || node.typeName.type !== AST_NODE_TYPES90.TSQualifiedName || node.typeName.left.type !== AST_NODE_TYPES90.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 === AST_NODE_TYPES89.TSTypeQuery && argument.exprName.type === AST_NODE_TYPES89.Identifier ? argument.exprName.name : null;
+      return arguments_.length === 1 && argument?.type === AST_NODE_TYPES90.TSTypeQuery && argument.exprName.type === AST_NODE_TYPES90.Identifier ? argument.exprName.name : null;
     }
     function recordLiteralUnions(members, owner, ownerName, exported) {
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES89.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
+        if (member.type !== AST_NODE_TYPES90.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
           continue;
         }
         const key = member.key;
-        const propertyName7 = key.type === AST_NODE_TYPES89.Identifier ? key.name : key.type === AST_NODE_TYPES89.Literal && typeof key.value === "string" ? key.value : null;
+        const propertyName7 = key.type === AST_NODE_TYPES90.Identifier ? key.name : key.type === AST_NODE_TYPES90.Literal && typeof key.value === "string" ? key.value : null;
         if (propertyName7 === null) {
           continue;
         }
@@ -19236,7 +19362,7 @@ var prefer_zod_infer_default = createRule({
         }
         const annotation = member.typeAnnotation.typeAnnotation;
         const domain = staticStringUnionDomain(annotation);
-        if (domain === null || annotation.type !== AST_NODE_TYPES89.TSUnionType) {
+        if (domain === null || annotation.type !== AST_NODE_TYPES90.TSUnionType) {
           continue;
         }
         literalUnionOccurrences.push({
@@ -19251,8 +19377,8 @@ var prefer_zod_infer_default = createRule({
       }
     }
     function collectConstrainedNames2(node) {
-      if (node.type === AST_NODE_TYPES89.TSTypeReference) {
-        if (node.typeName.type === AST_NODE_TYPES89.Identifier) {
+      if (node.type === AST_NODE_TYPES90.TSTypeReference) {
+        if (node.typeName.type === AST_NODE_TYPES90.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -19260,11 +19386,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === AST_NODE_TYPES89.TSArrayType) {
+      if (node.type === AST_NODE_TYPES90.TSArrayType) {
         collectConstrainedNames2(node.elementType);
         return;
       }
-      if (node.type === AST_NODE_TYPES89.TSUnionType || node.type === AST_NODE_TYPES89.TSIntersectionType) {
+      if (node.type === AST_NODE_TYPES90.TSUnionType || node.type === AST_NODE_TYPES90.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames2(member);
         }
@@ -19273,7 +19399,7 @@ var prefer_zod_infer_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          if (statement.type === AST_NODE_TYPES89.ImportDeclaration) {
+          if (statement.type === AST_NODE_TYPES90.ImportDeclaration) {
             recordZodImport(statement);
           }
         }
@@ -19282,7 +19408,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES89.Identifier || node.init == null || !isModuleLevelConst(node)) {
+        if (node.id.type !== AST_NODE_TYPES90.Identifier || node.init == null || !isModuleLevelConst(node)) {
           return;
         }
         const fields = twinSchemaFields(node.init, zodNamespaces);
@@ -19299,14 +19425,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === AST_NODE_TYPES89.Identifier && node.property.type === AST_NODE_TYPES89.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+        if (node.object.type === AST_NODE_TYPES90.Identifier && node.property.type === AST_NODE_TYPES90.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === AST_NODE_TYPES89.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES89.TSQualifiedName && typeName.right.type === AST_NODE_TYPES89.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === AST_NODE_TYPES90.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES90.TSQualifiedName && typeName.right.type === AST_NODE_TYPES90.Identifier ? typeName.right.name : null;
         if (referenced === null || !isPreferZodInferTypeConstraintName(referenced)) {
           return;
         }
@@ -19340,7 +19466,7 @@ var prefer_zod_infer_default = createRule({
             typeName: node.id.name
           });
         }
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES89.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES90.TSTypeLiteral) {
           return;
         }
         const members = twinTypeMembers(node);
@@ -19452,12 +19578,12 @@ var prefer_zod_infer_default = createRule({
   }
 });
 function staticFieldName(key) {
-  return key.type === AST_NODE_TYPES89.Identifier ? key.name : key.type === AST_NODE_TYPES89.Literal && typeof key.value === "string" ? key.value : null;
+  return key.type === AST_NODE_TYPES90.Identifier ? key.name : key.type === AST_NODE_TYPES90.Literal && typeof key.value === "string" ? key.value : null;
 }
 
 // src/rules/prefer-zod-parse-output-type.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES90,
+  AST_NODE_TYPES as AST_NODE_TYPES91,
   ESLintUtils as ESLintUtils13
 } from "@typescript-eslint/utils";
 import ts11 from "typescript";
@@ -19513,20 +19639,20 @@ var PREFER_ZOD_PARSE_OUTPUT_TYPE_DOCUMENTATION = {
 };
 function isModuleLevelConst2(node) {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES90.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== AST_NODE_TYPES91.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === AST_NODE_TYPES90.Program || container.type === AST_NODE_TYPES90.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES90.Program;
+  return container.type === AST_NODE_TYPES91.Program || container.type === AST_NODE_TYPES91.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES91.Program;
 }
 function isLocalZodObjectSchema(node, namespaces) {
   let current = node;
-  while (current.type === AST_NODE_TYPES90.CallExpression) {
+  while (current.type === AST_NODE_TYPES91.CallExpression) {
     const { callee } = current;
-    if (callee.type !== AST_NODE_TYPES90.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES90.Identifier) {
+    if (callee.type !== AST_NODE_TYPES91.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES91.Identifier) {
       return false;
     }
-    if (callee.object.type === AST_NODE_TYPES90.Identifier) {
+    if (callee.object.type === AST_NODE_TYPES91.Identifier) {
       return namespaces.has(callee.object.name) && (callee.property.name === "object" || callee.property.name === "strictObject");
     }
     current = callee.object;
@@ -19535,7 +19661,7 @@ function isLocalZodObjectSchema(node, namespaces) {
 }
 function zodParseCall(node) {
   const { callee } = node;
-  if (callee.type !== AST_NODE_TYPES90.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES90.Identifier || callee.property.type !== AST_NODE_TYPES90.Identifier || callee.property.name !== "parse" && callee.property.name !== "safeParse") {
+  if (callee.type !== AST_NODE_TYPES91.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES91.Identifier || callee.property.type !== AST_NODE_TYPES91.Identifier || callee.property.name !== "parse" && callee.property.name !== "safeParse") {
     return null;
   }
   return {
@@ -19550,7 +19676,7 @@ function returnedOutputCandidate(parsed, output) {
   const annotation = owner?.returnType?.typeAnnotation;
   if (annotation === void 0) return null;
   const typeReference = returnContractReference(annotation);
-  if (typeReference === null || typeReference.typeName.type !== AST_NODE_TYPES90.Identifier) {
+  if (typeReference === null || typeReference.typeName.type !== AST_NODE_TYPES91.Identifier) {
     return null;
   }
   return {
@@ -19567,7 +19693,7 @@ function directParseReturnCandidate(node) {
   return parsed?.method === "parse" ? returnedOutputCandidate(parsed, node) : null;
 }
 function localParseReturnCandidates(node, sourceCode) {
-  if (node.id.type !== AST_NODE_TYPES90.Identifier || node.init?.type !== AST_NODE_TYPES90.CallExpression || node.parent.type !== AST_NODE_TYPES90.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
+  if (node.id.type !== AST_NODE_TYPES91.Identifier || node.init?.type !== AST_NODE_TYPES91.CallExpression || node.parent.type !== AST_NODE_TYPES91.VariableDeclaration || node.parent.kind !== "const" || enclosingFunction4(node.init) === null) {
     return [];
   }
   const parsed = zodParseCall(node.init);
@@ -19578,7 +19704,7 @@ function localParseReturnCandidates(node, sourceCode) {
   for (const reference of variable.references) {
     const identifier = reference.identifier;
     const parent = identifier.parent;
-    const output = parsed.method === "parse" ? identifier : parent.type === AST_NODE_TYPES90.MemberExpression && parent.object === identifier && !parent.computed && parent.property.type === AST_NODE_TYPES90.Identifier && parent.property.name === "data" ? parent : null;
+    const output = parsed.method === "parse" ? identifier : parent.type === AST_NODE_TYPES91.MemberExpression && parent.object === identifier && !parent.computed && parent.property.type === AST_NODE_TYPES91.Identifier && parent.property.name === "data" ? parent : null;
     if (output === null) continue;
     const candidate2 = returnedOutputCandidate(parsed, output);
     if (candidate2 !== null) candidates.push(candidate2);
@@ -19589,17 +19715,17 @@ function directReturnOwner(node) {
   let current = node;
   while (current.parent !== void 0) {
     const parent = current.parent;
-    if (parent.type === AST_NODE_TYPES90.ReturnStatement) {
+    if (parent.type === AST_NODE_TYPES91.ReturnStatement) {
       return parent.argument === current ? enclosingFunction4(parent) : null;
     }
-    if (parent.type === AST_NODE_TYPES90.ArrowFunctionExpression && parent.expression && parent.body === current) {
+    if (parent.type === AST_NODE_TYPES91.ArrowFunctionExpression && parent.expression && parent.body === current) {
       return parent;
     }
-    if (parent.type === AST_NODE_TYPES90.AwaitExpression && parent.argument === current) {
+    if (parent.type === AST_NODE_TYPES91.AwaitExpression && parent.argument === current) {
       current = parent;
       continue;
     }
-    if (parent.type === AST_NODE_TYPES90.ConditionalExpression) {
+    if (parent.type === AST_NODE_TYPES91.ConditionalExpression) {
       const parsedWhenTrue = parent.consequent === current && isNullishExpression(parent.alternate);
       const parsedWhenFalse = parent.alternate === current && isNullishExpression(parent.consequent);
       if (parsedWhenTrue || parsedWhenFalse) {
@@ -19612,12 +19738,12 @@ function directReturnOwner(node) {
   return null;
 }
 function isNullishExpression(node) {
-  return node.type === AST_NODE_TYPES90.Literal && node.value === null || node.type === AST_NODE_TYPES90.Identifier && node.name === "undefined";
+  return node.type === AST_NODE_TYPES91.Literal && node.value === null || node.type === AST_NODE_TYPES91.Identifier && node.name === "undefined";
 }
 function enclosingFunction4(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === AST_NODE_TYPES90.ArrowFunctionExpression || current.type === AST_NODE_TYPES90.FunctionDeclaration || current.type === AST_NODE_TYPES90.FunctionExpression) {
+    if (current.type === AST_NODE_TYPES91.ArrowFunctionExpression || current.type === AST_NODE_TYPES91.FunctionDeclaration || current.type === AST_NODE_TYPES91.FunctionExpression) {
       return current;
     }
     current = current.parent;
@@ -19625,45 +19751,45 @@ function enclosingFunction4(node) {
   return null;
 }
 function returnContractReference(node) {
-  if (node.type === AST_NODE_TYPES90.TSUnionType) {
+  if (node.type === AST_NODE_TYPES91.TSUnionType) {
     const substantive = node.types.filter(
-      (member) => member.type !== AST_NODE_TYPES90.TSNullKeyword && member.type !== AST_NODE_TYPES90.TSUndefinedKeyword
+      (member) => member.type !== AST_NODE_TYPES91.TSNullKeyword && member.type !== AST_NODE_TYPES91.TSUndefinedKeyword
     );
     const [only] = substantive;
     return substantive.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  if (node.type === AST_NODE_TYPES90.TSTypeReference && node.typeName.type === AST_NODE_TYPES90.Identifier && node.typeName.name === "Promise") {
+  if (node.type === AST_NODE_TYPES91.TSTypeReference && node.typeName.type === AST_NODE_TYPES91.Identifier && node.typeName.name === "Promise") {
     const parameters = node.typeArguments?.params ?? [];
     const [only] = parameters;
     return parameters.length === 1 && only !== void 0 ? returnContractReference(only) : null;
   }
-  return node.type === AST_NODE_TYPES90.TSTypeReference && node.typeName.type === AST_NODE_TYPES90.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
+  return node.type === AST_NODE_TYPES91.TSTypeReference && node.typeName.type === AST_NODE_TYPES91.Identifier && (node.typeArguments?.params.length ?? 0) === 0 ? node : null;
 }
 function recordZodNamespaces(node, namespaces) {
   for (const statement of node.body) {
-    if (statement.type !== AST_NODE_TYPES90.ImportDeclaration || !isZodModule(statement.source.value)) {
+    if (statement.type !== AST_NODE_TYPES91.ImportDeclaration || !isZodModule(statement.source.value)) {
       continue;
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.type === AST_NODE_TYPES90.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES90.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES90.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES90.Identifier && specifier.imported.name === "z") {
+      if (specifier.type === AST_NODE_TYPES91.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES91.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES91.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES91.Identifier && specifier.imported.name === "z") {
         namespaces.add(specifier.local.name);
       }
     }
   }
 }
 function collectConstrainedNames(node, names) {
-  if (node.type === AST_NODE_TYPES90.TSTypeReference) {
-    if (node.typeName.type === AST_NODE_TYPES90.Identifier) names.add(node.typeName.name);
+  if (node.type === AST_NODE_TYPES91.TSTypeReference) {
+    if (node.typeName.type === AST_NODE_TYPES91.Identifier) names.add(node.typeName.name);
     for (const argument of node.typeArguments?.params ?? []) {
       collectConstrainedNames(argument, names);
     }
     return;
   }
-  if (node.type === AST_NODE_TYPES90.TSArrayType) {
+  if (node.type === AST_NODE_TYPES91.TSArrayType) {
     collectConstrainedNames(node.elementType, names);
     return;
   }
-  if (node.type === AST_NODE_TYPES90.TSUnionType || node.type === AST_NODE_TYPES90.TSIntersectionType) {
+  if (node.type === AST_NODE_TYPES91.TSUnionType || node.type === AST_NODE_TYPES91.TSIntersectionType) {
     for (const member of node.types) collectConstrainedNames(member, names);
   }
 }
@@ -19697,7 +19823,7 @@ function reportCandidates(context, services, schemas, candidates, zodNamespaces,
     if (constrained) return;
     if (declaration.getSourceFile() === tsSchema.getSourceFile()) {
       const estreeDeclaration = services.tsNodeToESTreeNodeMap.get(declaration);
-      if ((estreeDeclaration.type === AST_NODE_TYPES90.TSInterfaceDeclaration || estreeDeclaration.type === AST_NODE_TYPES90.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
+      if ((estreeDeclaration.type === AST_NODE_TYPES91.TSInterfaceDeclaration || estreeDeclaration.type === AST_NODE_TYPES91.TSTypeAliasDeclaration) && preferZodInferOwnsDefaultTwin({
         constrained,
         declaration: estreeDeclaration,
         initializer: schema.initializer,
@@ -19802,7 +19928,7 @@ var prefer_zod_parse_output_type_default = createRule({
         recordZodNamespaces(node, namespaces);
       },
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES90.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
+        if (node.id.type === AST_NODE_TYPES91.Identifier && node.init !== null && isModuleLevelConst2(node) && isLocalZodObjectSchema(node.init, namespaces)) {
           schemas.push({ identifier: node.id, initializer: node.init, name: node.id.name });
         }
         candidates.push(...localParseReturnCandidates(node, context.sourceCode));
@@ -19812,13 +19938,13 @@ var prefer_zod_parse_output_type_default = createRule({
         if (candidate2 !== null) candidates.push(candidate2);
       },
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === AST_NODE_TYPES90.Identifier && node.property.type === AST_NODE_TYPES90.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
+        if (node.object.type === AST_NODE_TYPES91.Identifier && node.property.type === AST_NODE_TYPES91.Identifier && isPreferZodInferModuleReshaper(node.property.name)) {
           reshapedSchemas.add(node.object.name);
         }
       },
       TSTypeReference(node) {
         const { typeName } = node;
-        const name = typeName.type === AST_NODE_TYPES90.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES90.TSQualifiedName && typeName.right.type === AST_NODE_TYPES90.Identifier ? typeName.right.name : null;
+        const name = typeName.type === AST_NODE_TYPES91.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES91.TSQualifiedName && typeName.right.type === AST_NODE_TYPES91.Identifier ? typeName.right.name : null;
         if (name === null || !isPreferZodInferTypeConstraintName(name)) return;
         for (const argument of node.typeArguments?.params ?? []) {
           collectConstrainedNames(argument, constrainedTypeNames);
@@ -19842,7 +19968,7 @@ var prefer_zod_parse_output_type_default = createRule({
 // src/rules/require-assert-never.ts
 import {
   ESLintUtils as ESLintUtils14,
-  AST_NODE_TYPES as AST_NODE_TYPES91
+  AST_NODE_TYPES as AST_NODE_TYPES92
 } from "@typescript-eslint/utils";
 import ts12 from "typescript";
 var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
@@ -19857,14 +19983,14 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === AST_NODE_TYPES91.EmptyStatement) return false;
-  if (statement.type === AST_NODE_TYPES91.BreakStatement) {
+  if (statement.type === AST_NODE_TYPES92.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES92.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === AST_NODE_TYPES91.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES91.TSInterfaceDeclaration) {
+  if (statement.type === AST_NODE_TYPES92.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES92.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === AST_NODE_TYPES91.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES92.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -19880,7 +20006,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES91.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES92.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -19961,7 +20087,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES92, ASTUtils as ASTUtils46 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES93, ASTUtils as ASTUtils47 } from "@typescript-eslint/utils";
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an explicit abort signal on locally analyzable global fetch calls.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -19988,14 +20114,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== AST_NODE_TYPES92.ObjectExpression) {
+  if (init.type !== AST_NODE_TYPES93.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === AST_NODE_TYPES92.SpreadElement) {
+    if (prop.type === AST_NODE_TYPES93.SpreadElement) {
       return false;
     }
-    if (prop.key.type === AST_NODE_TYPES92.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES92.Literal && prop.key.value === "signal") {
+    if (prop.key.type === AST_NODE_TYPES93.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES93.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -20005,7 +20131,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === AST_NODE_TYPES92.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES92.TemplateLiteral || node.type === AST_NODE_TYPES92.NewExpression && node.callee.type === AST_NODE_TYPES92.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === AST_NODE_TYPES93.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES93.TemplateLiteral || node.type === AST_NODE_TYPES93.NewExpression && node.callee.type === AST_NODE_TYPES93.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -20043,30 +20169,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils46.findVariable(scope, identifier.name);
+      const variable = ASTUtils47.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === AST_NODE_TYPES92.Identifier) {
+      if (callee.type === AST_NODE_TYPES93.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === AST_NODE_TYPES92.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES92.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES92.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === AST_NODE_TYPES93.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES93.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES93.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = ASTUtils46.findVariable(
+      const variable = ASTUtils47.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 !== AST_NODE_TYPES92.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== AST_NODE_TYPES93.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 !== AST_NODE_TYPES92.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES92.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES92.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== AST_NODE_TYPES93.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES93.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES93.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -20074,13 +20200,13 @@ var require_fetch_timeout_default = createRule({
     }
     function isForwardedRequest(argument) {
       let value = argument;
-      if (value.type === AST_NODE_TYPES92.Identifier) {
-        const binding = ASTUtils46.findVariable(context.sourceCode.getScope(value), value.name);
+      if (value.type === AST_NODE_TYPES93.Identifier) {
+        const binding = ASTUtils47.findVariable(context.sourceCode.getScope(value), value.name);
         const definition = binding?.defs.length === 1 ? binding.defs[0] : void 0;
         if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || binding?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         value = definition.node.init;
       }
-      return value.type === AST_NODE_TYPES92.NewExpression && value.callee.type === AST_NODE_TYPES92.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
+      return value.type === AST_NODE_TYPES93.NewExpression && value.callee.type === AST_NODE_TYPES93.Identifier && value.callee.name === "Request" && resolvesToGlobal(value.callee);
     }
     return {
       CallExpression(node) {
@@ -20091,7 +20217,7 @@ var require_fetch_timeout_default = createRule({
         if (first !== void 0 && (node.arguments.length === 1 && !isInlineUrl(first, resolvesToGlobal) || isForwardedRequest(first))) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES92.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES93.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -20100,7 +20226,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-exported-class.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES93 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES94 } from "@typescript-eslint/utils";
 var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Require exported concrete classes with public behavior to declare a contract.",
@@ -20147,23 +20273,23 @@ var REQUIRE_INTERFACE_FOR_EXPORTED_CLASS_DOCUMENTATION = {
 };
 function hasPublicInstanceBehavior(node) {
   return node.body.body.some((member) => {
-    if (member.type === AST_NODE_TYPES93.MethodDefinition) {
-      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== AST_NODE_TYPES93.PrivateIdentifier;
+    if (member.type === AST_NODE_TYPES94.MethodDefinition) {
+      return member.kind !== "constructor" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.key.type !== AST_NODE_TYPES94.PrivateIdentifier;
     }
-    if (member.type !== AST_NODE_TYPES93.PropertyDefinition || member.static)
+    if (member.type !== AST_NODE_TYPES94.PropertyDefinition || member.static)
       return false;
-    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === AST_NODE_TYPES93.PrivateIdentifier) return false;
-    return member.value?.type === AST_NODE_TYPES93.ArrowFunctionExpression || member.value?.type === AST_NODE_TYPES93.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES93.TSFunctionType;
+    if (member.accessibility === "private" || member.accessibility === "protected" || member.key.type === AST_NODE_TYPES94.PrivateIdentifier) return false;
+    return member.value?.type === AST_NODE_TYPES94.ArrowFunctionExpression || member.value?.type === AST_NODE_TYPES94.FunctionExpression || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES94.TSFunctionType;
   });
 }
 function classBindings(statement) {
-  const declaration = statement.type === AST_NODE_TYPES93.ExportNamedDeclaration ? statement.declaration : statement;
-  if (declaration?.type === AST_NODE_TYPES93.ClassDeclaration) {
+  const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration ? statement.declaration : statement;
+  if (declaration?.type === AST_NODE_TYPES94.ClassDeclaration) {
     return declaration.id === null ? [] : [{ declaration, name: declaration.id.name }];
   }
-  if (declaration?.type !== AST_NODE_TYPES93.VariableDeclaration) return [];
+  if (declaration?.type !== AST_NODE_TYPES94.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === AST_NODE_TYPES93.Identifier && item.init?.type === AST_NODE_TYPES93.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
+    (item) => item.id.type === AST_NODE_TYPES94.Identifier && item.init?.type === AST_NODE_TYPES94.ClassExpression ? [{ declaration: item.init, name: item.id.name }] : []
   );
 }
 var require_interface_for_exported_class_default = createRule({
@@ -20197,7 +20323,7 @@ var require_interface_for_exported_class_default = createRule({
         }
         const exported = exportedClasses(program, classes);
         for (const [declaration, exportedName] of exported) {
-          const extendsLocalAbstractBase = declaration.superClass?.type === AST_NODE_TYPES93.Identifier && abstractBases.has(declaration.superClass.name);
+          const extendsLocalAbstractBase = declaration.superClass?.type === AST_NODE_TYPES94.Identifier && abstractBases.has(declaration.superClass.name);
           if (declaration.abstract || declaration.implements.length > 0 || extendsLocalAbstractBase || !hasPublicInstanceBehavior(declaration)) continue;
           context.report({
             node: declaration.id ?? declaration,
@@ -20212,7 +20338,7 @@ var require_interface_for_exported_class_default = createRule({
 function exportedClasses(program, classes) {
   const exported = /* @__PURE__ */ new Map();
   function collectExportedClass(statement) {
-    if (statement.type === AST_NODE_TYPES93.ExportNamedDeclaration) {
+    if (statement.type === AST_NODE_TYPES94.ExportNamedDeclaration) {
       for (const binding of classBindings(statement)) {
         exported.set(binding.declaration, binding.name);
       }
@@ -20220,13 +20346,13 @@ function exportedClasses(program, classes) {
       collectClassSpecifiers(statement);
       return;
     }
-    if (statement.type !== AST_NODE_TYPES93.ExportDefaultDeclaration) return;
-    if (statement.declaration.type === AST_NODE_TYPES93.ClassDeclaration || statement.declaration.type === AST_NODE_TYPES93.ClassExpression) {
+    if (statement.type !== AST_NODE_TYPES94.ExportDefaultDeclaration) return;
+    if (statement.declaration.type === AST_NODE_TYPES94.ClassDeclaration || statement.declaration.type === AST_NODE_TYPES94.ClassExpression) {
       exported.set(
         statement.declaration,
         statement.declaration.id?.name ?? "default"
       );
-    } else if (statement.declaration.type === AST_NODE_TYPES93.Identifier) {
+    } else if (statement.declaration.type === AST_NODE_TYPES94.Identifier) {
       const candidate2 = classes.get(statement.declaration.name);
       if (candidate2 !== void 0) {
         exported.set(candidate2, statement.declaration.name);
@@ -20238,7 +20364,7 @@ function exportedClasses(program, classes) {
       if (specifier.exportKind === "type") continue;
       const candidate2 = classes.get(specifier.local.name);
       if (candidate2 === void 0) continue;
-      const exportedName = specifier.exported.type === AST_NODE_TYPES93.Identifier ? specifier.exported.name : specifier.exported.value;
+      const exportedName = specifier.exported.type === AST_NODE_TYPES94.Identifier ? specifier.exported.name : specifier.exported.value;
       exported.set(candidate2, exportedName);
     }
   }
@@ -20249,7 +20375,7 @@ function exportedClasses(program, classes) {
 }
 
 // src/rules/require-port-for-service.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES94 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES95 } from "@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.",
@@ -20274,45 +20400,45 @@ var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS2 = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
 var staticMemberName7 = (member) => {
-  if (member.property.type === AST_NODE_TYPES94.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === AST_NODE_TYPES94.Identifier) return member.property.name;
-  return member.computed && member.property.type === AST_NODE_TYPES94.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === AST_NODE_TYPES95.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === AST_NODE_TYPES95.Identifier) return member.property.name;
+  return member.computed && member.property.type === AST_NODE_TYPES95.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 === AST_NODE_TYPES94.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === AST_NODE_TYPES95.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
         if (specifier.exportKind !== "type") names.add(specifier.local.name);
       }
-    } else if (statement.type === AST_NODE_TYPES94.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES94.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES95.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES95.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === AST_NODE_TYPES94.TSExportAssignment && statement.expression.type === AST_NODE_TYPES94.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES95.TSExportAssignment && statement.expression.type === AST_NODE_TYPES95.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES94.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES94.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES95.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES95.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === AST_NODE_TYPES94.TSUnionType) {
+  if (annotation?.type === AST_NODE_TYPES95.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== AST_NODE_TYPES94.TSUndefinedKeyword && member.type !== AST_NODE_TYPES94.TSNullKeyword
+      (member) => member.type !== AST_NODE_TYPES95.TSUndefinedKeyword && member.type !== AST_NODE_TYPES95.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES94.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES95.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === AST_NODE_TYPES94.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES94.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === AST_NODE_TYPES95.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES95.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === AST_NODE_TYPES94.Identifier ? name.name : name.type === AST_NODE_TYPES94.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === AST_NODE_TYPES95.Identifier ? name.name : name.type === AST_NODE_TYPES95.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== AST_NODE_TYPES94.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== AST_NODE_TYPES94.Identifier) continue;
+    if (member.type !== AST_NODE_TYPES95.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== AST_NODE_TYPES95.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -20323,18 +20449,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   function collectDeclaredType(statement) {
-    const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES94.TSInterfaceDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES95.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES95.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       return;
     }
-    if (declaration?.type !== AST_NODE_TYPES94.TSTypeAliasDeclaration) return;
+    if (declaration?.type !== AST_NODE_TYPES95.TSTypeAliasDeclaration) return;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === AST_NODE_TYPES94.TSFunctionType || aliased.type === AST_NODE_TYPES94.TSConstructorType) {
+    if (aliased.type === AST_NODE_TYPES95.TSFunctionType || aliased.type === AST_NODE_TYPES95.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       return;
     }
-    const literals = aliased.type === AST_NODE_TYPES94.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES94.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES94.TSTypeLiteral) : [];
+    const literals = aliased.type === AST_NODE_TYPES95.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES95.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES95.TSTypeLiteral) : [];
     if (literals.length === 0) return;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -20365,22 +20491,22 @@ var readConstructor = (ctor, declared, typeParameters) => {
   function scanStoredFields(body3) {
     const pending = [...body3.body];
     function recordStoredField(current) {
-      if (current.type === AST_NODE_TYPES94.ArrowFunctionExpression || current.type === AST_NODE_TYPES94.FunctionExpression || current.type === AST_NODE_TYPES94.FunctionDeclaration || current.type === AST_NODE_TYPES94.ClassExpression || current.type === AST_NODE_TYPES94.ClassDeclaration) return;
-      const expression = current.type === AST_NODE_TYPES94.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === AST_NODE_TYPES94.AssignmentExpression && expression.left.type === AST_NODE_TYPES94.MemberExpression && expression.left.object.type === AST_NODE_TYPES94.ThisExpression ? staticMemberName7(expression.left) : null;
-      if (expression?.type !== AST_NODE_TYPES94.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS2.has(expression.operator) || expression.left.type !== AST_NODE_TYPES94.MemberExpression || expression.left.object.type !== AST_NODE_TYPES94.ThisExpression || storedField === null) {
+      if (current.type === AST_NODE_TYPES95.ArrowFunctionExpression || current.type === AST_NODE_TYPES95.FunctionExpression || current.type === AST_NODE_TYPES95.FunctionDeclaration || current.type === AST_NODE_TYPES95.ClassExpression || current.type === AST_NODE_TYPES95.ClassDeclaration) return;
+      const expression = current.type === AST_NODE_TYPES95.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === AST_NODE_TYPES95.AssignmentExpression && expression.left.type === AST_NODE_TYPES95.MemberExpression && expression.left.object.type === AST_NODE_TYPES95.ThisExpression ? staticMemberName7(expression.left) : null;
+      if (expression?.type !== AST_NODE_TYPES95.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS2.has(expression.operator) || expression.left.type !== AST_NODE_TYPES95.MemberExpression || expression.left.object.type !== AST_NODE_TYPES95.ThisExpression || storedField === null) {
         enqueueChildren(current);
         return;
       }
       let source = expression.right;
-      while (source.type === AST_NODE_TYPES94.TSNonNullExpression || source.type === AST_NODE_TYPES94.TSAsExpression || source.type === AST_NODE_TYPES94.TSSatisfiesExpression || source.type === AST_NODE_TYPES94.TSTypeAssertion) source = source.expression;
-      if (source.type === AST_NODE_TYPES94.NewExpression) {
+      while (source.type === AST_NODE_TYPES95.TSNonNullExpression || source.type === AST_NODE_TYPES95.TSAsExpression || source.type === AST_NODE_TYPES95.TSSatisfiesExpression || source.type === AST_NODE_TYPES95.TSTypeAssertion) source = source.expression;
+      if (source.type === AST_NODE_TYPES95.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === AST_NODE_TYPES94.Identifier) {
+      } else if (source.type === AST_NODE_TYPES95.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === AST_NODE_TYPES94.MemberExpression && source.object.type === AST_NODE_TYPES94.Identifier) {
+      } else if (source.type === AST_NODE_TYPES95.MemberExpression && source.object.type === AST_NODE_TYPES95.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -20408,7 +20534,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   function collectCollaborators(parameter) {
     for (const reference of parameterCollaborators(parameter, declared, storedMemberFieldsFrom)) {
-      const fields = parameter.type === AST_NODE_TYPES94.TSParameterProperty ? [reference.name] : reference.fields.length > 0 ? reference.fields : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === AST_NODE_TYPES95.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;
@@ -20426,8 +20552,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
   let target = parameter;
-  if (target.type === AST_NODE_TYPES94.AssignmentPattern) target = target.left;
-  if (target.type === AST_NODE_TYPES94.ObjectPattern) {
+  if (target.type === AST_NODE_TYPES95.AssignmentPattern) target = target.left;
+  if (target.type === AST_NODE_TYPES95.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -20436,9 +20562,9 @@ var parameterCollaborators = (parameter, declared, storedMemberFieldsFrom) => {
 };
 var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES94.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES94.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES94.Identifier) return [];
+  if (target.type === AST_NODE_TYPES95.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES95.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES95.Identifier) return [];
   const members = bagMemberTypes(target.typeAnnotation?.typeAnnotation, declared);
   if (members === null) return [];
   const storedMembers = storedMemberFieldsFrom.get(target.name);
@@ -20454,9 +20580,9 @@ var namedBagCollaborators = (annotated, declared, storedMemberFieldsFrom) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES94.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES94.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES94.Identifier) return null;
+  if (target.type === AST_NODE_TYPES95.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES95.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES95.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -20468,11 +20594,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== AST_NODE_TYPES94.Property || property.computed) continue;
-    if (property.key.type !== AST_NODE_TYPES94.Identifier) continue;
+    if (property.type !== AST_NODE_TYPES95.Property || property.computed) continue;
+    if (property.key.type !== AST_NODE_TYPES95.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === AST_NODE_TYPES94.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== AST_NODE_TYPES94.Identifier) continue;
+    const bound = property.value.type === AST_NODE_TYPES95.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== AST_NODE_TYPES95.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -20482,21 +20608,21 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var bagMemberTypes = (annotation, declared) => {
   if (annotation === void 0) return null;
-  if (annotation.type === AST_NODE_TYPES94.TSTypeLiteral) {
+  if (annotation.type === AST_NODE_TYPES95.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== AST_NODE_TYPES94.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES94.Identifier) {
+  if (annotation.type !== AST_NODE_TYPES95.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES95.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === AST_NODE_TYPES94.CallExpression) {
+  if (node.type === AST_NODE_TYPES95.CallExpression) {
     const { callee } = node;
-    if (callee.type === AST_NODE_TYPES94.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === AST_NODE_TYPES94.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES94.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === AST_NODE_TYPES95.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === AST_NODE_TYPES95.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES95.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === AST_NODE_TYPES94.TSTypeReference && node.typeName.type === AST_NODE_TYPES94.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === AST_NODE_TYPES95.TSTypeReference && node.typeName.type === AST_NODE_TYPES95.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -20518,33 +20644,33 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === AST_NODE_TYPES94.ChainExpression || callee.type === AST_NODE_TYPES94.TSAsExpression || callee.type === AST_NODE_TYPES94.TSNonNullExpression || callee.type === AST_NODE_TYPES94.TSSatisfiesExpression || callee.type === AST_NODE_TYPES94.TSTypeAssertion) callee = callee.expression;
-  return callee.type === AST_NODE_TYPES94.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === AST_NODE_TYPES95.ChainExpression || callee.type === AST_NODE_TYPES95.TSAsExpression || callee.type === AST_NODE_TYPES95.TSNonNullExpression || callee.type === AST_NODE_TYPES95.TSSatisfiesExpression || callee.type === AST_NODE_TYPES95.TSTypeAssertion) callee = callee.expression;
+  return callee.type === AST_NODE_TYPES95.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate2) => {
   let node = candidate2;
-  while (node.type === AST_NODE_TYPES94.ChainExpression || node.type === AST_NODE_TYPES94.TSAsExpression || node.type === AST_NODE_TYPES94.TSNonNullExpression || node.type === AST_NODE_TYPES94.TSSatisfiesExpression || node.type === AST_NODE_TYPES94.TSTypeAssertion) node = node.expression;
-  return node.type === AST_NODE_TYPES94.MemberExpression && node.object.type === AST_NODE_TYPES94.ThisExpression ? staticMemberName7(node) : null;
+  while (node.type === AST_NODE_TYPES95.ChainExpression || node.type === AST_NODE_TYPES95.TSAsExpression || node.type === AST_NODE_TYPES95.TSNonNullExpression || node.type === AST_NODE_TYPES95.TSSatisfiesExpression || node.type === AST_NODE_TYPES95.TSTypeAssertion) node = node.expression;
+  return node.type === AST_NODE_TYPES95.MemberExpression && node.object.type === AST_NODE_TYPES95.ThisExpression ? staticMemberName7(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === AST_NODE_TYPES94.ClassDeclaration || current.type === AST_NODE_TYPES94.ClassExpression || current.type === AST_NODE_TYPES94.FunctionDeclaration || current.type === AST_NODE_TYPES94.FunctionExpression) return;
-    if (current.type === AST_NODE_TYPES94.CallExpression) {
+    if (current.type === AST_NODE_TYPES95.ClassDeclaration || current.type === AST_NODE_TYPES95.ClassExpression || current.type === AST_NODE_TYPES95.FunctionDeclaration || current.type === AST_NODE_TYPES95.FunctionExpression) return;
+    if (current.type === AST_NODE_TYPES95.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
     forEachOwnAstChild(current, visit);
   };
   for (const member of body2.body) {
-    if (member.type === AST_NODE_TYPES94.StaticBlock || member.static) continue;
-    if (member.type === AST_NODE_TYPES94.MethodDefinition) {
+    if (member.type === AST_NODE_TYPES95.StaticBlock || member.static) continue;
+    if (member.type === AST_NODE_TYPES95.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== AST_NODE_TYPES94.PropertyDefinition || member.value === null) continue;
+    if (member.type !== AST_NODE_TYPES95.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === AST_NODE_TYPES94.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === AST_NODE_TYPES95.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -20564,25 +20690,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES94.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES95.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES95.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   function collectPublicCallable(member) {
-    if (member.type === AST_NODE_TYPES94.PropertyDefinition) {
+    if (member.type === AST_NODE_TYPES95.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") return;
-      if (member.key.type === AST_NODE_TYPES94.PrivateIdentifier) return;
-      if (member.value?.type !== AST_NODE_TYPES94.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES94.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES94.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES94.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES94.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) return;
+      if (member.key.type === AST_NODE_TYPES95.PrivateIdentifier) return;
+      if (member.value?.type !== AST_NODE_TYPES95.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES95.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES95.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES95.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES95.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) return;
       names.push(declaredMemberName(member) ?? "\u2026");
       return;
     }
-    if (member.type !== AST_NODE_TYPES94.MethodDefinition) return;
+    if (member.type !== AST_NODE_TYPES95.MethodDefinition) return;
     if (member.kind !== "method" || member.static) return;
     if (member.accessibility === "private" || member.accessibility === "protected") return;
-    if (member.key.type === AST_NODE_TYPES94.PrivateIdentifier) return;
+    if (member.key.type === AST_NODE_TYPES95.PrivateIdentifier) return;
     names.push(declaredMemberName(member) ?? "\u2026");
   }
   for (const member of body2.body) {
@@ -20593,13 +20719,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES94.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === AST_NODE_TYPES95.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 === AST_NODE_TYPES94.TSTypeReference && result.typeName.type === AST_NODE_TYPES94.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === AST_NODE_TYPES95.TSTypeReference && result.typeName.type === AST_NODE_TYPES95.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -20607,10 +20733,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration || statement.type === AST_NODE_TYPES94.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES94.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === AST_NODE_TYPES95.ExportNamedDeclaration || statement.type === AST_NODE_TYPES95.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES95.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === AST_NODE_TYPES94.Identifier) {
+      if (declaration.superClass?.type === AST_NODE_TYPES95.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -20628,8 +20754,8 @@ function localClassAbstractness(program) {
   return classes;
 }
 function declaredMemberName(member) {
-  if (!member.computed && member.key.type === AST_NODE_TYPES94.Identifier) return member.key.name;
-  if (member.key.type === AST_NODE_TYPES94.Literal && typeof member.key.value === "string") return member.key.value;
+  if (!member.computed && member.key.type === AST_NODE_TYPES95.Identifier) return member.key.name;
+  if (member.key.type === AST_NODE_TYPES95.Literal && typeof member.key.value === "string") return member.key.value;
   return null;
 }
 function localInterfaceSurfaces(program) {
@@ -20637,28 +20763,28 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES94.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES94.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES94.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES95.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES95.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES95.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES95.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   function collectInterfaceSurface(statement) {
-    const declaration = statement.type === AST_NODE_TYPES94.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES94.TSTypeAliasDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES95.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES95.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES94.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES95.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === AST_NODE_TYPES94.TSTypeReference && part.typeName.type === AST_NODE_TYPES94.Identifier) {
+        if (part.type === AST_NODE_TYPES95.TSTypeReference && part.typeName.type === AST_NODE_TYPES95.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== AST_NODE_TYPES94.TSTypeLiteral) continue;
+        if (part.type !== AST_NODE_TYPES95.TSTypeLiteral) continue;
         addCallableMembers(part.members, callables2);
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       return;
     }
-    if (declaration?.type !== AST_NODE_TYPES94.TSInterfaceDeclaration) return;
+    if (declaration?.type !== AST_NODE_TYPES95.TSInterfaceDeclaration) return;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     addCallableMembers(declaration.body.body, callables);
     interfaces.set(declaration.id.name, callables);
@@ -20667,7 +20793,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === AST_NODE_TYPES94.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === AST_NODE_TYPES95.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -20677,16 +20803,16 @@ function localInterfaceSurfaces(program) {
   }
   function addCallableMembers(members, callables) {
     for (const member of members) {
-      if (member.type !== AST_NODE_TYPES94.TSMethodSignature && member.type !== AST_NODE_TYPES94.TSPropertySignature) continue;
+      if (member.type !== AST_NODE_TYPES95.TSMethodSignature && member.type !== AST_NODE_TYPES95.TSPropertySignature) continue;
       const name = declaredMemberName(member);
       if (name === null) continue;
-      if (member.type === AST_NODE_TYPES94.TSMethodSignature) {
+      if (member.type === AST_NODE_TYPES95.TSMethodSignature) {
         callables.add(name);
         continue;
       }
-      if (member.type !== AST_NODE_TYPES94.TSPropertySignature) continue;
+      if (member.type !== AST_NODE_TYPES95.TSPropertySignature) continue;
       const annotation = member.typeAnnotation?.typeAnnotation;
-      if (annotation?.type === AST_NODE_TYPES94.TSFunctionType || annotation?.type === AST_NODE_TYPES94.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES94.Identifier && functionAliases.has(annotation.typeName.name)) callables.add(name);
+      if (annotation?.type === AST_NODE_TYPES95.TSFunctionType || annotation?.type === AST_NODE_TYPES95.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES95.Identifier && functionAliases.has(annotation.typeName.name)) callables.add(name);
     }
   }
   function expandInheritedSurfaces() {
@@ -20715,7 +20841,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== AST_NODE_TYPES94.Identifier) return true;
+    if (node.superClass.type !== AST_NODE_TYPES95.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -20756,7 +20882,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 === AST_NODE_TYPES94.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === AST_NODE_TYPES95.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -20798,7 +20924,7 @@ function hasStructuralPort(name, methods, interfaces) {
 function implementedSurfaceCovers(node, methods, classes, interfaces) {
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== AST_NODE_TYPES94.Identifier) return true;
+    if (implementation.expression.type !== AST_NODE_TYPES95.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -20812,7 +20938,7 @@ function implementedSurfaceCovers(node, methods, classes, interfaces) {
 }
 
 // src/rules/require-sql-access-class.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES95, ASTUtils as ASTUtils47 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES96, ASTUtils as ASTUtils48 } from "@typescript-eslint/utils";
 var DIRECT_EXECUTION_METHODS = /* @__PURE__ */ new Set([
   "all",
   "batch",
@@ -20908,9 +21034,9 @@ var REQUIRE_SQL_ACCESS_CLASS_DOCUMENTATION = {
   ]
 };
 function memberName7(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES95.Identifier)
+  if (!node.computed && node.property.type === AST_NODE_TYPES96.Identifier)
     return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES95.Literal && typeof node.property.value === "string")
+  if (node.computed && node.property.type === AST_NODE_TYPES96.Literal && typeof node.property.value === "string")
     return node.property.value;
   return null;
 }
@@ -20922,89 +21048,89 @@ function isDatabaseOperation(method, receiver) {
   return BUILDER_SHORT_TERMINALS.has(method) && expressionCallsBuilder(receiver);
 }
 function databaseReceiver(node) {
-  if (node.type === AST_NODE_TYPES95.Identifier)
+  if (node.type === AST_NODE_TYPES96.Identifier)
     return DATABASE_NAMES.test(node.name);
-  if (node.type !== AST_NODE_TYPES95.MemberExpression) return false;
+  if (node.type !== AST_NODE_TYPES96.MemberExpression) return false;
   const name = memberName7(node);
   return name === "DB" || name !== null && DATABASE_NAMES.test(name);
 }
 function databaseRootMember(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES95.ChainExpression) {
+    if (current.type === AST_NODE_TYPES96.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.TSAsExpression || current.type === AST_NODE_TYPES95.TSNonNullExpression || current.type === AST_NODE_TYPES95.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES96.TSAsExpression || current.type === AST_NODE_TYPES96.TSNonNullExpression || current.type === AST_NODE_TYPES96.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES95.MemberExpression) return null;
+    if (current.type === AST_NODE_TYPES96.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES96.MemberExpression) return null;
       current = current.callee.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.MemberExpression) {
-      if (current.object.type === AST_NODE_TYPES95.ThisExpression)
+    if (current.type === AST_NODE_TYPES96.MemberExpression) {
+      if (current.object.type === AST_NODE_TYPES96.ThisExpression)
         return memberName7(current);
       current = current.object;
       continue;
     }
-    return current.type === AST_NODE_TYPES95.Identifier ? current.name : null;
+    return current.type === AST_NODE_TYPES96.Identifier ? current.name : null;
   }
 }
 function expressionHasDatabaseMarker(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES95.ChainExpression) {
+    if (current.type === AST_NODE_TYPES96.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.TSAsExpression || current.type === AST_NODE_TYPES95.TSNonNullExpression || current.type === AST_NODE_TYPES95.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES96.TSAsExpression || current.type === AST_NODE_TYPES96.TSNonNullExpression || current.type === AST_NODE_TYPES96.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES95.MemberExpression) return false;
+    if (current.type === AST_NODE_TYPES96.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES96.MemberExpression) return false;
       current = current.callee.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.MemberExpression) {
+    if (current.type === AST_NODE_TYPES96.MemberExpression) {
       const name = memberName7(current);
       if (name === "DB" || name !== null && DATABASE_NAMES.test(name))
         return true;
       current = current.object;
       continue;
     }
-    return current.type === AST_NODE_TYPES95.Identifier && DATABASE_NAMES.test(current.name);
+    return current.type === AST_NODE_TYPES96.Identifier && DATABASE_NAMES.test(current.name);
   }
 }
 function expressionCallsBuilder(node) {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES95.ChainExpression) {
+    if (current.type === AST_NODE_TYPES96.ChainExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.TSAsExpression || current.type === AST_NODE_TYPES95.TSNonNullExpression || current.type === AST_NODE_TYPES95.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES96.TSAsExpression || current.type === AST_NODE_TYPES96.TSNonNullExpression || current.type === AST_NODE_TYPES96.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES95.CallExpression) {
-      if (current.callee.type !== AST_NODE_TYPES95.MemberExpression) return false;
+    if (current.type === AST_NODE_TYPES96.CallExpression) {
+      if (current.callee.type !== AST_NODE_TYPES96.MemberExpression) return false;
       const name = memberName7(current.callee);
       if (name !== null && BUILDER_METHODS.has(name)) return true;
       current = current.callee.object;
       continue;
     }
-    if (current.type !== AST_NODE_TYPES95.MemberExpression) return false;
+    if (current.type !== AST_NODE_TYPES96.MemberExpression) return false;
     current = current.object;
   }
 }
 function owningClass2(node) {
   let current = node.parent;
   while (current != null) {
-    if (current.type === AST_NODE_TYPES95.ClassDeclaration || current.type === AST_NODE_TYPES95.ClassExpression)
+    if (current.type === AST_NODE_TYPES96.ClassDeclaration || current.type === AST_NODE_TYPES96.ClassExpression)
       return current;
     current = current.parent;
   }
@@ -21013,25 +21139,25 @@ function owningClass2(node) {
 function injectedMembers(owner) {
   const injected = /* @__PURE__ */ new Set();
   const constructor = owner.body.body.find(
-    (member) => member.type === AST_NODE_TYPES95.MethodDefinition && member.kind === "constructor"
+    (member) => member.type === AST_NODE_TYPES96.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 !== AST_NODE_TYPES95.TSParameterProperty) continue;
-    const value = parameter.parameter.type === AST_NODE_TYPES95.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
-    if (value.type === AST_NODE_TYPES95.Identifier) injected.add(value.name);
+    if (parameter.type !== AST_NODE_TYPES96.TSParameterProperty) continue;
+    const value = parameter.parameter.type === AST_NODE_TYPES96.AssignmentPattern ? parameter.parameter.left : parameter.parameter;
+    if (value.type === AST_NODE_TYPES96.Identifier) injected.add(value.name);
   }
   const body2 = constructor.value.body;
   if (body2 === null) return injected;
   function collectInjectedMember(statement) {
-    if (statement.type !== AST_NODE_TYPES95.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES95.AssignmentExpression || statement.expression.operator !== "=") return;
+    if (statement.type !== AST_NODE_TYPES96.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES96.AssignmentExpression || statement.expression.operator !== "=") return;
     const { left, right } = statement.expression;
-    if (left.type !== AST_NODE_TYPES95.MemberExpression) return;
+    if (left.type !== AST_NODE_TYPES96.MemberExpression) return;
     const target = thisRootMember(left);
     if (target === null) return;
-    const source = right.type === AST_NODE_TYPES95.Identifier ? right.name : right.type === AST_NODE_TYPES95.MemberExpression && right.object.type === AST_NODE_TYPES95.Identifier ? right.object.name : null;
+    const source = right.type === AST_NODE_TYPES96.Identifier ? right.name : right.type === AST_NODE_TYPES96.MemberExpression && right.object.type === AST_NODE_TYPES96.Identifier ? right.object.name : null;
     if (source !== null && parameters.has(source)) injected.add(target);
   }
   for (const statement of body2.body) {
@@ -21042,26 +21168,26 @@ function injectedMembers(owner) {
 function thisRootMember(node) {
   let current = node;
   let root = null;
-  while (current.type === AST_NODE_TYPES95.MemberExpression) {
+  while (current.type === AST_NODE_TYPES96.MemberExpression) {
     const name = memberName7(current);
     if (name === null) return null;
     root = name;
     current = current.object;
   }
-  return current.type === AST_NODE_TYPES95.ThisExpression ? root : null;
+  return current.type === AST_NODE_TYPES96.ThisExpression ? root : null;
 }
 function parameterNames(parameter) {
   let value = parameter;
-  if (value.type === AST_NODE_TYPES95.TSParameterProperty) value = value.parameter;
-  if (value.type === AST_NODE_TYPES95.AssignmentPattern) value = value.left;
-  if (value.type === AST_NODE_TYPES95.Identifier) return /* @__PURE__ */ new Set([value.name]);
-  if (value.type !== AST_NODE_TYPES95.ObjectPattern) return /* @__PURE__ */ new Set();
+  if (value.type === AST_NODE_TYPES96.TSParameterProperty) value = value.parameter;
+  if (value.type === AST_NODE_TYPES96.AssignmentPattern) value = value.left;
+  if (value.type === AST_NODE_TYPES96.Identifier) return /* @__PURE__ */ new Set([value.name]);
+  if (value.type !== AST_NODE_TYPES96.ObjectPattern) return /* @__PURE__ */ new Set();
   return new Set(
     value.properties.flatMap((property) => {
-      if (property.type === AST_NODE_TYPES95.RestElement)
-        return property.argument.type === AST_NODE_TYPES95.Identifier ? [property.argument.name] : [];
-      const target = property.value.type === AST_NODE_TYPES95.AssignmentPattern ? property.value.left : property.value;
-      return target.type === AST_NODE_TYPES95.Identifier ? [target.name] : [];
+      if (property.type === AST_NODE_TYPES96.RestElement)
+        return property.argument.type === AST_NODE_TYPES96.Identifier ? [property.argument.name] : [];
+      const target = property.value.type === AST_NODE_TYPES96.AssignmentPattern ? property.value.left : property.value;
+      return target.type === AST_NODE_TYPES96.Identifier ? [target.name] : [];
     })
   );
 }
@@ -21085,17 +21211,17 @@ var require_sql_access_class_default = createRule({
     function knownNonDatabase(node, seen = /* @__PURE__ */ new Set()) {
       if (seen.has(node)) return false;
       seen.add(node);
-      if (node.type === AST_NODE_TYPES95.Identifier) {
-        const binding = ASTUtils47.findVariable(context.sourceCode.getScope(node), node.name);
+      if (node.type === AST_NODE_TYPES96.Identifier) {
+        const binding = ASTUtils48.findVariable(context.sourceCode.getScope(node), node.name);
         if (binding?.defs.length !== 1 || binding.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         const definition = binding.defs[0];
         return definition?.type === "Variable" && definition.node.init !== null && knownNonDatabase(definition.node.init, seen);
       }
-      return node.type === AST_NODE_TYPES95.NewExpression && node.callee.type === AST_NODE_TYPES95.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (ASTUtils47.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
+      return node.type === AST_NODE_TYPES96.NewExpression && node.callee.type === AST_NODE_TYPES96.Identifier && ["Map", "WeakMap", "URLSearchParams"].includes(node.callee.name) && (ASTUtils48.findVariable(context.sourceCode.getScope(node.callee), node.callee.name)?.defs.length ?? 0) === 0;
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES95.MemberExpression)
+        if (node.callee.type !== AST_NODE_TYPES96.MemberExpression)
           return;
         const method = memberName7(node.callee);
         if (knownNonDatabase(node.callee.object)) return;
@@ -21113,7 +21239,7 @@ var require_sql_access_class_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES96 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES97 } from "@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.",
@@ -21128,34 +21254,34 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression5(node) {
-  if (node.type === AST_NODE_TYPES96.TSAsExpression || node.type === AST_NODE_TYPES96.TSSatisfiesExpression || node.type === AST_NODE_TYPES96.TSNonNullExpression || node.type === AST_NODE_TYPES96.TSTypeAssertion) {
+  if (node.type === AST_NODE_TYPES97.TSAsExpression || node.type === AST_NODE_TYPES97.TSSatisfiesExpression || node.type === AST_NODE_TYPES97.TSNonNullExpression || node.type === AST_NODE_TYPES97.TSTypeAssertion) {
     return unwrapExpression5(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression5(node);
-  if (value.type === AST_NODE_TYPES96.Literal) {
+  if (value.type === AST_NODE_TYPES97.Literal) {
     return true;
   }
-  if (value.type === AST_NODE_TYPES96.TemplateLiteral) {
+  if (value.type === AST_NODE_TYPES97.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === AST_NODE_TYPES96.ArrayExpression) {
+  if (value.type === AST_NODE_TYPES97.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== AST_NODE_TYPES96.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== AST_NODE_TYPES97.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === AST_NODE_TYPES96.ObjectExpression) {
+  if (value.type === AST_NODE_TYPES97.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === AST_NODE_TYPES96.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES96.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === AST_NODE_TYPES97.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES97.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName6(property) {
-  if (!property.computed && property.key.type === AST_NODE_TYPES96.Identifier) return property.key.name;
-  return property.key.type === AST_NODE_TYPES96.Literal && typeof property.key.value === "string" ? property.key.value : null;
+  if (!property.computed && property.key.type === AST_NODE_TYPES97.Identifier) return property.key.name;
+  return property.key.type === AST_NODE_TYPES97.Literal && typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
   name: "require-static-next-matcher",
@@ -21177,19 +21303,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== AST_NODE_TYPES96.VariableDeclaration) {
+        if (node.declaration?.type !== AST_NODE_TYPES97.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== AST_NODE_TYPES96.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== AST_NODE_TYPES97.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression5(declaration.init);
-          if (config.type !== AST_NODE_TYPES96.ObjectExpression) {
+          if (config.type !== AST_NODE_TYPES97.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== AST_NODE_TYPES96.Property || propertyName6(property) !== "matcher" || property.value.type === AST_NODE_TYPES96.AssignmentPattern) {
+            if (property.type !== AST_NODE_TYPES97.Property || propertyName6(property) !== "matcher" || property.value.type === AST_NODE_TYPES97.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -21203,7 +21329,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES97, ASTUtils as ASTUtils48 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES98, ASTUtils as ASTUtils49 } from "@typescript-eslint/utils";
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
   summary: "Require explicit form-level initialization or a field default for directly bound Controller fields.",
   rationale: "React Hook Form exposes form-level defaultValues/values and field-level defaultValue as its explicit initialization mechanisms. A directly bound controlled field should not omit both mechanisms.",
@@ -21236,12 +21362,12 @@ var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
 };
 function staticPropertyName(property) {
   if (property.computed) return null;
-  if (property.key.type === AST_NODE_TYPES97.Identifier) return property.key.name;
-  if (property.key.type === AST_NODE_TYPES97.Literal && typeof property.key.value === "string") return property.key.value;
+  if (property.key.type === AST_NODE_TYPES98.Identifier) return property.key.name;
+  if (property.key.type === AST_NODE_TYPES98.Literal && typeof property.key.value === "string") return property.key.value;
   return null;
 }
 function unwrapExpression6(node) {
-  if (node.type === AST_NODE_TYPES97.TSAsExpression || node.type === AST_NODE_TYPES97.TSSatisfiesExpression || node.type === AST_NODE_TYPES97.TSNonNullExpression || node.type === AST_NODE_TYPES97.TSTypeAssertion) return unwrapExpression6(node.expression);
+  if (node.type === AST_NODE_TYPES98.TSAsExpression || node.type === AST_NODE_TYPES98.TSSatisfiesExpression || node.type === AST_NODE_TYPES98.TSNonNullExpression || node.type === AST_NODE_TYPES98.TSTypeAssertion) return unwrapExpression6(node.expression);
   return node;
 }
 var require_use_form_default_values_default = createRule({
@@ -21258,7 +21384,7 @@ var require_use_form_default_values_default = createRule({
     const imported = /* @__PURE__ */ new Map();
     const uninitializedForms = /* @__PURE__ */ new Set();
     const uninitializedControls = /* @__PURE__ */ new Set();
-    const bindingNamed = (node, name) => ASTUtils48.findVariable(context.sourceCode.getScope(node), name);
+    const bindingNamed = (node, name) => ASTUtils49.findVariable(context.sourceCode.getScope(node), name);
     const bindingOf = (node) => bindingNamed(node, node.name);
     const stable = (variable) => !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
     const importedKind = (node) => {
@@ -21271,44 +21397,44 @@ var require_use_form_default_values_default = createRule({
     };
     const isDefinitelyUndefined = (node) => {
       const value = unwrapExpression6(node);
-      return value.type === AST_NODE_TYPES97.UnaryExpression && value.operator === "void" || value.type === AST_NODE_TYPES97.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
+      return value.type === AST_NODE_TYPES98.UnaryExpression && value.operator === "void" || value.type === AST_NODE_TYPES98.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
     };
     const initializationState = (node) => {
       if (node === void 0) return "uninitialized";
-      if (node.type !== AST_NODE_TYPES97.ObjectExpression) return "unknown";
+      if (node.type !== AST_NODE_TYPES98.ObjectExpression) return "unknown";
       const initialization = /* @__PURE__ */ new Map();
       for (const property of node.properties) {
-        if (property.type === AST_NODE_TYPES97.SpreadElement || property.computed) return "unknown";
-        if (property.type !== AST_NODE_TYPES97.Property) continue;
+        if (property.type === AST_NODE_TYPES98.SpreadElement || property.computed) return "unknown";
+        if (property.type !== AST_NODE_TYPES98.Property) continue;
         const name = staticPropertyName(property);
         if (name === "defaultValues" || name === "values") initialization.set(name, !isDefinitelyUndefined(property.value));
       }
       return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
     };
     const uninitializedUseFormCall = (node) => {
-      if (node.type !== AST_NODE_TYPES97.CallExpression || node.callee.type !== AST_NODE_TYPES97.Identifier || importedKind(node.callee) !== "useForm") return false;
+      if (node.type !== AST_NODE_TYPES98.CallExpression || node.callee.type !== AST_NODE_TYPES98.Identifier || importedKind(node.callee) !== "useForm") return false;
       const options = node.arguments[0];
-      return options?.type !== AST_NODE_TYPES97.SpreadElement && initializationState(options) === "uninitialized";
+      return options?.type !== AST_NODE_TYPES98.SpreadElement && initializationState(options) === "uninitialized";
     };
     const isUninitializedForm = (node) => {
-      if (node.type !== AST_NODE_TYPES97.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES98.Identifier) return false;
       const variable = bindingOf(node);
       return variable !== null && stable(variable) && uninitializedForms.has(variable);
     };
     const isUninitializedControl = (node) => {
-      if (node.type === AST_NODE_TYPES97.Identifier) {
+      if (node.type === AST_NODE_TYPES98.Identifier) {
         const variable = bindingOf(node);
         return variable !== null && stable(variable) && uninitializedControls.has(variable);
       }
-      return node.type === AST_NODE_TYPES97.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES97.Identifier && node.property.name === "control" && isUninitializedForm(node.object);
+      return node.type === AST_NODE_TYPES98.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES98.Identifier && node.property.name === "control" && isUninitializedForm(node.object);
     };
     const fieldOptionsNeedDefault = (node) => {
-      if (node?.type !== AST_NODE_TYPES97.ObjectExpression) return false;
+      if (node?.type !== AST_NODE_TYPES98.ObjectExpression) return false;
       let control = null;
       let hasDefault = false;
       for (const property of node.properties) {
-        if (property.type === AST_NODE_TYPES97.SpreadElement || property.computed) return false;
-        if (property.type !== AST_NODE_TYPES97.Property) continue;
+        if (property.type === AST_NODE_TYPES98.SpreadElement || property.computed) return false;
+        if (property.type !== AST_NODE_TYPES98.Property) continue;
         const name = staticPropertyName(property);
         if (name === "control") control = property.value;
         if (name === "defaultValue") hasDefault = !isDefinitelyUndefined(property.value);
@@ -21318,14 +21444,14 @@ var require_use_form_default_values_default = createRule({
     const jsxAttribute = (node, name) => {
       let result = null;
       for (const attribute of node.attributes) {
-        if (attribute.type === AST_NODE_TYPES97.JSXSpreadAttribute) return null;
-        if (attribute.name.type === AST_NODE_TYPES97.JSXIdentifier && attribute.name.name === name) result = attribute;
+        if (attribute.type === AST_NODE_TYPES98.JSXSpreadAttribute) return null;
+        if (attribute.name.type === AST_NODE_TYPES98.JSXIdentifier && attribute.name.name === name) result = attribute;
       }
       return result;
     };
     const trackDestructuredControl = (pattern) => {
       for (const property of pattern.properties) {
-        if (property.type !== AST_NODE_TYPES97.Property || staticPropertyName(property) !== "control" || property.value.type !== AST_NODE_TYPES97.Identifier) continue;
+        if (property.type !== AST_NODE_TYPES98.Property || staticPropertyName(property) !== "control" || property.value.type !== AST_NODE_TYPES98.Identifier) continue;
         const variable = bindingOf(property.value);
         if (variable !== null) uninitializedControls.add(variable);
       }
@@ -21334,8 +21460,8 @@ var require_use_form_default_values_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type !== AST_NODE_TYPES97.ImportSpecifier) continue;
-          const name = specifier.imported.type === AST_NODE_TYPES97.Identifier ? specifier.imported.name : String(specifier.imported.value);
+          if (specifier.type !== AST_NODE_TYPES98.ImportSpecifier) continue;
+          const name = specifier.imported.type === AST_NODE_TYPES98.Identifier ? specifier.imported.name : String(specifier.imported.value);
           if (name !== "Controller" && name !== "useController" && name !== "useForm") continue;
           const variable = bindingOf(specifier.local);
           if (variable !== null) imported.set(variable, name);
@@ -21344,34 +21470,34 @@ var require_use_form_default_values_default = createRule({
       VariableDeclarator(node) {
         if (node.init === null) return;
         if (uninitializedUseFormCall(node.init)) {
-          if (node.id.type === AST_NODE_TYPES97.Identifier) {
+          if (node.id.type === AST_NODE_TYPES98.Identifier) {
             const variable = bindingOf(node.id);
             if (variable !== null) uninitializedForms.add(variable);
-          } else if (node.id.type === AST_NODE_TYPES97.ObjectPattern) {
+          } else if (node.id.type === AST_NODE_TYPES98.ObjectPattern) {
             trackDestructuredControl(node.id);
           }
           return;
         }
-        if (node.id.type === AST_NODE_TYPES97.ObjectPattern && isUninitializedForm(node.init)) {
+        if (node.id.type === AST_NODE_TYPES98.ObjectPattern && isUninitializedForm(node.init)) {
           trackDestructuredControl(node.id);
           return;
         }
-        if (node.id.type === AST_NODE_TYPES97.Identifier && node.init.type === AST_NODE_TYPES97.MemberExpression && !node.init.computed && node.init.property.type === AST_NODE_TYPES97.Identifier && node.init.property.name === "control" && isUninitializedForm(node.init.object)) {
+        if (node.id.type === AST_NODE_TYPES98.Identifier && node.init.type === AST_NODE_TYPES98.MemberExpression && !node.init.computed && node.init.property.type === AST_NODE_TYPES98.Identifier && node.init.property.name === "control" && isUninitializedForm(node.init.object)) {
           const variable = bindingOf(node.id);
           if (variable !== null) uninitializedControls.add(variable);
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES97.Identifier || importedKind(node.callee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === AST_NODE_TYPES97.SpreadElement ? void 0 : node.arguments[0])) return;
+        if (node.callee.type !== AST_NODE_TYPES98.Identifier || importedKind(node.callee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === AST_NODE_TYPES98.SpreadElement ? void 0 : node.arguments[0])) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       },
       JSXOpeningElement(node) {
-        if (node.name.type !== AST_NODE_TYPES97.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
-        if (node.attributes.some((attribute) => attribute.type === AST_NODE_TYPES97.JSXSpreadAttribute)) return;
+        if (node.name.type !== AST_NODE_TYPES98.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.attributes.some((attribute) => attribute.type === AST_NODE_TYPES98.JSXSpreadAttribute)) return;
         const control = jsxAttribute(node, "control");
-        if (control?.value?.type !== AST_NODE_TYPES97.JSXExpressionContainer || control.value.expression.type === AST_NODE_TYPES97.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
+        if (control?.value?.type !== AST_NODE_TYPES98.JSXExpressionContainer || control.value.expression.type === AST_NODE_TYPES98.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
         const defaultValue = jsxAttribute(node, "defaultValue");
-        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== AST_NODE_TYPES97.JSXExpressionContainer || defaultValue.value.expression.type !== AST_NODE_TYPES97.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
+        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== AST_NODE_TYPES98.JSXExpressionContainer || defaultValue.value.expression.type !== AST_NODE_TYPES98.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       }
     };
@@ -21447,8 +21573,8 @@ var require_use_server_in_actions_file_default = createRule({
 
 // src/rules/require-zod-form-validation.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES98,
-  ASTUtils as ASTUtils49
+  AST_NODE_TYPES as AST_NODE_TYPES99,
+  ASTUtils as ASTUtils50
 } from "@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.",
@@ -21475,14 +21601,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES98.Identifier) {
+    if (current.type === AST_NODE_TYPES99.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES98.CallExpression) {
+    if (current.type === AST_NODE_TYPES99.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES98.MemberExpression) {
+    if (current.type === AST_NODE_TYPES99.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -21491,12 +21617,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === AST_NODE_TYPES98.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES99.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES98.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES99.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES98.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES98.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES99.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES99.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -21517,7 +21643,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => ASTUtils49.findVariable(
+    const resolvedBinding = (identifier) => ASTUtils50.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -21527,16 +21653,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES98.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES99.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === AST_NODE_TYPES98.ObjectExpression || init?.type === AST_NODE_TYPES98.ArrayExpression || init?.type === AST_NODE_TYPES98.Literal || init?.type === AST_NODE_TYPES98.ArrowFunctionExpression || init?.type === AST_NODE_TYPES98.FunctionExpression;
+      return init?.type === AST_NODE_TYPES99.ObjectExpression || init?.type === AST_NODE_TYPES99.ArrayExpression || init?.type === AST_NODE_TYPES99.Literal || init?.type === AST_NODE_TYPES99.ArrowFunctionExpression || init?.type === AST_NODE_TYPES99.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== AST_NODE_TYPES98.CallExpression) return false;
+      if (node.type !== AST_NODE_TYPES99.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES98.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES98.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES99.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES99.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -21545,14 +21671,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 !== AST_NODE_TYPES98.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES99.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 === AST_NODE_TYPES98.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES99.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -21563,8 +21689,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES98.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES98.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES99.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES99.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -21573,15 +21699,15 @@ var require_zod_form_validation_default = createRule({
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
         if (isZodParseCall(parent)) return parent;
-        if (parent.type === AST_NODE_TYPES98.CallExpression && parent.callee.type === AST_NODE_TYPES98.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES99.CallExpression && parent.callee.type === AST_NODE_TYPES99.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES98.CallExpression && parent.callee.type === AST_NODE_TYPES98.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES98.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES98.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES99.CallExpression && parent.callee.type === AST_NODE_TYPES99.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES99.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES99.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES98.CallExpression || parent.type === AST_NODE_TYPES98.NewExpression || parent.type === AST_NODE_TYPES98.TaggedTemplateExpression || parent.type === AST_NODE_TYPES98.ArrowFunctionExpression || parent.type === AST_NODE_TYPES98.FunctionExpression || parent.type === AST_NODE_TYPES98.FunctionDeclaration) return null;
+        if (parent.type === AST_NODE_TYPES99.CallExpression || parent.type === AST_NODE_TYPES99.NewExpression || parent.type === AST_NODE_TYPES99.TaggedTemplateExpression || parent.type === AST_NODE_TYPES99.ArrowFunctionExpression || parent.type === AST_NODE_TYPES99.FunctionExpression || parent.type === AST_NODE_TYPES99.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
@@ -21589,16 +21715,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 === AST_NODE_TYPES98.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES98.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES99.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES99.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === AST_NODE_TYPES98.TSAsExpression || parent.type === AST_NODE_TYPES98.TSSatisfiesExpression || parent.type === AST_NODE_TYPES98.TSNonNullExpression || parent.type === AST_NODE_TYPES98.ChainExpression) && parent.expression === current) {
+      while ((parent.type === AST_NODE_TYPES99.TSAsExpression || parent.type === AST_NODE_TYPES99.TSSatisfiesExpression || parent.type === AST_NODE_TYPES99.TSNonNullExpression || parent.type === AST_NODE_TYPES99.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === AST_NODE_TYPES98.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES98.Identifier) {
+      if (parent.type === AST_NODE_TYPES99.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES99.Identifier) {
         return parent;
       }
       return null;
@@ -21607,7 +21733,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === AST_NODE_TYPES98.BlockStatement || parent.type === AST_NODE_TYPES98.Program) {
+        if (parent.type === AST_NODE_TYPES99.BlockStatement || parent.type === AST_NODE_TYPES99.Program) {
           return current;
         }
         current = parent;
@@ -21616,12 +21742,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES98.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES98.Identifier ? callee.property.name : null;
+      return callee.type === AST_NODE_TYPES99.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES99.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === AST_NODE_TYPES98.LogicalExpression || current.type === AST_NODE_TYPES98.ConditionalExpression) {
+        if (current.type === AST_NODE_TYPES99.LogicalExpression || current.type === AST_NODE_TYPES99.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -21631,7 +21757,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 === AST_NODE_TYPES98.AwaitExpression) return true;
+        if (current.type === AST_NODE_TYPES99.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -21644,7 +21770,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 !== AST_NODE_TYPES98.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES98.ExpressionStatement) {
+      if (validationStatement.type !== AST_NODE_TYPES99.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES99.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -21656,16 +21782,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === AST_NODE_TYPES98.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === AST_NODE_TYPES99.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== AST_NODE_TYPES98.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== AST_NODE_TYPES99.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === AST_NODE_TYPES98.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === AST_NODE_TYPES99.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES98.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES98.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES99.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES99.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -21676,23 +21802,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === AST_NODE_TYPES98.ReturnStatement || node.type === AST_NODE_TYPES98.ThrowStatement) {
+      if (node.type === AST_NODE_TYPES99.ReturnStatement || node.type === AST_NODE_TYPES99.ThrowStatement) {
         return true;
       }
-      if (node.type !== AST_NODE_TYPES98.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== AST_NODE_TYPES99.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 !== AST_NODE_TYPES98.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES98.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== AST_NODE_TYPES99.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES99.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === AST_NODE_TYPES98.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === AST_NODE_TYPES99.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === AST_NODE_TYPES98.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === AST_NODE_TYPES99.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -21712,7 +21838,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 === AST_NODE_TYPES98.Identifier
+        (identifier) => identifier.type === AST_NODE_TYPES99.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -21738,7 +21864,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 === AST_NODE_TYPES98.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES98.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES98.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES98.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES99.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES99.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES99.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES99.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -21827,7 +21953,7 @@ function expressionCallableName(current) {
 }
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES99, ASTUtils as ASTUtils50 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES100, ASTUtils as ASTUtils51 } from "@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.",
@@ -21845,7 +21971,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === AST_NODE_TYPES99.ArrowFunctionExpression || node.type === AST_NODE_TYPES99.FunctionDeclaration || node.type === AST_NODE_TYPES99.FunctionExpression;
+  return node.type === AST_NODE_TYPES100.ArrowFunctionExpression || node.type === AST_NODE_TYPES100.FunctionDeclaration || node.type === AST_NODE_TYPES100.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -21946,8 +22072,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 === AST_NODE_TYPES99.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === AST_NODE_TYPES99.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === AST_NODE_TYPES100.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === AST_NODE_TYPES100.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -21971,7 +22097,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 !== AST_NODE_TYPES99.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES100.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -21986,17 +22112,17 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   function collectNamedExports(statement) {
-    if (statement.type !== AST_NODE_TYPES99.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
-    if (statement.declaration?.type === AST_NODE_TYPES99.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== AST_NODE_TYPES100.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) return;
+    if (statement.declaration?.type === AST_NODE_TYPES100.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === AST_NODE_TYPES99.VariableDeclaration) {
+    if (statement.declaration?.type === AST_NODE_TYPES100.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === AST_NODE_TYPES99.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === AST_NODE_TYPES100.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES99.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES100.Identifier) {
         names.add(specifier.local.name);
       }
     }
@@ -22005,22 +22131,22 @@ function exportedNames(program) {
     collectNamedExports(statement);
   }
   for (const statement of program.body) {
-    if (statement.type === AST_NODE_TYPES99.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES99.Identifier) names.add(statement.declaration.name);
-    if (statement.type === AST_NODE_TYPES99.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES99.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === AST_NODE_TYPES100.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES100.Identifier) names.add(statement.declaration.name);
+    if (statement.type === AST_NODE_TYPES100.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES100.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === AST_NODE_TYPES99.ExportNamedDeclaration || statement.type === AST_NODE_TYPES99.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === AST_NODE_TYPES99.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === AST_NODE_TYPES100.ExportNamedDeclaration || statement.type === AST_NODE_TYPES100.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === AST_NODE_TYPES100.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== AST_NODE_TYPES99.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== AST_NODE_TYPES100.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === AST_NODE_TYPES99.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === AST_NODE_TYPES100.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -22033,21 +22159,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName2(node) {
-  if (node.key.type === AST_NODE_TYPES99.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === AST_NODE_TYPES99.Identifier ? node.key.name : null;
+  if (node.key.type === AST_NODE_TYPES100.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === AST_NODE_TYPES100.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES99.Identifier ? ASTUtils50.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES100.Identifier ? ASTUtils51.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== AST_NODE_TYPES99.ThisExpression && !isClassReference) return null;
-  if (node.property.type === AST_NODE_TYPES99.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES99.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES99.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== AST_NODE_TYPES100.ThisExpression && !isClassReference) return null;
+  if (node.property.type === AST_NODE_TYPES100.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES100.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES100.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === AST_NODE_TYPES99.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES99.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES99.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === AST_NODE_TYPES100.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES100.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES100.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -22056,7 +22182,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES99.MethodDefinition
+    (member) => member.type === AST_NODE_TYPES100.MethodDefinition
   );
   const counts = classMethodCounts(node.body, methods);
   const scopeDefinitions = methods.flatMap((method) => {
@@ -22065,7 +22191,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName2(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES99.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES100.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -22074,11 +22200,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils50.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils51.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === AST_NODE_TYPES99.ClassExpression && node.parent.type === AST_NODE_TYPES99.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES99.Identifier) {
-    const outer = ASTUtils50.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === AST_NODE_TYPES100.ClassExpression && node.parent.type === AST_NODE_TYPES100.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES100.Identifier) {
+    const outer = ASTUtils51.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   function collectMethodCalls(method) {
@@ -22094,21 +22220,21 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === AST_NODE_TYPES99.TSAsExpression || current?.type === AST_NODE_TYPES99.TSSatisfiesExpression || current?.type === AST_NODE_TYPES99.TSNonNullExpression) current = current.expression;
-      return current?.type === AST_NODE_TYPES99.ThisExpression;
+      while (current?.type === AST_NODE_TYPES100.TSAsExpression || current?.type === AST_NODE_TYPES100.TSSatisfiesExpression || current?.type === AST_NODE_TYPES100.TSNonNullExpression) current = current.expression;
+      return current?.type === AST_NODE_TYPES100.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== AST_NODE_TYPES99.VariableDeclarator && current.type !== AST_NODE_TYPES99.AssignmentPattern) return;
-      if (current.type === AST_NODE_TYPES99.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES99.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === AST_NODE_TYPES99.VariableDeclarator ? current.id : current.left;
-      const value = current.type === AST_NODE_TYPES99.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== AST_NODE_TYPES100.VariableDeclarator && current.type !== AST_NODE_TYPES100.AssignmentPattern) return;
+      if (current.type === AST_NODE_TYPES100.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES100.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === AST_NODE_TYPES100.VariableDeclarator ? current.id : current.left;
+      const value = current.type === AST_NODE_TYPES100.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === AST_NODE_TYPES99.ObjectPattern) {
+      if (binding.type === AST_NODE_TYPES100.ObjectPattern) {
         pinDestructuredMembers(binding);
         return;
       }
-      if (binding.type !== AST_NODE_TYPES99.Identifier) return;
-      const variable = ASTUtils50.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== AST_NODE_TYPES100.Identifier) return;
+      const variable = ASTUtils51.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -22122,18 +22248,18 @@ function classScope(context, node, computedReferenceNames) {
     }
     function pinDestructuredMembers(binding) {
       for (const property of binding.properties) {
-        if (property.type === AST_NODE_TYPES99.RestElement) {
+        if (property.type === AST_NODE_TYPES100.RestElement) {
           for (const name of privateNames) pinned.add(name);
-        } else if (property.key.type === AST_NODE_TYPES99.Identifier && privateNames.has(property.key.name)) {
+        } else if (property.key.type === AST_NODE_TYPES100.Identifier && privateNames.has(property.key.name)) {
           pinned.add(property.key.name);
         }
       }
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === AST_NODE_TYPES99.VariableDeclarator && current.id.type === AST_NODE_TYPES99.ObjectPattern && thisValue(current.init)) {
+      if (current.type === AST_NODE_TYPES100.VariableDeclarator && current.id.type === AST_NODE_TYPES100.ObjectPattern && thisValue(current.init)) {
         pinDestructuredMembers(current.id);
       }
-      if (current.type !== AST_NODE_TYPES99.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES100.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -22141,12 +22267,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES99.Identifier ? ASTUtils50.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES100.Identifier ? ASTUtils51.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES99.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES100.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -22167,9 +22293,9 @@ function classScope(context, node, computedReferenceNames) {
   }
   for (const method of methods) collectMethodCalls(method);
   for (const member of node.body.body) {
-    if (member.type === AST_NODE_TYPES99.MethodDefinition || member.type === AST_NODE_TYPES99.TSAbstractMethodDefinition) continue;
+    if (member.type === AST_NODE_TYPES100.MethodDefinition || member.type === AST_NODE_TYPES100.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== AST_NODE_TYPES99.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES100.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -22191,12 +22317,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case AST_NODE_TYPES99.StaticBlock:
+    case AST_NODE_TYPES100.StaticBlock:
       return true;
-    case AST_NODE_TYPES99.PropertyDefinition:
-    case AST_NODE_TYPES99.AccessorProperty:
+    case AST_NODE_TYPES100.PropertyDefinition:
+    case AST_NODE_TYPES100.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case AST_NODE_TYPES99.MethodDefinition:
+    case AST_NODE_TYPES100.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -22228,7 +22354,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === AST_NODE_TYPES99.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES99.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === AST_NODE_TYPES100.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES100.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -22242,15 +22368,15 @@ function classMethodCounts(body2, methods) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of body2.body) {
-    if (member.type !== AST_NODE_TYPES99.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === AST_NODE_TYPES99.Identifier ? member.key.name : null;
+    if (member.type !== AST_NODE_TYPES100.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === AST_NODE_TYPES100.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   return counts;
 }
 
 // src/rules/source-coupled-test.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES100, ASTUtils as ASTUtils51 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES101, ASTUtils as ASTUtils52 } from "@typescript-eslint/utils";
 var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|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"]);
@@ -22322,21 +22448,21 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   ]
 };
 function staticMemberName8(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES100.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES100.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === AST_NODE_TYPES101.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES101.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap7(node) {
-  if (node.type === AST_NODE_TYPES100.AwaitExpression) return unwrap7(node.argument);
-  if (node.type === AST_NODE_TYPES100.ChainExpression) return unwrap7(node.expression);
-  if (node.type === AST_NODE_TYPES100.TSAsExpression || node.type === AST_NODE_TYPES100.TSNonNullExpression || node.type === AST_NODE_TYPES100.TSTypeAssertion) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES101.AwaitExpression) return unwrap7(node.argument);
+  if (node.type === AST_NODE_TYPES101.ChainExpression) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES101.TSAsExpression || node.type === AST_NODE_TYPES101.TSNonNullExpression || node.type === AST_NODE_TYPES101.TSTypeAssertion) return unwrap7(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap7(node);
-  if (current.type === AST_NODE_TYPES100.Literal && typeof current.value === "string") return current.value;
-  if (current.type === AST_NODE_TYPES100.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === AST_NODE_TYPES100.BinaryExpression && current.operator === "+") {
+  if (current.type === AST_NODE_TYPES101.Literal && typeof current.value === "string") return current.value;
+  if (current.type === AST_NODE_TYPES101.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === AST_NODE_TYPES101.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -22348,7 +22474,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap7(node);
-  if (current.type !== AST_NODE_TYPES100.CallExpression || current.callee.type !== AST_NODE_TYPES100.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES100.SpreadElement) return null;
+  if (current.type !== AST_NODE_TYPES101.CallExpression || current.callee.type !== AST_NODE_TYPES101.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES101.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -22370,7 +22496,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const scopes = [newScope()];
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
-      const bindingOf = (node) => ASTUtils51.findVariable(context.sourceCode.getScope(node), node.name);
+      const bindingOf = (node) => ASTUtils52.findVariable(context.sourceCode.getScope(node), node.name);
       const assertionKind = (node) => {
         const binding = bindingOf(node);
         if (binding === null || binding.defs.length === 0) {
@@ -22404,37 +22530,37 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === AST_NODE_TYPES100.Identifier) return visible("paths", current);
-        if (current.type === AST_NODE_TYPES100.CallExpression || current.type === AST_NODE_TYPES100.NewExpression) {
+        if (current.type === AST_NODE_TYPES101.Identifier) return visible("paths", current);
+        if (current.type === AST_NODE_TYPES101.CallExpression || current.type === AST_NODE_TYPES101.NewExpression) {
           const callee = current.callee;
           const first = current.arguments[0];
-          if (first === void 0 || first.type === AST_NODE_TYPES100.SpreadElement) return false;
-          if (current.type === AST_NODE_TYPES100.NewExpression && callee.type === AST_NODE_TYPES100.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === AST_NODE_TYPES100.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES100.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES100.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES100.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === AST_NODE_TYPES101.SpreadElement) return false;
+          if (current.type === AST_NODE_TYPES101.NewExpression && callee.type === AST_NODE_TYPES101.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === AST_NODE_TYPES101.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES101.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES101.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES101.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
         }
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap7(node);
-        if (current.type !== AST_NODE_TYPES100.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== AST_NODE_TYPES101.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap7(current.callee);
-        if (callee.type === AST_NODE_TYPES100.Identifier) {
+        if (callee.type === AST_NODE_TYPES101.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== AST_NODE_TYPES100.MemberExpression) return false;
+        if (callee.type !== AST_NODE_TYPES101.MemberExpression) return false;
         const name2 = staticMemberName8(callee);
         const object = unwrap7(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES100.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES101.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap7(node);
-        if (current.type === AST_NODE_TYPES100.Identifier) return visibleRawOrigins(current);
+        if (current.type === AST_NODE_TYPES101.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === AST_NODE_TYPES100.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES100.MemberExpression && staticMemberName8(current) === "length") return rawOrigins(current.object);
-        if (current.type !== AST_NODE_TYPES100.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES101.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES101.MemberExpression && staticMemberName8(current) === "length") return rawOrigins(current.object);
+        if (current.type !== AST_NODE_TYPES101.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES100.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES101.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName8(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
@@ -22442,32 +22568,32 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === AST_NODE_TYPES100.BinaryExpression || current.type === AST_NODE_TYPES100.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES100.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== AST_NODE_TYPES100.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES101.BinaryExpression || current.type === AST_NODE_TYPES101.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES101.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== AST_NODE_TYPES101.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES100.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES101.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName8(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 === AST_NODE_TYPES100.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES101.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap7(node.callee);
-        if (callee.type === AST_NODE_TYPES100.Identifier && assertionKind(callee) === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES100.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === AST_NODE_TYPES101.Identifier && assertionKind(callee) === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES101.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== AST_NODE_TYPES100.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES101.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName8(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap7(callee.object);
-        while (receiver.type === AST_NODE_TYPES100.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName8(receiver) ?? "")) receiver = unwrap7(receiver.object);
-        if (receiver.type === AST_NODE_TYPES100.CallExpression && receiver.callee.type === AST_NODE_TYPES100.Identifier && assertionKind(receiver.callee) === "expect") {
+        while (receiver.type === AST_NODE_TYPES101.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName8(receiver) ?? "")) receiver = unwrap7(receiver.object);
+        if (receiver.type === AST_NODE_TYPES101.CallExpression && receiver.callee.type === AST_NODE_TYPES101.Identifier && assertionKind(receiver.callee) === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES100.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES101.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== AST_NODE_TYPES100.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES100.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== AST_NODE_TYPES101.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES101.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -22489,7 +22615,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap7(node);
-        return current.type === AST_NODE_TYPES100.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES100.SpreadElement && sourcePath(element));
+        return current.type === AST_NODE_TYPES101.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES101.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -22499,8 +22625,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       function declareFsReaders(pattern) {
         for (const property of pattern.properties) {
-          if (property.type !== AST_NODE_TYPES100.Property || property.value.type !== AST_NODE_TYPES100.Identifier) continue;
-          const key = property.key.type === AST_NODE_TYPES100.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES100.Literal ? String(property.key.value) : "";
+          if (property.type !== AST_NODE_TYPES101.Property || property.value.type !== AST_NODE_TYPES101.Identifier) continue;
+          const key = property.key.type === AST_NODE_TYPES101.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES101.Literal ? String(property.key.value) : "";
           if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
         }
       }
@@ -22509,8 +22635,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 === AST_NODE_TYPES100.ImportSpecifier) {
-              const imported = specifier.imported.type === AST_NODE_TYPES100.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === AST_NODE_TYPES101.ImportSpecifier) {
+              const imported = specifier.imported.type === AST_NODE_TYPES101.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -22523,26 +22649,26 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (node.init === null) return;
           const required = requireSource(node.init);
           const initializer = unwrap7(node.init);
-          if (required !== null && initializer.type === AST_NODE_TYPES100.CallExpression && initializer.callee.type === AST_NODE_TYPES100.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES100.Identifier) {
+          if (required !== null && initializer.type === AST_NODE_TYPES101.CallExpression && initializer.callee.type === AST_NODE_TYPES101.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES101.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === AST_NODE_TYPES100.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === AST_NODE_TYPES101.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             declareFsReaders(node.id);
             return;
           }
-          if (node.id.type !== AST_NODE_TYPES100.Identifier) return;
+          if (node.id.type !== AST_NODE_TYPES101.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === AST_NODE_TYPES100.Identifier) declare(node.left, {});
+          if (node.left.type === AST_NODE_TYPES101.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap7(node.right);
-          const collection = right.type === AST_NODE_TYPES100.Identifier && visible("collections", right);
-          const left = node.left.type === AST_NODE_TYPES100.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === AST_NODE_TYPES100.Identifier) declare(left, { path: true });
+          const collection = right.type === AST_NODE_TYPES101.Identifier && visible("collections", right);
+          const left = node.left.type === AST_NODE_TYPES101.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === AST_NODE_TYPES101.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -22560,22 +22686,22 @@ var source_coupled_test_default = createSourceCoupledRule(
   GENERAL_SOURCE_SUFFIX_RE
 );
 function importedAssertionKind(specifier) {
-  if (specifier.type !== AST_NODE_TYPES100.ImportSpecifier && specifier.type !== AST_NODE_TYPES100.ImportDefaultSpecifier && specifier.type !== AST_NODE_TYPES100.ImportNamespaceSpecifier || specifier.parent.type !== AST_NODE_TYPES100.ImportDeclaration) return null;
+  if (specifier.type !== AST_NODE_TYPES101.ImportSpecifier && specifier.type !== AST_NODE_TYPES101.ImportDefaultSpecifier && specifier.type !== AST_NODE_TYPES101.ImportNamespaceSpecifier || specifier.parent.type !== AST_NODE_TYPES101.ImportDeclaration) return null;
   const source = importSource(specifier.parent);
   if (source !== null && ASSERT_MODULES.has(source)) {
-    if (specifier.type !== AST_NODE_TYPES100.ImportSpecifier) return "assert";
-    const imported2 = specifier.imported.type === AST_NODE_TYPES100.Identifier ? specifier.imported.name : String(specifier.imported.value);
+    if (specifier.type !== AST_NODE_TYPES101.ImportSpecifier) return "assert";
+    const imported2 = specifier.imported.type === AST_NODE_TYPES101.Identifier ? specifier.imported.name : String(specifier.imported.value);
     if (imported2 === "strict" || ASSERT_MATCHERS.has(imported2)) return "assert";
     return null;
   }
-  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== AST_NODE_TYPES100.ImportSpecifier) return null;
-  const imported = specifier.imported.type === AST_NODE_TYPES100.Identifier ? specifier.imported.name : String(specifier.imported.value);
+  if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== AST_NODE_TYPES101.ImportSpecifier) return null;
+  const imported = specifier.imported.type === AST_NODE_TYPES101.Identifier ? specifier.imported.name : String(specifier.imported.value);
   if (imported === "assert" || imported === "expect") return imported;
   return null;
 }
 
 // src/rules/sole-export-matches-filename.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES101 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES102 } from "@typescript-eslint/utils";
 var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
   defaultLevel: "warning",
   summary: "Make a module filename reflect its sole named public runtime export.",
@@ -22656,10 +22782,10 @@ function reflectsExportName(fileStem, exportedStem) {
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === AST_NODE_TYPES101.ClassDeclaration || declaration.type === AST_NODE_TYPES101.FunctionDeclaration || declaration.type === AST_NODE_TYPES101.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== AST_NODE_TYPES101.VariableDeclaration) return [];
+  if (declaration.type === AST_NODE_TYPES102.ClassDeclaration || declaration.type === AST_NODE_TYPES102.FunctionDeclaration || declaration.type === AST_NODE_TYPES102.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== AST_NODE_TYPES102.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === AST_NODE_TYPES101.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === AST_NODE_TYPES102.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -22683,29 +22809,29 @@ var sole_export_matches_filename_default = createRule({
         const exports = [];
         const publicExports = /* @__PURE__ */ new Set();
         function collectPublicExport(statement) {
-          if (statement.type === AST_NODE_TYPES101.ExportAllDeclaration || statement.type === AST_NODE_TYPES101.ExportNamedDeclaration && statement.source !== null) return false;
-          if (statement.type === AST_NODE_TYPES101.ExportDefaultDeclaration) {
+          if (statement.type === AST_NODE_TYPES102.ExportAllDeclaration || statement.type === AST_NODE_TYPES102.ExportNamedDeclaration && statement.source !== null) return false;
+          if (statement.type === AST_NODE_TYPES102.ExportDefaultDeclaration) {
             publicExports.add("default");
             const declaration = statement.declaration;
-            if ((declaration.type === AST_NODE_TYPES101.ClassDeclaration || declaration.type === AST_NODE_TYPES101.FunctionDeclaration) && declaration.id !== null) exports.push({ name: declaration.id.name, node: declaration });
+            if ((declaration.type === AST_NODE_TYPES102.ClassDeclaration || declaration.type === AST_NODE_TYPES102.FunctionDeclaration) && declaration.id !== null) exports.push({ name: declaration.id.name, node: declaration });
             else return false;
           }
-          if (statement.type !== AST_NODE_TYPES101.ExportNamedDeclaration) return true;
+          if (statement.type !== AST_NODE_TYPES102.ExportNamedDeclaration) return true;
           return collectNamedExport(statement);
         }
         function collectNamedExport(statement) {
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES101.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES102.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === AST_NODE_TYPES101.VariableDeclaration) {
-            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES101.Identifier)) return false;
+          if (declaration?.type === AST_NODE_TYPES102.VariableDeclaration) {
+            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES102.Identifier)) return false;
             for (const item of declaration.declarations) {
-              if (item.id.type === AST_NODE_TYPES101.Identifier) publicExports.add(item.id.name);
+              if (item.id.type === AST_NODE_TYPES102.Identifier) publicExports.add(item.id.name);
             }
           }
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES101.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES102.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
           }
           if (statement.exportKind === "type") return true;
@@ -22715,7 +22841,7 @@ var sole_export_matches_filename_default = createRule({
         }
         function collectRuntimeSpecifiers(statement) {
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES101.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES102.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
             if (specifier.exportKind === "type") continue;
             if (exported === "default") exports.push({ name: specifier.local.name, node: specifier });
@@ -22730,7 +22856,7 @@ var sole_export_matches_filename_default = createRule({
         const only = [...unique.values()][0];
         if (only === void 0) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
-        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === AST_NODE_TYPES101.ImportDeclaration && statement.source.value === "astro:content")) return;
+        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === AST_NODE_TYPES102.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
@@ -22781,8 +22907,8 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 
 // src/rules/require-pascal-case-zod-schema-name.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES102,
-  ASTUtils as ASTUtils52
+  AST_NODE_TYPES as AST_NODE_TYPES103,
+  ASTUtils as ASTUtils53
 } from "@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.",
@@ -22915,18 +23041,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES102.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES103.Identifier ? callee.property.name : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES102.Identifier) {
+    if (current.type === AST_NODE_TYPES103.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES102.MemberExpression) {
+    if (current.type === AST_NODE_TYPES103.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES102.CallExpression) {
+    if (current.type === AST_NODE_TYPES103.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -22937,13 +23063,13 @@ var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES102.MemberExpression) {
-      if (current.computed || current.property.type !== AST_NODE_TYPES102.Identifier) return [];
+    if (current.type === AST_NODE_TYPES103.MemberExpression) {
+      if (current.computed || current.property.type !== AST_NODE_TYPES103.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES102.CallExpression) {
+    if (current.type === AST_NODE_TYPES103.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -22954,16 +23080,16 @@ var chainMemberNames2 = (node) => {
 };
 var unwrapExpression7 = (node) => {
   let current = node;
-  while (current.type === AST_NODE_TYPES102.TSAsExpression || current.type === AST_NODE_TYPES102.TSSatisfiesExpression || current.type === AST_NODE_TYPES102.TSNonNullExpression || current.type === AST_NODE_TYPES102.TSTypeAssertion) {
+  while (current.type === AST_NODE_TYPES103.TSAsExpression || current.type === AST_NODE_TYPES103.TSSatisfiesExpression || current.type === AST_NODE_TYPES103.TSNonNullExpression || current.type === AST_NODE_TYPES103.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES102.VariableDeclaration) return false;
+  if (declaration.type !== AST_NODE_TYPES103.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === AST_NODE_TYPES102.Program || owner.type === AST_NODE_TYPES102.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES102.Program;
+  return owner.type === AST_NODE_TYPES103.Program || owner.type === AST_NODE_TYPES103.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES103.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -22983,7 +23109,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils52.findVariable(
+      return ASTUtils53.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -23004,8 +23130,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
     }
     function isConfirmedSchema(expression) {
       const init = unwrapExpression7(expression);
-      if (init.type === AST_NODE_TYPES102.Identifier) return isSchemaBinding(init);
-      if (init.type !== AST_NODE_TYPES102.CallExpression || init.callee.type !== AST_NODE_TYPES102.MemberExpression) {
+      if (init.type === AST_NODE_TYPES103.Identifier) return isSchemaBinding(init);
+      if (init.type !== AST_NODE_TYPES103.CallExpression || init.callee.type !== AST_NODE_TYPES103.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -23025,7 +23151,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 === AST_NODE_TYPES102.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES102.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES102.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES102.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES103.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES103.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES103.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES103.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -23034,7 +23160,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 !== AST_NODE_TYPES102.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES103.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -23217,6 +23343,7 @@ var RULES = {
   "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-nominal-id-types": prefer_nominal_id_types_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,
@@ -23248,7 +23375,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.26.8"
+  version: "15.28.0"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {
@@ -23267,6 +23394,7 @@ var ADVISORY_RULES = [
   "@sarj/prefer-named-complex-return-type",
   "@sarj/prefer-node-crypto-hash",
   "@sarj/prefer-node-fs-promises",
+  "@sarj/prefer-nominal-id-types",
   "@sarj/prefer-shared-zod-enum",
   "@sarj/prefer-switch-for-repeated-equality",
   "@sarj/prefer-whole-object-assertion",
@@ -23357,6 +23485,7 @@ var RECOMMENDED_RULES = {
   "@sarj/prefer-module-level-refined-schema": "warn",
   "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
   "@sarj/prefer-named-callback-domain": "error",
+  "@sarj/prefer-nominal-id-types": "warn",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",
@@ -23474,6 +23603,7 @@ var STRICT_RULES = {
   "@sarj/prefer-module-level-refined-schema": "warn",
   "@sarj/prefer-multi-value-zod-literal": ["warn", { zodMajorVersion: 4 }],
   "@sarj/prefer-named-callback-domain": "error",
+  "@sarj/prefer-nominal-id-types": "warn",
   "@sarj/prefer-named-complex-return-type": "warn",
   "@sarj/prefer-node-crypto-hash": "warn",
   "@sarj/prefer-node-fs-promises": "warn",