@sarj/eslint-plugin 15.8.2 → 15.10.0

package/dist/index.js

@@ -4679,11 +4679,11 @@ var no_offset_pagination_default = createRule({
 // src/rules/no-positional-tuple-return.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES18 } from "@typescript-eslint/utils";
 var noPositionalTupleReturnDocumentation = {
-  summary: "Disallow returning a multi-field tuple from an exported function; return a named object so call sites cannot mismatch slots.",
-  rationale: "Public tuple fields are identified only by position, so reordering can preserve types while changing meaning.",
+  summary: "Disallow returning a multi-field tuple from a named function; return a named object so call sites cannot mismatch slots.",
+  rationale: "Tuple fields are identified only by position, so reordering can preserve types while changing meaning.",
   remediation: "Return an object whose property names describe each value.",
   category: "maintainability",
-  limitations: ["Only declared multi-field tuple returns on public TypeScript surfaces are inspected."],
+  limitations: ["Declared or syntax-proven multi-field tuple returns on named functions and public type surfaces are inspected; anonymous inline callbacks and syntax-proven TanStack Query key factories are excluded."],
   examples: [
     { id: "named-object-return", title: "Return named fields", outcome: "no-match", files: [{ path: "src/download.ts", source: "export function download(): { body: string; status: number } { return impl(); }" }], focusPath: "src/download.ts", expectedCount: 0, public: true },
     { id: "tuple-return", title: "Do not expose positional fields", outcome: "match", files: [{ path: "src/download.ts", source: "export function download(): [string, number] { return impl(); }" }], focusPath: "src/download.ts", expectedCount: 1, public: true }
@@ -4721,6 +4721,16 @@ function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
   }
   return null;
 }
+function tupleExpression(node, aliases) {
+  if (node.type !== AST_NODE_TYPES18.TSAsExpression && node.type !== AST_NODE_TYPES18.TSSatisfiesExpression) {
+    return null;
+  }
+  if (node.expression.type !== AST_NODE_TYPES18.ArrayExpression || node.expression.elements.length < MIN_ELEMENTS) {
+    return null;
+  }
+  if (node.type === AST_NODE_TYPES18.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES18.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES18.Identifier && node.typeAnnotation.typeName.name === "const") return node.expression;
+  return tupleReturnType(node.typeAnnotation, aliases) === null ? null : node.expression;
+}
 function functionName(node) {
   if (node.type === AST_NODE_TYPES18.FunctionDeclaration) {
     if (node.id !== null) return node.id.name;
@@ -4736,60 +4746,25 @@ function functionName(node) {
     return parent.id.name;
   }
   if ((parent?.type === AST_NODE_TYPES18.MethodDefinition || parent?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || parent?.type === AST_NODE_TYPES18.PropertyDefinition || parent?.type === AST_NODE_TYPES18.Property) && parent.key.type === AST_NODE_TYPES18.Identifier) {
-    if ((parent.type === AST_NODE_TYPES18.MethodDefinition || parent.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || parent.type === AST_NODE_TYPES18.PropertyDefinition) && (parent.accessibility === "private" || parent.accessibility === "protected")) return null;
     return parent.key.name;
   }
   return null;
 }
-function isInlineExported(node) {
-  if (moduleScopeBindingName(node) === null) return false;
-  for (let current = node; current != null; current = current.parent) {
-    const parent = current.parent;
-    if (parent?.type === AST_NODE_TYPES18.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-      return true;
-    }
-  }
-  return false;
-}
-function moduleScopeBindingName(node) {
-  let current = node;
-  while (current.parent != null && current.parent.type !== AST_NODE_TYPES18.Program) {
-    current = current.parent;
-  }
-  if (current.parent?.type !== AST_NODE_TYPES18.Program) {
-    return null;
-  }
-  let topLevel = current;
-  if (current.type === AST_NODE_TYPES18.ExportNamedDeclaration || current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-    topLevel = current.declaration;
-  }
-  if (topLevel === null) return null;
-  if (topLevel.type === AST_NODE_TYPES18.FunctionDeclaration) {
-    if (topLevel !== node) return null;
-    return topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null);
-  }
-  if ((topLevel.type === AST_NODE_TYPES18.ArrowFunctionExpression || topLevel.type === AST_NODE_TYPES18.FunctionExpression) && topLevel === node && current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-    return "default";
-  }
-  if (topLevel.type === AST_NODE_TYPES18.ClassDeclaration) {
-    let owner = node.parent;
-    while (owner != null && owner.parent !== topLevel.body) owner = owner.parent;
-    return (owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null) : null;
-  }
-  if (topLevel.type === AST_NODE_TYPES18.VariableDeclaration) {
-    for (const declarator of topLevel.declarations) {
-      let initializer = declarator.init;
-      while (initializer?.type === AST_NODE_TYPES18.TSAsExpression || initializer?.type === AST_NODE_TYPES18.TSSatisfiesExpression || initializer?.type === AST_NODE_TYPES18.TSNonNullExpression) initializer = initializer.expression;
-      if (declarator.id.type === AST_NODE_TYPES18.Identifier && initializer === node) return declarator.id.name;
-      if (declarator.id.type === AST_NODE_TYPES18.Identifier && (initializer?.type === AST_NODE_TYPES18.ClassExpression || initializer?.type === AST_NODE_TYPES18.ObjectExpression)) {
-        let owner = node.parent;
-        const container = initializer.type === AST_NODE_TYPES18.ClassExpression ? initializer.body : initializer;
-        while (owner != null && owner.parent !== container) owner = owner.parent;
-        if ((owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition || owner?.type === AST_NODE_TYPES18.Property) && owner.value === node) return declarator.id.name;
-      }
-    }
-  }
-  return null;
+function isQueryKeyFactory(node) {
+  let wrapped = node;
+  while ((wrapped.parent?.type === AST_NODE_TYPES18.TSAsExpression || wrapped.parent?.type === AST_NODE_TYPES18.TSSatisfiesExpression || wrapped.parent?.type === AST_NODE_TYPES18.TSNonNullExpression) && wrapped.parent.expression === wrapped) wrapped = wrapped.parent;
+  const property = wrapped.parent;
+  if (property?.type !== AST_NODE_TYPES18.Property || property.value !== wrapped) return false;
+  const object = property.parent;
+  if (object.type !== AST_NODE_TYPES18.ObjectExpression) return false;
+  const assertion = object.parent;
+  if (assertion.type !== AST_NODE_TYPES18.TSAsExpression || assertion.expression !== object || assertion.typeAnnotation.type !== AST_NODE_TYPES18.TSTypeReference || assertion.typeAnnotation.typeName.type !== AST_NODE_TYPES18.Identifier || assertion.typeAnnotation.typeName.name !== "const") return false;
+  const declarator = assertion.parent;
+  if (declarator.type !== AST_NODE_TYPES18.VariableDeclarator || declarator.id.type !== AST_NODE_TYPES18.Identifier || !/Keys$/i.test(declarator.id.name) || declarator.parent.type !== AST_NODE_TYPES18.VariableDeclaration || declarator.parent.kind !== "const") return false;
+  return object.properties.some((candidate) => {
+    if (candidate.type !== AST_NODE_TYPES18.Property || staticMemberName3(candidate.key) !== "all") return false;
+    return candidate.value.type === AST_NODE_TYPES18.TSAsExpression && candidate.value.expression.type === AST_NODE_TYPES18.ArrayExpression && candidate.value.typeAnnotation.type === AST_NODE_TYPES18.TSTypeReference && candidate.value.typeAnnotation.typeName.type === AST_NODE_TYPES18.Identifier && candidate.value.typeAnnotation.typeName.name === "const";
+  });
 }
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
@@ -4898,18 +4873,52 @@ function isExportedClass(node, specifierExports) {
   if (node.parent.type === AST_NODE_TYPES18.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES18.Identifier) return specifierExports.has(node.parent.id.name) || isInlineExported(node);
   return false;
 }
-function isExportedInterface(node, exports) {
-  return node.parent.type === AST_NODE_TYPES18.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES18.ExportDefaultDeclaration || node.parent.type === AST_NODE_TYPES18.Program && exports.has(node.id.name);
+function isInlineExported(node) {
+  if (moduleScopeBindingName(node) === null) return false;
+  for (let current = node; current != null; current = current.parent) {
+    const parent = current.parent;
+    if (parent?.type === AST_NODE_TYPES18.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
+      return true;
+    }
+  }
+  return false;
 }
-function isExported(node, specifierExports) {
-  if (isInlineExported(node)) {
-    return true;
+function moduleScopeBindingName(node) {
+  let current = node;
+  while (current.parent != null && current.parent.type !== AST_NODE_TYPES18.Program) {
+    current = current.parent;
   }
-  if (specifierExports.size === 0) {
-    return false;
+  if (current.parent?.type !== AST_NODE_TYPES18.Program) return null;
+  let topLevel = current;
+  if (current.type === AST_NODE_TYPES18.ExportNamedDeclaration || current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) topLevel = current.declaration;
+  if (topLevel === null) return null;
+  if (topLevel.type === AST_NODE_TYPES18.FunctionDeclaration) {
+    if (topLevel !== node) return null;
+    return topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null);
   }
-  const binding = moduleScopeBindingName(node);
-  return binding !== null && specifierExports.has(binding);
+  if ((topLevel.type === AST_NODE_TYPES18.ArrowFunctionExpression || topLevel.type === AST_NODE_TYPES18.FunctionExpression) && topLevel === node && current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) return "default";
+  if (topLevel.type === AST_NODE_TYPES18.ClassDeclaration) {
+    let owner = node.parent;
+    while (owner != null && owner.parent !== topLevel.body) owner = owner.parent;
+    return (owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null) : null;
+  }
+  if (topLevel.type === AST_NODE_TYPES18.VariableDeclaration) {
+    for (const declarator of topLevel.declarations) {
+      let initializer = declarator.init;
+      while (initializer?.type === AST_NODE_TYPES18.TSAsExpression || initializer?.type === AST_NODE_TYPES18.TSSatisfiesExpression || initializer?.type === AST_NODE_TYPES18.TSNonNullExpression) initializer = initializer.expression;
+      if (declarator.id.type === AST_NODE_TYPES18.Identifier && initializer === node) return declarator.id.name;
+      if (declarator.id.type === AST_NODE_TYPES18.Identifier && (initializer?.type === AST_NODE_TYPES18.ClassExpression || initializer?.type === AST_NODE_TYPES18.ObjectExpression)) {
+        let owner = node.parent;
+        const container = initializer.type === AST_NODE_TYPES18.ClassExpression ? initializer.body : initializer;
+        while (owner != null && owner.parent !== container) owner = owner.parent;
+        if ((owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition || owner?.type === AST_NODE_TYPES18.Property) && owner.value === node) return declarator.id.name;
+      }
+    }
+  }
+  return null;
+}
+function isExportedInterface(node, exports) {
+  return node.parent.type === AST_NODE_TYPES18.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES18.ExportDefaultDeclaration || node.parent.type === AST_NODE_TYPES18.Program && exports.has(node.id.name);
 }
 var no_positional_tuple_return_default = createRule({
   name: "no-positional-tuple-return",
@@ -4917,11 +4926,11 @@ var no_positional_tuple_return_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow returning a multi-field tuple from an exported function; return a named object so call sites cannot mismatch slots."
+      description: "Disallow returning a multi-field tuple from a named function; return a named object so call sites cannot mismatch slots."
     },
     schema: [],
     messages: {
-      noPositionalTupleReturn: "Exported `{{name}}` returns a {{count}}-field tuple, so consumers depend on positional slots that can be reordered silently. Return a named object instead."
+      noPositionalTupleReturn: "`{{name}}` returns a {{count}}-field tuple, so callers depend on positional slots that can be reordered silently. Return a named object instead."
     }
   },
   defaultOptions: [],
@@ -4933,6 +4942,8 @@ var no_positional_tuple_return_default = createRule({
       exportedTypeNames(context.sourceCode.ast)
     );
     const aliases = typeAliases(context.sourceCode.ast);
+    const reportedFunctions = /* @__PURE__ */ new WeakSet();
+    const functionStack = [];
     const report = (annotation, name) => {
       const tuple = tupleReturnType(annotation, aliases);
       if (tuple === null || tuple.elementTypes.length < MIN_ELEMENTS) return;
@@ -4942,25 +4953,54 @@ var no_positional_tuple_return_default = createRule({
         data: { name, count: String(tuple.elementTypes.length) }
       });
     };
+    const reportExpression = (node, expression) => {
+      if (reportedFunctions.has(node)) return;
+      const tuple = tupleExpression(expression, aliases);
+      const name = functionName(node);
+      if (tuple === null || name === null) return;
+      reportedFunctions.add(node);
+      context.report({
+        node: tuple,
+        messageId: "noPositionalTupleReturn",
+        data: { name, count: String(tuple.elements.length) }
+      });
+    };
     const check = (node) => {
+      if (isQueryKeyFactory(node)) return;
       const annotation = node.returnType?.typeAnnotation;
       if (annotation === void 0) {
+        if (node.type === AST_NODE_TYPES18.ArrowFunctionExpression && node.expression) {
+          reportExpression(node, node.body);
+        }
         return;
       }
       const name = functionName(node);
       if (name === null) {
         return;
       }
-      if (!isExported(node, specifierExports)) {
-        return;
-      }
       report(annotation, name);
     };
+    const enterFunction = (node) => {
+      functionStack.push(node);
+      check(node);
+    };
+    const exitFunction = () => {
+      functionStack.pop();
+    };
     return {
-      FunctionDeclaration: check,
-      FunctionExpression: check,
-      ArrowFunctionExpression: check,
-      TSEmptyBodyFunctionExpression: check,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      TSEmptyBodyFunctionExpression: enterFunction,
+      "TSEmptyBodyFunctionExpression:exit": exitFunction,
+      ReturnStatement(node) {
+        const owner = functionStack.at(-1);
+        if (owner === void 0 || owner.returnType !== void 0 || node.argument === null) return;
+        reportExpression(owner, node.argument);
+      },
       TSDeclareFunction(node) {
         if (node.id === null || node.returnType === void 0 || node.parent.type !== AST_NODE_TYPES18.ExportNamedDeclaration && node.parent.type !== AST_NODE_TYPES18.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
         report(node.returnType.typeAnnotation, node.id.name);
@@ -9305,8 +9345,98 @@ function unwrapExpression(node) {
   return node;
 }
 
-// src/rules/prefer-constant-time-secret-compare.ts
+// src/rules/test-phase-label-comment.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES37 } from "@typescript-eslint/utils";
+var PHASE_WORD = String.raw`arrange|act|assert(?:ion)?s?|given|when|then|exercise|execute|verif(?:y|ication)|cleanup|prepare|sanity(?:\s+check)?`;
+var PHASE_RE = new RegExp(
+  String.raw`^[-=~*_#.\s]{0,40}(?:${PHASE_WORD})(?:\s*(?:[/&+,|]|->|and)\s*(?:${PHASE_WORD}))*[-=~*_#.\s:;!–—]{0,40}$`,
+  "iu"
+);
+var testPhaseLabelCommentDocumentation = {
+  summary: "Tests must not use bare Arrange, Act, Assert, Given, When, or Then phase comments.",
+  rationale: "Phase labels narrate test structure without explaining behavior and often hide unclear names or oversized tests.",
+  remediation: "Delete the label; if the phases remain hard to follow, extract a named helper or split the test.",
+  category: "testing",
+  autofix: "safe",
+  limitations: [
+    "Only standalone line comments in recognized test files are checked.",
+    "Comments inside bracketed expressions or containing words outside the bounded phase grammar are preserved."
+  ],
+  examples: [
+    {
+      id: "behavioral-comment",
+      title: "Behavioral consequence is retained",
+      outcome: "no-match",
+      files: [{ path: "widget.test.ts", source: "// Then the retry loop would spin forever.\nexpect(run()).toBe(true);" }],
+      focusPath: "widget.test.ts",
+      expectedCount: 0,
+      public: true
+    },
+    {
+      id: "bare-phase-label",
+      title: "Bare phase label is removed",
+      outcome: "match",
+      files: [{ path: "widget.test.ts", source: "// Arrange\nconst widget = makeWidget();" }],
+      focusPath: "widget.test.ts",
+      expectedCount: 1,
+      fixedFiles: [{ path: "widget.test.ts", source: "const widget = makeWidget();" }],
+      public: true
+    }
+  ]
+};
+function insideExpression(sourceCode, comment) {
+  const token = sourceCode.getTokenAfter(comment, { includeComments: false });
+  if (token === null) return false;
+  let node = sourceCode.getNodeByRangeIndex(token.range[0]);
+  while (node != null && node.type !== AST_NODE_TYPES37.Program) {
+    if (node.type === AST_NODE_TYPES37.ArrayExpression || node.type === AST_NODE_TYPES37.ObjectExpression || node.type === AST_NODE_TYPES37.CallExpression || node.type === AST_NODE_TYPES37.NewExpression) return node.loc.start.line < comment.loc.start.line;
+    if (/Statement$/u.test(node.type) || /Declaration$/u.test(node.type)) return false;
+    node = node.parent;
+  }
+  return false;
+}
+function continuesProseRun(comments, index) {
+  const comment = comments[index];
+  if (comment?.type !== "Line") return false;
+  return [comments[index - 1], comments[index + 1]].some(
+    (neighbor) => neighbor?.type === "Line" && Math.abs(neighbor.loc.start.line - comment.loc.start.line) === 1 && !PHASE_RE.test(neighbor.value.trim())
+  );
+}
+var test_phase_label_comment_default = createRule({
+  name: "test-phase-label-comment",
+  documentation: testPhaseLabelCommentDocumentation,
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: { description: testPhaseLabelCommentDocumentation.summary },
+    schema: [],
+    messages: { removeLabel: "Bare test phase label \u2014 delete it and let the test names and helpers carry the structure." }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    return {
+      Program() {
+        const comments = context.sourceCode.getAllComments();
+        for (const [index, comment] of comments.entries()) {
+          if (comment.type !== "Line" || !PHASE_RE.test(comment.value.trim())) continue;
+          const removal = wholeLineRemovalRange(context.sourceCode.text, comment);
+          if (removal === null || insideExpression(context.sourceCode, comment) || continuesProseRun(comments, index)) {
+            continue;
+          }
+          context.report({
+            node: comment,
+            messageId: "removeLabel",
+            fix: (fixer) => fixer.removeRange(removal.range)
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-constant-time-secret-compare.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES38 } from "@typescript-eslint/utils";
 var preferConstantTimeSecretCompareDocumentation = {
   summary: "Disallow `===`/`!==` on a secret-like value; short-circuiting comparison leaks the secret through timing. Use a constant-time compare.",
   rationale: "Ordinary equality stops at the first differing byte, allowing repeated measurements to reveal secret material.",
@@ -9325,14 +9455,14 @@ var SENTINEL_PREFIX_RE = /^(skip|sentinel|empty|none|missing|unset|placeholder|d
 var AST_NODE_TYPE_RE = /^(?:TS|JSX)?[A-Z][A-Za-z]*(?:Signature|Keyword|Expression|Declaration|Element|Literal|Identifier)$/;
 function isExcludedOperand(node) {
   switch (node.type) {
-    case AST_NODE_TYPES37.Literal:
+    case AST_NODE_TYPES38.Literal:
       return true;
-    case AST_NODE_TYPES37.TemplateLiteral:
+    case AST_NODE_TYPES38.TemplateLiteral:
       return node.expressions.length === 0;
-    case AST_NODE_TYPES37.Identifier:
+    case AST_NODE_TYPES38.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case AST_NODE_TYPES37.MemberExpression:
-      return !node.computed && node.property.type === AST_NODE_TYPES37.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case AST_NODE_TYPES38.MemberExpression:
+      return !node.computed && node.property.type === AST_NODE_TYPES38.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
@@ -9343,23 +9473,23 @@ function isConstantReference(identifier) {
   return identifier === identifier.toUpperCase() && /[A-Za-z]/.test(identifier);
 }
 function operandName(node) {
-  if (node.type === AST_NODE_TYPES37.Identifier) {
+  if (node.type === AST_NODE_TYPES38.Identifier) {
     return node.name;
   }
-  if (node.type === AST_NODE_TYPES37.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES37.Identifier) {
+  if (node.type === AST_NODE_TYPES38.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES38.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === AST_NODE_TYPES37.TemplateLiteral) {
+  if (node.type === AST_NODE_TYPES38.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === AST_NODE_TYPES37.TemplateLiteral) {
+  if (node.type === AST_NODE_TYPES38.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -9413,7 +9543,7 @@ var prefer_constant_time_secret_compare_default = createRule({
 
 // src/rules/prefer-discriminated-union.ts
 import "@typescript-eslint/utils";
-import { AST_NODE_TYPES as AST_NODE_TYPES38 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES39 } from "@typescript-eslint/utils";
 var preferDiscriminatedUnionDocumentation = {
   summary: "Flag flat result objects with a required positive boolean status and optional success/failure payloads.",
   rationale: "A boolean status plus optional branch data permits contradictory and incomplete states.",
@@ -9445,13 +9575,13 @@ var SUCCESS_PAYLOAD_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var REQUIRED_STATUS_MEMBER_COUNT = 1;
 var FUNCTION_RETURN_OWNER_TYPES = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES38.ArrowFunctionExpression,
-  AST_NODE_TYPES38.FunctionDeclaration,
-  AST_NODE_TYPES38.FunctionExpression,
-  AST_NODE_TYPES38.TSDeclareFunction,
-  AST_NODE_TYPES38.TSEmptyBodyFunctionExpression,
-  AST_NODE_TYPES38.TSFunctionType,
-  AST_NODE_TYPES38.TSMethodSignature
+  AST_NODE_TYPES39.ArrowFunctionExpression,
+  AST_NODE_TYPES39.FunctionDeclaration,
+  AST_NODE_TYPES39.FunctionExpression,
+  AST_NODE_TYPES39.TSDeclareFunction,
+  AST_NODE_TYPES39.TSEmptyBodyFunctionExpression,
+  AST_NODE_TYPES39.TSFunctionType,
+  AST_NODE_TYPES39.TSMethodSignature
 ]);
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let statusMemberCount = 0;
@@ -9459,7 +9589,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasSuccessPayload = false;
   let hasUnrecognizedMember = false;
   for (const member of typeLiteral.members) {
-    if (member.type !== AST_NODE_TYPES38.TSPropertySignature) {
+    if (member.type !== AST_NODE_TYPES39.TSPropertySignature) {
       hasUnrecognizedMember = true;
       continue;
     }
@@ -9483,26 +9613,26 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
 }
 function getMemberName(member) {
-  if (member.type !== AST_NODE_TYPES38.TSPropertySignature) {
+  if (member.type !== AST_NODE_TYPES39.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === AST_NODE_TYPES38.Identifier) {
+  if (key.type === AST_NODE_TYPES39.Identifier) {
     return key.name;
   }
-  if (key.type === AST_NODE_TYPES38.Literal && typeof key.value === "string") {
+  if (key.type === AST_NODE_TYPES39.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES38.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES39.TSBooleanKeyword;
 }
 function inlineReturnTypeLiteral(node) {
   let annotation = null;
-  if (node.parent.type === AST_NODE_TYPES38.TSTypeAnnotation) {
+  if (node.parent.type === AST_NODE_TYPES39.TSTypeAnnotation) {
     annotation = node.parent;
-  } else if (node.parent.type === AST_NODE_TYPES38.TSTypeParameterInstantiation && node.parent.params.length === 1 && node.parent.params[0] === node && node.parent.parent.type === AST_NODE_TYPES38.TSTypeReference && node.parent.parent.typeName.type === AST_NODE_TYPES38.Identifier && node.parent.parent.typeName.name === "Promise" && node.parent.parent.parent.type === AST_NODE_TYPES38.TSTypeAnnotation) {
+  } else if (node.parent.type === AST_NODE_TYPES39.TSTypeParameterInstantiation && node.parent.params.length === 1 && node.parent.params[0] === node && node.parent.parent.type === AST_NODE_TYPES39.TSTypeReference && node.parent.parent.typeName.type === AST_NODE_TYPES39.Identifier && node.parent.parent.typeName.name === "Promise" && node.parent.parent.parent.type === AST_NODE_TYPES39.TSTypeAnnotation) {
     annotation = node.parent.parent.parent;
   }
   if (annotation === null) return null;
@@ -9542,7 +9672,7 @@ var prefer_discriminated_union_default = createRule({
         }
         const synthetic = {
           ...node.body,
-          type: AST_NODE_TYPES38.TSTypeLiteral,
+          type: AST_NODE_TYPES39.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -9559,7 +9689,7 @@ var prefer_discriminated_union_default = createRule({
 });
 
 // src/rules/prefer-input-group-search.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES39 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES40 } from "@typescript-eslint/utils";
 var preferInputGroupSearchDocumentation = {
   summary: "Require search icons and shared Input controls in the same visual wrapper to use InputGroup.",
   rationale: "The shared compound control provides consistent spacing, focus behavior, and accessible composition.",
@@ -9580,15 +9710,15 @@ var MAX_JSX_DISTANCE = 2;
 var SEARCH_EXPORTS = ["Search", "SearchIcon", "LucideSearch"];
 function localNamedImports(node, importedName4) {
   return node.specifiers.filter(
-    (specifier) => specifier.type === AST_NODE_TYPES39.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES39.Identifier ? specifier.imported.name : specifier.imported.value) === importedName4
+    (specifier) => specifier.type === AST_NODE_TYPES40.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES40.Identifier ? specifier.imported.name : specifier.imported.value) === importedName4
   ).map((specifier) => specifier.local.name);
 }
 function elementName(node) {
-  return node.name.type === AST_NODE_TYPES39.JSXIdentifier ? node.name.name : null;
+  return node.name.type === AST_NODE_TYPES40.JSXIdentifier ? node.name.name : null;
 }
 function jsxAncestors(occurrence) {
   return occurrence.ancestors.filter(
-    (ancestor) => ancestor.type === AST_NODE_TYPES39.JSXElement
+    (ancestor) => ancestor.type === AST_NODE_TYPES40.JSXElement
   );
 }
 function isWithinInputGroup(occurrence, inputGroupNames) {
@@ -9701,7 +9831,7 @@ var prefer_input_group_search_default = createRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES40, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES41, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
 var preferImmutableModuleConstantDocumentation = {
   summary: "Require module-level constant collections to expose readonly state.",
   rationale: "A const binding prevents reassignment but does not stop callers from mutating its array, object, Set, or Map contents.",
@@ -9749,59 +9879,59 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "unshift"
 ]);
 function isAsConst(node, sourceText) {
-  if (node.type === AST_NODE_TYPES40.TSSatisfiesExpression || node.type === AST_NODE_TYPES40.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES41.TSSatisfiesExpression || node.type === AST_NODE_TYPES41.TSNonNullExpression) {
     return isAsConst(node.expression, sourceText);
   }
-  if (node.type !== AST_NODE_TYPES40.TSAsExpression) return false;
+  if (node.type !== AST_NODE_TYPES41.TSAsExpression) return false;
   return sourceText(node.typeAnnotation).trim() === "const";
 }
 function unwrapExpression2(node) {
-  if (node.type === AST_NODE_TYPES40.TSAsExpression || node.type === AST_NODE_TYPES40.TSSatisfiesExpression || node.type === AST_NODE_TYPES40.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES41.TSAsExpression || node.type === AST_NODE_TYPES41.TSSatisfiesExpression || node.type === AST_NODE_TYPES41.TSNonNullExpression) {
     return unwrapExpression2(node.expression);
   }
   return node;
 }
 function isObjectFreeze(node, isUnshadowedGlobal) {
   const inner = unwrapExpression2(node);
-  if (inner.type === AST_NODE_TYPES40.CallExpression && inner.callee.type === AST_NODE_TYPES40.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES40.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES40.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
+  if (inner.type === AST_NODE_TYPES41.CallExpression && inner.callee.type === AST_NODE_TYPES41.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES41.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES41.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
     const argument = inner.arguments[0];
-    return argument !== void 0 && argument.type !== AST_NODE_TYPES40.SpreadElement && collectionKind(argument, isUnshadowedGlobal) === "literal";
+    return argument !== void 0 && argument.type !== AST_NODE_TYPES41.SpreadElement && collectionKind(argument, isUnshadowedGlobal) === "literal";
   }
   return false;
 }
 function collectionKind(node, isUnshadowedGlobal) {
   const inner = unwrapExpression2(node);
-  if (inner.type === AST_NODE_TYPES40.CallExpression && inner.callee.type === AST_NODE_TYPES40.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES40.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES40.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES40.SpreadElement) {
+  if (inner.type === AST_NODE_TYPES41.CallExpression && inner.callee.type === AST_NODE_TYPES41.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES41.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES41.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES41.SpreadElement) {
     return collectionKind(inner.arguments[0], isUnshadowedGlobal);
   }
-  if (inner.type === AST_NODE_TYPES40.ArrayExpression || inner.type === AST_NODE_TYPES40.ObjectExpression) {
+  if (inner.type === AST_NODE_TYPES41.ArrayExpression || inner.type === AST_NODE_TYPES41.ObjectExpression) {
     return "literal";
   }
-  if (inner.type === AST_NODE_TYPES40.NewExpression && inner.callee.type === AST_NODE_TYPES40.Identifier && (inner.callee.name === "Set" || inner.callee.name === "Map") && isUnshadowedGlobal(inner.callee)) {
+  if (inner.type === AST_NODE_TYPES41.NewExpression && inner.callee.type === AST_NODE_TYPES41.Identifier && (inner.callee.name === "Set" || inner.callee.name === "Map") && isUnshadowedGlobal(inner.callee)) {
     return inner.callee.name;
   }
   return null;
 }
 function declaredReadonlyType(node, kind, aliases) {
-  const annotation = node.id.type === AST_NODE_TYPES40.Identifier ? node.id.typeAnnotation : void 0;
+  const annotation = node.id.type === AST_NODE_TYPES41.Identifier ? node.id.typeAnnotation : void 0;
   if (annotation !== void 0 && isReadonlyTypeResolved(annotation.typeAnnotation, kind, aliases)) {
     return true;
   }
-  return node.init?.type === AST_NODE_TYPES40.TSAsExpression && isReadonlyTypeResolved(node.init.typeAnnotation, kind, aliases);
+  return node.init?.type === AST_NODE_TYPES41.TSAsExpression && isReadonlyTypeResolved(node.init.typeAnnotation, kind, aliases);
 }
 function isReadonlyTypeResolved(node, kind, aliases, seen = /* @__PURE__ */ new Set()) {
   if (isReadonlyType(node, kind)) return true;
-  if (node.type !== AST_NODE_TYPES40.TSTypeReference || node.typeName.type !== AST_NODE_TYPES40.Identifier) return false;
+  if (node.type !== AST_NODE_TYPES41.TSTypeReference || node.typeName.type !== AST_NODE_TYPES41.Identifier) return false;
   const name = node.typeName.name;
   const target = aliases.get(name);
   if (target === void 0 || seen.has(name)) return false;
   return isReadonlyTypeResolved(target, kind, aliases, /* @__PURE__ */ new Set([...seen, name]));
 }
 function isReadonlyType(node, kind) {
-  if (node.type === AST_NODE_TYPES40.TSTypeOperator && node.operator === "readonly") {
+  if (node.type === AST_NODE_TYPES41.TSTypeOperator && node.operator === "readonly") {
     return true;
   }
-  if (node.type !== AST_NODE_TYPES40.TSTypeReference || node.typeName.type !== AST_NODE_TYPES40.Identifier) {
+  if (node.type !== AST_NODE_TYPES41.TSTypeReference || node.typeName.type !== AST_NODE_TYPES41.Identifier) {
     return false;
   }
   if (node.typeName.name === "Readonly") {
@@ -9810,31 +9940,31 @@ function isReadonlyType(node, kind) {
   return kind === "literal" ? node.typeName.name === "ReadonlyArray" : node.typeName.name === `Readonly${kind}`;
 }
 function hasUnknownExplicitType(node, aliases) {
-  const annotation = node.id.type === AST_NODE_TYPES40.Identifier ? node.id.typeAnnotation?.typeAnnotation : void 0;
+  const annotation = node.id.type === AST_NODE_TYPES41.Identifier ? node.id.typeAnnotation?.typeAnnotation : void 0;
   if (annotation === void 0) return false;
-  if (annotation.type === AST_NODE_TYPES40.TSArrayType || annotation.type === AST_NODE_TYPES40.TSTypeOperator) return false;
-  if (annotation.type !== AST_NODE_TYPES40.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES40.Identifier) return true;
+  if (annotation.type === AST_NODE_TYPES41.TSArrayType || annotation.type === AST_NODE_TYPES41.TSTypeOperator) return false;
+  if (annotation.type !== AST_NODE_TYPES41.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES41.Identifier) return true;
   return !aliases.has(annotation.typeName.name) && !["Array", "Map", "Readonly", "ReadonlyArray", "ReadonlyMap", "ReadonlySet", "Set"].includes(annotation.typeName.name);
 }
 function referenceMutates(identifier, isUnshadowedGlobal) {
   let member = identifier.parent;
-  if (member?.type !== AST_NODE_TYPES40.MemberExpression || member.object !== identifier) {
-    return member?.type === AST_NODE_TYPES40.CallExpression && member.arguments[0] === identifier && member.callee.type === AST_NODE_TYPES40.MemberExpression && !member.callee.computed && member.callee.object.type === AST_NODE_TYPES40.Identifier && member.callee.object.name === "Object" && isUnshadowedGlobal(member.callee.object) && member.callee.property.type === AST_NODE_TYPES40.Identifier && member.callee.property.name === "assign";
+  if (member?.type !== AST_NODE_TYPES41.MemberExpression || member.object !== identifier) {
+    return member?.type === AST_NODE_TYPES41.CallExpression && member.arguments[0] === identifier && member.callee.type === AST_NODE_TYPES41.MemberExpression && !member.callee.computed && member.callee.object.type === AST_NODE_TYPES41.Identifier && member.callee.object.name === "Object" && isUnshadowedGlobal(member.callee.object) && member.callee.property.type === AST_NODE_TYPES41.Identifier && member.callee.property.name === "assign";
   }
-  while (member.parent.type === AST_NODE_TYPES40.MemberExpression && member.parent.object === member) {
+  while (member.parent.type === AST_NODE_TYPES41.MemberExpression && member.parent.object === member) {
     member = member.parent;
   }
   const parent = member.parent;
-  if (parent?.type === AST_NODE_TYPES40.AssignmentExpression && parent.left === member) {
+  if (parent?.type === AST_NODE_TYPES41.AssignmentExpression && parent.left === member) {
     return true;
   }
-  if (parent?.type === AST_NODE_TYPES40.UpdateExpression && parent.argument === member) {
+  if (parent?.type === AST_NODE_TYPES41.UpdateExpression && parent.argument === member) {
     return true;
   }
-  if (parent?.type === AST_NODE_TYPES40.UnaryExpression && parent.operator === "delete" && parent.argument === member) {
+  if (parent?.type === AST_NODE_TYPES41.UnaryExpression && parent.operator === "delete" && parent.argument === member) {
     return true;
   }
-  return parent?.type === AST_NODE_TYPES40.CallExpression && parent.callee === member && (member.property.type === AST_NODE_TYPES40.Identifier && !member.computed || member.property.type === AST_NODE_TYPES40.Literal && typeof member.property.value === "string") && MUTATING_METHODS.has(member.property.type === AST_NODE_TYPES40.Identifier ? member.property.name : member.property.value);
+  return parent?.type === AST_NODE_TYPES41.CallExpression && parent.callee === member && (member.property.type === AST_NODE_TYPES41.Identifier && !member.computed || member.property.type === AST_NODE_TYPES41.Literal && typeof member.property.value === "string") && MUTATING_METHODS.has(member.property.type === AST_NODE_TYPES41.Identifier ? member.property.name : member.property.value);
 }
 var prefer_immutable_module_constant_default = createRule({
   name: "prefer-immutable-module-constant",
@@ -9871,10 +10001,10 @@ var prefer_immutable_module_constant_default = createRule({
         seen.add(variable);
         for (const reference of variable.references) {
           const identifier = reference.identifier;
-          if (identifier.type !== AST_NODE_TYPES40.Identifier) continue;
+          if (identifier.type !== AST_NODE_TYPES41.Identifier) continue;
           if (referenceMutates(identifier, isUnshadowedGlobal)) return true;
           const declarator = identifier.parent;
-          if (declarator.type !== AST_NODE_TYPES40.VariableDeclarator || declarator.init !== identifier || declarator.id.type !== AST_NODE_TYPES40.Identifier || declarator.parent.type !== AST_NODE_TYPES40.VariableDeclaration || declarator.parent.kind !== "const") {
+          if (declarator.type !== AST_NODE_TYPES41.VariableDeclarator || declarator.init !== identifier || declarator.id.type !== AST_NODE_TYPES41.Identifier || declarator.parent.type !== AST_NODE_TYPES41.VariableDeclaration || declarator.parent.kind !== "const") {
             continue;
           }
           const alias = sourceCode.getDeclaredVariables(declarator)[0];
@@ -9886,32 +10016,32 @@ var prefer_immutable_module_constant_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          const declaration = statement.type === AST_NODE_TYPES40.ExportNamedDeclaration ? statement.declaration : statement;
-          if (declaration?.type === AST_NODE_TYPES40.TSTypeAliasDeclaration) {
+          const declaration = statement.type === AST_NODE_TYPES41.ExportNamedDeclaration ? statement.declaration : statement;
+          if (declaration?.type === AST_NODE_TYPES41.TSTypeAliasDeclaration) {
             typeAliases2.set(declaration.id.name, declaration.typeAnnotation);
           }
-          if (statement.type === AST_NODE_TYPES40.ExportNamedDeclaration) {
+          if (statement.type === AST_NODE_TYPES41.ExportNamedDeclaration) {
             if (statement.source !== null || statement.exportKind === "type") continue;
             for (const specifier of statement.specifiers) {
-              if (specifier.type === AST_NODE_TYPES40.ExportSpecifier && specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES40.Identifier) {
+              if (specifier.type === AST_NODE_TYPES41.ExportSpecifier && specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES41.Identifier) {
                 exportedNames2.add(specifier.local.name);
               }
             }
-          } else if (statement.type === AST_NODE_TYPES40.ExportDefaultDeclaration && unwrapTransparentExport(statement.declaration)?.type === AST_NODE_TYPES40.Identifier) {
+          } else if (statement.type === AST_NODE_TYPES41.ExportDefaultDeclaration && unwrapTransparentExport(statement.declaration)?.type === AST_NODE_TYPES41.Identifier) {
             exportedNames2.add(unwrapTransparentExport(statement.declaration).name);
           }
         }
       },
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== AST_NODE_TYPES40.VariableDeclaration || declaration.kind !== "const" || node.id.type !== AST_NODE_TYPES40.Identifier || node.init === null) {
+        if (declaration.type !== AST_NODE_TYPES41.VariableDeclaration || declaration.kind !== "const" || node.id.type !== AST_NODE_TYPES41.Identifier || node.init === null) {
           return;
         }
         const container = declaration.parent;
-        if (container.type !== AST_NODE_TYPES40.Program && !(container.type === AST_NODE_TYPES40.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES40.Program)) {
+        if (container.type !== AST_NODE_TYPES41.Program && !(container.type === AST_NODE_TYPES41.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES41.Program)) {
           return;
         }
-        const directlyExported = container.type === AST_NODE_TYPES40.ExportNamedDeclaration;
+        const directlyExported = container.type === AST_NODE_TYPES41.ExportNamedDeclaration;
         if (!CONSTANT_NAME.test(node.id.name) && !directlyExported && !exportedNames2.has(node.id.name)) {
           return;
         }
@@ -9936,14 +10066,14 @@ var prefer_immutable_module_constant_default = createRule({
   }
 });
 function unwrapTransparentExport(node) {
-  if (node.type === AST_NODE_TYPES40.TSSatisfiesExpression || node.type === AST_NODE_TYPES40.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES41.TSSatisfiesExpression || node.type === AST_NODE_TYPES41.TSNonNullExpression) {
     return unwrapTransparentExport(node.expression);
   }
   return node;
 }
 
 // src/rules/prefer-shadcn-primitives.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES41 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES42 } from "@typescript-eslint/utils";
 var preferShadcnPrimitivesDocumentation = {
   summary: "Require visible raw JSX controls to use the corresponding shared shadcn primitive.",
   rationale: "Shared primitives centralize interaction, accessibility, and visual behavior across the product.",
@@ -9988,16 +10118,16 @@ var AMBIGUOUS_INPUT_TYPES = /* @__PURE__ */ new Set([
   "submit"
 ]);
 function rawElementName(node) {
-  if (node.name.type !== AST_NODE_TYPES41.JSXIdentifier) return null;
+  if (node.name.type !== AST_NODE_TYPES42.JSXIdentifier) return null;
   const name = node.name.name;
   return Object.hasOwn(SHADCN_PRIMITIVES, name) ? name : null;
 }
 function effectiveAttribute(node, attributeName) {
   for (const attribute of node.attributes.toReversed()) {
-    if (attribute.type === AST_NODE_TYPES41.JSXSpreadAttribute) {
+    if (attribute.type === AST_NODE_TYPES42.JSXSpreadAttribute) {
       return { kind: "unknown" };
     }
-    if (attribute.name.type !== AST_NODE_TYPES41.JSXIdentifier || attribute.name.name !== attributeName) {
+    if (attribute.name.type !== AST_NODE_TYPES42.JSXIdentifier || attribute.name.name !== attributeName) {
       continue;
     }
     const value = staticString(attribute.value);
@@ -10006,17 +10136,17 @@ function effectiveAttribute(node, attributeName) {
   return { kind: "missing" };
 }
 function staticString(value) {
-  if (value?.type === AST_NODE_TYPES41.Literal) {
+  if (value?.type === AST_NODE_TYPES42.Literal) {
     return typeof value.value === "string" ? value.value : null;
   }
-  if (value?.type !== AST_NODE_TYPES41.JSXExpressionContainer) return null;
+  if (value?.type !== AST_NODE_TYPES42.JSXExpressionContainer) return null;
   return staticExpressionString(value.expression);
 }
 function staticExpressionString(expression) {
-  if (expression.type === AST_NODE_TYPES41.Literal) {
+  if (expression.type === AST_NODE_TYPES42.Literal) {
     return typeof expression.value === "string" ? expression.value : null;
   }
-  if (expression.type === AST_NODE_TYPES41.TemplateLiteral) {
+  if (expression.type === AST_NODE_TYPES42.TemplateLiteral) {
     let value = expression.quasis[0]?.value.cooked ?? "";
     for (const [index, substitution] of expression.expressions.entries()) {
       const staticSubstitution = staticExpressionString(substitution);
@@ -10026,13 +10156,13 @@ function staticExpressionString(expression) {
     }
     return value;
   }
-  if (expression.type === AST_NODE_TYPES41.TSAsExpression || expression.type === AST_NODE_TYPES41.TSNonNullExpression || expression.type === AST_NODE_TYPES41.TSSatisfiesExpression || expression.type === AST_NODE_TYPES41.TSTypeAssertion) {
+  if (expression.type === AST_NODE_TYPES42.TSAsExpression || expression.type === AST_NODE_TYPES42.TSNonNullExpression || expression.type === AST_NODE_TYPES42.TSSatisfiesExpression || expression.type === AST_NODE_TYPES42.TSTypeAssertion) {
     return staticExpressionString(expression.expression);
   }
   return null;
 }
 function isLabelableElement(node) {
-  if (node.openingElement.name.type !== AST_NODE_TYPES41.JSXIdentifier) {
+  if (node.openingElement.name.type !== AST_NODE_TYPES42.JSXIdentifier) {
     return false;
   }
   const name = node.openingElement.name.name;
@@ -10044,10 +10174,10 @@ function isLabelableElement(node) {
 }
 function containsLabelableElement(node) {
   return node.children.some((child) => {
-    if (child.type === AST_NODE_TYPES41.JSXElement) {
+    if (child.type === AST_NODE_TYPES42.JSXElement) {
       return isLabelableElement(child) || containsLabelableElement(child);
     }
-    if (child.type === AST_NODE_TYPES41.JSXFragment) {
+    if (child.type === AST_NODE_TYPES42.JSXFragment) {
       return containsLabelableElement(child);
     }
     return false;
@@ -10056,7 +10186,7 @@ function containsLabelableElement(node) {
 function isStaticallyAssociatedLabel(node) {
   const htmlFor = effectiveAttribute(node, "htmlFor");
   if (htmlFor.kind === "known" && htmlFor.value.trim().length > 0) return true;
-  return node.parent.type === AST_NODE_TYPES41.JSXElement && containsLabelableElement(node.parent);
+  return node.parent.type === AST_NODE_TYPES42.JSXElement && containsLabelableElement(node.parent);
 }
 function replacementFor(node, element) {
   if (element !== "input") return SHADCN_PRIMITIVES[element];
@@ -10127,7 +10257,7 @@ var prefer_shadcn_primitives_default = createRule({
 });
 
 // src/rules/prefer-module-level-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES42 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES43 } from "@typescript-eslint/utils";
 var preferModuleLevelConstantDocumentation = {
   summary: "Hoist literal-only constant collections and regexes out of function bodies to module scope so they are allocated once.",
   rationale: "Recreating immutable lookup data on every call wastes allocations and obscures its constant nature.",
@@ -10167,9 +10297,9 @@ var MUTATING_METHODS2 = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES7 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES42.FunctionDeclaration,
-  AST_NODE_TYPES42.FunctionExpression,
-  AST_NODE_TYPES42.ArrowFunctionExpression
+  AST_NODE_TYPES43.FunctionDeclaration,
+  AST_NODE_TYPES43.FunctionExpression,
+  AST_NODE_TYPES43.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile2(filename, sourceText) {
@@ -10182,14 +10312,14 @@ function isLocalFixtureFile(filename) {
   return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap3(node) {
-  if (node.type === AST_NODE_TYPES42.TSAsExpression || node.type === AST_NODE_TYPES42.TSSatisfiesExpression || node.type === AST_NODE_TYPES42.TSNonNullExpression) {
+  if (node.type === AST_NODE_TYPES43.TSAsExpression || node.type === AST_NODE_TYPES43.TSSatisfiesExpression || node.type === AST_NODE_TYPES43.TSNonNullExpression) {
     return unwrap3(node.expression);
   }
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === AST_NODE_TYPES42.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === AST_NODE_TYPES43.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -10197,29 +10327,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap3(node);
   switch (inner.type) {
-    case AST_NODE_TYPES42.Literal: {
+    case AST_NODE_TYPES43.Literal: {
       return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case AST_NODE_TYPES42.TemplateLiteral: {
+    case AST_NODE_TYPES43.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case AST_NODE_TYPES42.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === AST_NODE_TYPES42.Literal && typeof inner.argument.value === "number";
+    case AST_NODE_TYPES43.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === AST_NODE_TYPES43.Literal && typeof inner.argument.value === "number";
     }
-    case AST_NODE_TYPES42.ArrayExpression: {
+    case AST_NODE_TYPES43.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== AST_NODE_TYPES42.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== AST_NODE_TYPES43.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case AST_NODE_TYPES42.ObjectExpression: {
+    case AST_NODE_TYPES43.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== AST_NODE_TYPES42.Property) {
+        if (prop.type !== AST_NODE_TYPES43.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== AST_NODE_TYPES42.Literal) {
+        if (prop.computed && prop.key.type !== AST_NODE_TYPES43.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -10241,19 +10371,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === AST_NODE_TYPES42.ArrayExpression) {
+  if (node.type === AST_NODE_TYPES43.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === AST_NODE_TYPES42.ObjectExpression) {
+  if (node.type === AST_NODE_TYPES43.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === AST_NODE_TYPES42.NewExpression && node.callee.type === AST_NODE_TYPES42.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === AST_NODE_TYPES43.NewExpression && node.callee.type === AST_NODE_TYPES43.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === AST_NODE_TYPES42.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === AST_NODE_TYPES43.SpreadElement) {
       return null;
     }
     const entries = unwrap3(arg);
-    if (entries.type !== AST_NODE_TYPES42.ArrayExpression) {
+    if (entries.type !== AST_NODE_TYPES43.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -10262,7 +10392,7 @@ function classify(init, checkRegex) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap3(node);
-  if (inner.type === AST_NODE_TYPES42.CallExpression && inner.callee.type === AST_NODE_TYPES42.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES42.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === AST_NODE_TYPES42.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES42.SpreadElement) {
+  if (inner.type === AST_NODE_TYPES43.CallExpression && inner.callee.type === AST_NODE_TYPES43.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES43.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === AST_NODE_TYPES43.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES43.SpreadElement) {
     return unwrap3(inner.arguments[0]);
   }
   return inner;
@@ -10289,48 +10419,48 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === AST_NODE_TYPES42.MemberExpression) {
+  if (parent.type === AST_NODE_TYPES43.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === AST_NODE_TYPES42.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === AST_NODE_TYPES43.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === AST_NODE_TYPES42.UpdateExpression) {
+    if (grandparent.type === AST_NODE_TYPES43.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === AST_NODE_TYPES42.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === AST_NODE_TYPES43.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === AST_NODE_TYPES42.Identifier && MUTATING_METHODS2.has(parent.property.name) && grandparent.type === AST_NODE_TYPES42.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === AST_NODE_TYPES43.Identifier && MUTATING_METHODS2.has(parent.property.name) && grandparent.type === AST_NODE_TYPES43.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === AST_NODE_TYPES42.ForOfStatement && parent.right === identifier) {
+  if (parent.type === AST_NODE_TYPES43.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES42.SpreadElement) {
+  if (parent.type === AST_NODE_TYPES43.SpreadElement) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES42.BinaryExpression) {
+  if (parent.type === AST_NODE_TYPES43.BinaryExpression) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES42.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === AST_NODE_TYPES43.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === AST_NODE_TYPES42.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === AST_NODE_TYPES43.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
 }
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === AST_NODE_TYPES42.Identifier && callee.name === "structuredClone") {
+  if (callee.type === AST_NODE_TYPES43.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== AST_NODE_TYPES42.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES42.Identifier || callee.property.type !== AST_NODE_TYPES42.Identifier) {
+  if (callee.type !== AST_NODE_TYPES43.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES43.Identifier || callee.property.type !== AST_NODE_TYPES43.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -10393,7 +10523,7 @@ var prefer_module_level_constant_default = createRule({
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== AST_NODE_TYPES42.Identifier) {
+        if (reference.identifier.type !== AST_NODE_TYPES43.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -10405,10 +10535,10 @@ var prefer_module_level_constant_default = createRule({
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== AST_NODE_TYPES42.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== AST_NODE_TYPES43.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES42.Identifier || node.init === null) {
+        if (node.id.type !== AST_NODE_TYPES43.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -10435,7 +10565,7 @@ var prefer_module_level_constant_default = createRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES43 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES44 } from "@typescript-eslint/utils";
 var preferModuleLevelSchemaDocumentation = {
   summary: "Declare a Zod schema at module scope when it closes over nothing in the enclosing function",
   rationale: "A closed schema created inside a function is rebuilt on every call and cannot be reused or exported for inference.",
@@ -10502,9 +10632,9 @@ var I18N_RECEIVER_NAMES = /* @__PURE__ */ new Set([
   "intl"
 ]);
 var FUNCTION_TYPES8 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES43.ArrowFunctionExpression,
-  AST_NODE_TYPES43.FunctionDeclaration,
-  AST_NODE_TYPES43.FunctionExpression
+  AST_NODE_TYPES44.ArrowFunctionExpression,
+  AST_NODE_TYPES44.FunctionDeclaration,
+  AST_NODE_TYPES44.FunctionExpression
 ]);
 function schemaExpression(node) {
   let current = node;
@@ -10513,10 +10643,10 @@ function schemaExpression(node) {
     if (parent === void 0) {
       return current;
     }
-    if (parent.type === AST_NODE_TYPES43.MemberExpression && parent.object === current && !parent.computed && parent.property.type === AST_NODE_TYPES43.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
+    if (parent.type === AST_NODE_TYPES44.MemberExpression && parent.object === current && !parent.computed && parent.property.type === AST_NODE_TYPES44.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
       return current;
     }
-    if (parent.type === AST_NODE_TYPES43.MemberExpression && parent.object === current || parent.type === AST_NODE_TYPES43.CallExpression && parent.callee === current || parent.type === AST_NODE_TYPES43.TSAsExpression && parent.expression === current || parent.type === AST_NODE_TYPES43.TSNonNullExpression && parent.expression === current) {
+    if (parent.type === AST_NODE_TYPES44.MemberExpression && parent.object === current || parent.type === AST_NODE_TYPES44.CallExpression && parent.callee === current || parent.type === AST_NODE_TYPES44.TSAsExpression && parent.expression === current || parent.type === AST_NODE_TYPES44.TSNonNullExpression && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -10567,22 +10697,22 @@ function subtreeSome(root, predicate) {
 function readsReceiver(node) {
   return subtreeSome(
     node,
-    (inner) => inner.type === AST_NODE_TYPES43.ThisExpression || inner.type === AST_NODE_TYPES43.Super || inner.type === AST_NODE_TYPES43.Identifier && inner.name === "arguments"
+    (inner) => inner.type === AST_NODE_TYPES44.ThisExpression || inner.type === AST_NODE_TYPES44.Super || inner.type === AST_NODE_TYPES44.Identifier && inner.name === "arguments"
   );
 }
 function buildsLocalizedText(node) {
   return subtreeSome(node, (inner) => {
-    if (inner.type === AST_NODE_TYPES43.TaggedTemplateExpression) {
+    if (inner.type === AST_NODE_TYPES44.TaggedTemplateExpression) {
       return true;
     }
-    if (inner.type !== AST_NODE_TYPES43.CallExpression) {
+    if (inner.type !== AST_NODE_TYPES44.CallExpression) {
       return false;
     }
     const { callee } = inner;
-    if (callee.type === AST_NODE_TYPES43.Identifier) {
+    if (callee.type === AST_NODE_TYPES44.Identifier) {
       return I18N_CALLEE_NAMES.has(callee.name);
     }
-    return callee.type === AST_NODE_TYPES43.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES43.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
+    return callee.type === AST_NODE_TYPES44.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES44.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
   });
 }
 function collectReferences(scope, out) {
@@ -10646,15 +10776,15 @@ var prefer_module_level_schema_default = createRule({
     }
     const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodCall(node) {
-      return node.type === AST_NODE_TYPES43.CallExpression && node.callee.type === AST_NODE_TYPES43.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES43.Identifier && zodNamespaces.has(node.callee.object.name);
+      return node.type === AST_NODE_TYPES44.CallExpression && node.callee.type === AST_NODE_TYPES44.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES44.Identifier && zodNamespaces.has(node.callee.object.name);
     }
     function isCovered(node) {
       let current = node.parent ?? void 0;
       while (current !== void 0) {
-        if (current !== node && isZodCall(current) && current.callee.type === AST_NODE_TYPES43.MemberExpression && current.callee.property.type === AST_NODE_TYPES43.Identifier && factories.has(current.callee.property.name)) {
+        if (current !== node && isZodCall(current) && current.callee.type === AST_NODE_TYPES44.MemberExpression && current.callee.property.type === AST_NODE_TYPES44.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === AST_NODE_TYPES43.CallExpression && (current.callee.type === AST_NODE_TYPES43.Identifier && memoCallees.has(current.callee.name) || current.callee.type === AST_NODE_TYPES43.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES43.Identifier && memoCallees.has(current.callee.property.name))) {
+        if (current.type === AST_NODE_TYPES44.CallExpression && (current.callee.type === AST_NODE_TYPES44.Identifier && memoCallees.has(current.callee.name) || current.callee.type === AST_NODE_TYPES44.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES44.Identifier && memoCallees.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -10669,11 +10799,11 @@ var prefer_module_level_schema_default = createRule({
         if (parent === void 0) {
           return confirmed;
         }
-        if (parent.type === AST_NODE_TYPES43.Property && parent.value === current || parent.type === AST_NODE_TYPES43.ObjectExpression || parent.type === AST_NODE_TYPES43.ArrayExpression) {
+        if (parent.type === AST_NODE_TYPES44.Property && parent.value === current || parent.type === AST_NODE_TYPES44.ObjectExpression || parent.type === AST_NODE_TYPES44.ArrayExpression) {
           current = parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES43.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
+        if (parent.type === AST_NODE_TYPES44.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
           current = schemaExpression(parent);
           confirmed = current;
           continue;
@@ -10683,7 +10813,7 @@ var prefer_module_level_schema_default = createRule({
     }
     function isSchemaComposition(node) {
       const { callee } = node;
-      const isCombinator = callee.type === AST_NODE_TYPES43.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES43.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
+      const isCombinator = callee.type === AST_NODE_TYPES44.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES44.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
       return isCombinator || isZodCall(node);
     }
     function closesOverNothing(node, enclosing) {
@@ -10703,12 +10833,12 @@ var prefer_module_level_schema_default = createRule({
         for (const definition of resolved.defs) {
           if (definition.type === "ImportBinding") {
             const parent = reference.identifier.parent;
-            if (parent?.type === AST_NODE_TYPES43.CallExpression && parent.callee === reference.identifier && !zodNamespaces.has(reference.identifier.name)) {
+            if (parent?.type === AST_NODE_TYPES44.CallExpression && parent.callee === reference.identifier && !zodNamespaces.has(reference.identifier.name)) {
               return false;
             }
             continue;
           }
-          if (definition.node.type === AST_NODE_TYPES43.VariableDeclarator && definition.node.parent.type === AST_NODE_TYPES43.VariableDeclaration && definition.node.parent.kind !== "const") {
+          if (definition.node.type === AST_NODE_TYPES44.VariableDeclarator && definition.node.parent.type === AST_NODE_TYPES44.VariableDeclaration && definition.node.parent.kind !== "const") {
             return false;
           }
           const [defStart, defEnd] = definition.node.range;
@@ -10724,13 +10854,13 @@ var prefer_module_level_schema_default = createRule({
     }
     function ownerName(enclosing) {
       const parent = enclosing.parent ?? void 0;
-      if (enclosing.type === AST_NODE_TYPES43.FunctionDeclaration && enclosing.id !== null) {
+      if (enclosing.type === AST_NODE_TYPES44.FunctionDeclaration && enclosing.id !== null) {
         return enclosing.id.name;
       }
-      if (parent !== void 0 && parent.type === AST_NODE_TYPES43.VariableDeclarator && parent.id.type === AST_NODE_TYPES43.Identifier) {
+      if (parent !== void 0 && parent.type === AST_NODE_TYPES44.VariableDeclarator && parent.id.type === AST_NODE_TYPES44.Identifier) {
         return parent.id.name;
       }
-      if (parent !== void 0 && (parent.type === AST_NODE_TYPES43.MethodDefinition || parent.type === AST_NODE_TYPES43.Property) && parent.key.type === AST_NODE_TYPES43.Identifier) {
+      if (parent !== void 0 && (parent.type === AST_NODE_TYPES44.MethodDefinition || parent.type === AST_NODE_TYPES44.Property) && parent.key.type === AST_NODE_TYPES44.Identifier) {
         return parent.key.name;
       }
       return "this function";
@@ -10741,7 +10871,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES43.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES43.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES43.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES43.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === AST_NODE_TYPES44.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES44.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES44.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES44.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -10751,7 +10881,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const callee = node.callee;
-        if (callee.property.type !== AST_NODE_TYPES43.Identifier) {
+        if (callee.property.type !== AST_NODE_TYPES44.Identifier) {
           return;
         }
         const factory = callee.property.name;
@@ -10766,7 +10896,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const shape = node.arguments[0];
-        if (shape !== void 0 && shape.type === AST_NODE_TYPES43.ObjectExpression && shape.properties.length < minProperties) {
+        if (shape !== void 0 && shape.type === AST_NODE_TYPES44.ObjectExpression && shape.properties.length < minProperties) {
           return;
         }
         const expression = schemaExpression(node);
@@ -10794,7 +10924,7 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES45, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
 var preferNativeRandomUuidDocumentation = {
   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.",
@@ -10808,7 +10938,7 @@ var preferNativeRandomUuidDocumentation = {
   ]
 };
 function requireUuid(node) {
-  return node?.type === AST_NODE_TYPES44.CallExpression && node.callee.type === AST_NODE_TYPES44.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES44.Literal && node.arguments[0].value === "uuid";
+  return node?.type === AST_NODE_TYPES45.CallExpression && node.callee.type === AST_NODE_TYPES45.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === AST_NODE_TYPES45.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -10852,37 +10982,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_TYPES44.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES44.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === AST_NODE_TYPES45.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES45.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === AST_NODE_TYPES44.ImportNamespaceSpecifier) {
+          } else if (specifier.type === AST_NODE_TYPES45.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== AST_NODE_TYPES44.CallExpression || node.init.callee.type !== AST_NODE_TYPES44.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== AST_NODE_TYPES45.CallExpression || node.init.callee.type !== AST_NODE_TYPES45.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === AST_NODE_TYPES44.Identifier) {
+        if (node.id.type === AST_NODE_TYPES45.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== AST_NODE_TYPES44.ObjectPattern) return;
+        if (node.id.type !== AST_NODE_TYPES45.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === AST_NODE_TYPES44.Property && !property.computed && (property.key.type === AST_NODE_TYPES44.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES44.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES44.Identifier) {
+          if (property.type === AST_NODE_TYPES45.Property && !property.computed && (property.key.type === AST_NODE_TYPES45.Identifier && property.key.name === "v4" || property.key.type === AST_NODE_TYPES45.Literal && property.key.value === "v4") && property.value.type === AST_NODE_TYPES45.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === AST_NODE_TYPES44.Identifier) {
+        if (node.callee.type === AST_NODE_TYPES45.Identifier) {
           const variable2 = resolve(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report(node);
           return;
         }
-        if (node.callee.type !== AST_NODE_TYPES44.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES44.Identifier || node.callee.property.type !== AST_NODE_TYPES44.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== AST_NODE_TYPES45.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES45.Identifier || node.callee.property.type !== AST_NODE_TYPES45.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve(node.callee.object);
@@ -10893,7 +11023,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES45, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES46, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
 var preferNonNullableCollectionDocumentation = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -10909,33 +11039,33 @@ var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
   if (node.computed) return null;
-  if (key.type === AST_NODE_TYPES45.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES45.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES46.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES46.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function isArrayType(node) {
-  if (node.type === AST_NODE_TYPES45.TSArrayType) return true;
-  return node.type === AST_NODE_TYPES45.TSTypeReference && node.typeName.type === AST_NODE_TYPES45.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === AST_NODE_TYPES46.TSArrayType) return true;
+  return node.type === AST_NODE_TYPES46.TSTypeReference && node.typeName.type === AST_NODE_TYPES46.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function nullableProperty(node) {
   if (node.optional) return null;
   const name = propertyName(node);
   const annotation = node.typeAnnotation?.typeAnnotation;
-  if (name === null || annotation?.type !== AST_NODE_TYPES45.TSUnionType) return null;
+  if (name === null || annotation?.type !== AST_NODE_TYPES46.TSUnionType) return null;
   const concrete = annotation.types.filter(
-    (member) => member.type !== AST_NODE_TYPES45.TSNullKeyword && member.type !== AST_NODE_TYPES45.TSUndefinedKeyword
+    (member) => member.type !== AST_NODE_TYPES46.TSNullKeyword && member.type !== AST_NODE_TYPES46.TSUndefinedKeyword
   );
   if (concrete.length === 0 || !concrete.every(isArrayType)) return null;
-  const acceptsNull = annotation.types.some((member) => member.type === AST_NODE_TYPES45.TSNullKeyword);
+  const acceptsNull = annotation.types.some((member) => member.type === AST_NODE_TYPES46.TSNullKeyword);
   const acceptsUndefined = annotation.types.some(
-    (member) => member.type === AST_NODE_TYPES45.TSUndefinedKeyword
+    (member) => member.type === AST_NODE_TYPES46.TSUndefinedKeyword
   );
   if (!acceptsNull && !acceptsUndefined) return null;
   return { name, node, acceptsNull, acceptsUndefined };
 }
 function shapeProperties(members) {
   return members.flatMap((member) => {
-    if (member.type !== AST_NODE_TYPES45.TSPropertySignature) return [];
+    if (member.type !== AST_NODE_TYPES46.TSPropertySignature) return [];
     const property = nullableProperty(member);
     return property === null ? [] : [property];
   });
@@ -10943,14 +11073,14 @@ function shapeProperties(members) {
 function typeIndex(program) {
   const index = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const exported = statement.type === AST_NODE_TYPES45.ExportNamedDeclaration;
+    const exported = statement.type === AST_NODE_TYPES46.ExportNamedDeclaration;
     const declaration = exported ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES45.TSInterfaceDeclaration) {
+    if (declaration?.type === AST_NODE_TYPES46.TSInterfaceDeclaration) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.body.body)
       });
-    } else if (declaration?.type === AST_NODE_TYPES45.TSTypeAliasDeclaration && declaration.typeAnnotation.type === AST_NODE_TYPES45.TSTypeLiteral) {
+    } else if (declaration?.type === AST_NODE_TYPES46.TSTypeAliasDeclaration && declaration.typeAnnotation.type === AST_NODE_TYPES46.TSTypeLiteral) {
       index.set(declaration.id.name, {
         exported,
         properties: shapeProperties(declaration.typeAnnotation.members)
@@ -10960,42 +11090,42 @@ function typeIndex(program) {
   return index;
 }
 function emptyArray(node) {
-  return node.type === AST_NODE_TYPES45.ArrayExpression && node.elements.length === 0;
+  return node.type === AST_NODE_TYPES46.ArrayExpression && node.elements.length === 0;
 }
 function sameAccess(node, access) {
   if (access.kind === "identifier") {
-    return node.type === AST_NODE_TYPES45.Identifier && node.name === access.name;
+    return node.type === AST_NODE_TYPES46.Identifier && node.name === access.name;
   }
-  return node.type === AST_NODE_TYPES45.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES45.Identifier && node.object.name === access.object && node.property.type === AST_NODE_TYPES45.Identifier && node.property.name === access.property;
+  return node.type === AST_NODE_TYPES46.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES46.Identifier && node.object.name === access.object && node.property.type === AST_NODE_TYPES46.Identifier && node.property.name === access.property;
 }
 function isNullGuard(node, access) {
-  if (node.type === AST_NODE_TYPES45.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
-  if (node.type !== AST_NODE_TYPES45.BinaryExpression || !["==", "==="].includes(node.operator)) {
+  if (node.type === AST_NODE_TYPES46.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
+  if (node.type !== AST_NODE_TYPES46.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
-  const nullish = (value) => value.type === AST_NODE_TYPES45.Literal && value.value === null || value.type === AST_NODE_TYPES45.Identifier && value.name === "undefined";
+  const nullish = (value) => value.type === AST_NODE_TYPES46.Literal && value.value === null || value.type === AST_NODE_TYPES46.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_TYPES45.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
-  if (node.type !== AST_NODE_TYPES45.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
+  if (node.type === AST_NODE_TYPES46.UnaryExpression && node.operator === "!" && memberLengthOf(node.argument, access)) return true;
+  if (node.type !== AST_NODE_TYPES46.BinaryExpression || !["==", "===", "<="].includes(node.operator)) {
     return false;
   }
-  const zero = (value) => value.type === AST_NODE_TYPES45.Literal && value.value === 0;
+  const zero = (value) => value.type === AST_NODE_TYPES46.Literal && value.value === 0;
   return memberLengthOf(node.left, access) && zero(node.right) || memberLengthOf(node.right, access) && zero(node.left);
 }
 function memberLengthOf(node, access) {
-  const target = node.type === AST_NODE_TYPES45.ChainExpression ? node.expression : node;
-  return target.type === AST_NODE_TYPES45.MemberExpression && !target.computed && target.property.type === AST_NODE_TYPES45.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+  const target = node.type === AST_NODE_TYPES46.ChainExpression ? node.expression : node;
+  return target.type === AST_NODE_TYPES46.MemberExpression && !target.computed && target.property.type === AST_NODE_TYPES46.Identifier && target.property.name === "length" && sameAccess(target.object, access);
 }
 function optionalMemberLengthOf(node, access) {
-  return node.type === AST_NODE_TYPES45.ChainExpression && node.expression.type === AST_NODE_TYPES45.MemberExpression && node.expression.optional && memberLengthOf(node, access);
+  return node.type === AST_NODE_TYPES46.ChainExpression && node.expression.type === AST_NODE_TYPES46.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
-  if (fn.body.type !== AST_NODE_TYPES45.BlockStatement) return false;
+  if (fn.body.type !== AST_NODE_TYPES46.BlockStatement) return false;
   const first = fn.body.body[0];
-  if (first?.type !== AST_NODE_TYPES45.IfStatement) return false;
-  const terminating = first.consequent.type === AST_NODE_TYPES45.ReturnStatement || first.consequent.type === AST_NODE_TYPES45.ThrowStatement || first.consequent.type === AST_NODE_TYPES45.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === AST_NODE_TYPES45.ReturnStatement || first.consequent.body[0]?.type === AST_NODE_TYPES45.ThrowStatement);
+  if (first?.type !== AST_NODE_TYPES46.IfStatement) return false;
+  const terminating = first.consequent.type === AST_NODE_TYPES46.ReturnStatement || first.consequent.type === AST_NODE_TYPES46.ThrowStatement || first.consequent.type === AST_NODE_TYPES46.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === AST_NODE_TYPES46.ReturnStatement || first.consequent.body[0]?.type === AST_NODE_TYPES46.ThrowStatement);
   if (!terminating) return false;
   if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
   return contains(first.test, visitorKeys, (node) => isNullGuard(node, access)) && contains(first.test, visitorKeys, (node) => isEmptyGuard(node, access));
@@ -11013,14 +11143,14 @@ 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_TYPES45.ArrowFunctionExpression || current.type === AST_NODE_TYPES45.FunctionDeclaration || current.type === AST_NODE_TYPES45.FunctionExpression)) return false;
+    if (current !== node && (current.type === AST_NODE_TYPES46.ArrowFunctionExpression || current.type === AST_NODE_TYPES46.FunctionDeclaration || current.type === AST_NODE_TYPES46.FunctionExpression)) return false;
     current = current.parent;
   }
   return current === fn;
 }
 function directlyCoalesced(node) {
   const parent = node.parent;
-  return parent?.type === AST_NODE_TYPES45.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
+  return parent?.type === AST_NODE_TYPES46.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
   const variable = ASTUtils13.findVariable(context.sourceCode.getScope(binding), binding.name);
@@ -11035,7 +11165,7 @@ function memberIsOnlyCoalesced(context, object, property, fn) {
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
     const parent = reference.identifier.parent;
-    if (parent?.type === AST_NODE_TYPES45.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === AST_NODE_TYPES45.Identifier && parent.property.name === property) return [parent];
+    if (parent?.type === AST_NODE_TYPES46.MemberExpression && !parent.computed && parent.object === reference.identifier && parent.property.type === AST_NODE_TYPES46.Identifier && parent.property.name === property) return [parent];
     return [];
   });
   return accesses.length > 0 && accesses.every((access) => access !== null && directlyCoalesced(access));
@@ -11061,8 +11191,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_TYPES45.TSTypeLiteral) return shapeProperties(annotation.members);
-      if (annotation?.type === AST_NODE_TYPES45.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES45.Identifier) {
+      if (annotation?.type === AST_NODE_TYPES46.TSTypeLiteral) return shapeProperties(annotation.members);
+      if (annotation?.type === AST_NODE_TYPES46.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES46.Identifier) {
         const shape = shapes.get(annotation.typeName.name);
         return shape?.exported === false ? shape.properties : [];
       }
@@ -11075,21 +11205,21 @@ var prefer_non_nullable_collection_default = createRule({
     }
     function checkFunction(fn) {
       for (const rawParameter of fn.params) {
-        const parameter = rawParameter.type === AST_NODE_TYPES45.AssignmentPattern ? rawParameter.left : rawParameter;
-        if (parameter.type === AST_NODE_TYPES45.ObjectPattern) {
+        const parameter = rawParameter.type === AST_NODE_TYPES46.AssignmentPattern ? rawParameter.left : rawParameter;
+        if (parameter.type === AST_NODE_TYPES46.ObjectPattern) {
           const properties2 = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
           for (const property of properties2) {
             const bindingProperty = parameter.properties.find(
-              (entry) => entry.type === AST_NODE_TYPES45.Property && !entry.computed && entry.key.type === AST_NODE_TYPES45.Identifier && entry.key.name === property.name
+              (entry) => entry.type === AST_NODE_TYPES46.Property && !entry.computed && entry.key.type === AST_NODE_TYPES46.Identifier && entry.key.name === property.name
             );
             if (bindingProperty === void 0) continue;
             const value = bindingProperty.value;
-            const binding = value.type === AST_NODE_TYPES45.AssignmentPattern ? value.left : value;
-            if (binding.type !== AST_NODE_TYPES45.Identifier) {
+            const binding = value.type === AST_NODE_TYPES46.AssignmentPattern ? value.left : value;
+            if (binding.type !== AST_NODE_TYPES46.Identifier) {
               record(property, false);
               continue;
             }
-            if (value.type === AST_NODE_TYPES45.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
+            if (value.type === AST_NODE_TYPES46.AssignmentPattern && emptyArray(value.right) && property.acceptsUndefined && !property.acceptsNull) {
               record(property, true);
               continue;
             }
@@ -11101,7 +11231,7 @@ var prefer_non_nullable_collection_default = createRule({
           }
           continue;
         }
-        if (parameter.type !== AST_NODE_TYPES45.Identifier) continue;
+        if (parameter.type !== AST_NODE_TYPES46.Identifier) continue;
         const properties = propertiesFor(parameter.typeAnnotation?.typeAnnotation);
         for (const property of properties) {
           const access = {
@@ -11139,8 +11269,9 @@ var prefer_non_nullable_collection_default = createRule({
 
 // src/rules/prefer-await-in-async-return.ts
 import {
+  ASTUtils as ASTUtils14,
   ESLintUtils as ESLintUtils3,
-  AST_NODE_TYPES as AST_NODE_TYPES46
+  AST_NODE_TYPES as AST_NODE_TYPES47
 } from "@typescript-eslint/utils";
 import * as ts2 from "typescript";
 var preferAwaitInAsyncReturnDocumentation = {
@@ -11151,7 +11282,8 @@ var preferAwaitInAsyncReturnDocumentation = {
   since: "15.6.3",
   limitations: [
     "Only a single directly returned `.then` call with an inline callback is checked.",
-    "The receiver must be proven Promise-like by TypeScript; untyped files and larger chains are intentionally ignored."
+    "The receiver must be proven Promise-like by TypeScript; untyped files and larger chains are intentionally ignored.",
+    "Direct loader callbacks passed to resolved `React.lazy` and `next/dynamic` imports are excluded because returning the module Promise is their framework contract."
   ],
   examples: [
     {
@@ -11180,30 +11312,30 @@ var preferAwaitInAsyncReturnDocumentation = {
     }
   ]
 };
-function isDirectAsyncReturn(node) {
+function directAsyncReturnOwner(node) {
   const parent = node.parent;
-  if (parent.type === AST_NODE_TYPES46.ArrowFunctionExpression && parent.body === node) {
-    return parent.async && !parent.generator;
+  if (parent.type === AST_NODE_TYPES47.ArrowFunctionExpression && parent.body === node) {
+    return parent.async && !parent.generator ? parent : null;
   }
-  if (parent.type !== AST_NODE_TYPES46.ReturnStatement || parent.argument !== node) {
-    return false;
+  if (parent.type !== AST_NODE_TYPES47.ReturnStatement || parent.argument !== node) {
+    return null;
   }
   let owner = parent.parent;
   while (owner !== void 0 && !isRuntimeFunction(owner)) {
     owner = owner.parent;
   }
-  return owner !== void 0 && owner.async && !owner.generator;
+  return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
-  return node.type === AST_NODE_TYPES46.ArrowFunctionExpression || node.type === AST_NODE_TYPES46.FunctionDeclaration || node.type === AST_NODE_TYPES46.FunctionExpression;
+  return node.type === AST_NODE_TYPES47.ArrowFunctionExpression || node.type === AST_NODE_TYPES47.FunctionDeclaration || node.type === AST_NODE_TYPES47.FunctionExpression;
 }
 function promiseThenReceiver(node) {
   const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES46.MemberExpression || callee.computed || callee.optional || callee.property.type !== AST_NODE_TYPES46.Identifier || callee.property.name !== "then" || node.optional || node.arguments.length !== 1) {
+  if (callee.type !== AST_NODE_TYPES47.MemberExpression || callee.computed || callee.optional || callee.property.type !== AST_NODE_TYPES47.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_TYPES46.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES46.FunctionExpression) {
+  if (callback === void 0 || callback.type !== AST_NODE_TYPES47.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES47.FunctionExpression) {
     return null;
   }
   return callee.object;
@@ -11249,9 +11381,33 @@ var prefer_await_in_async_return_default = createRule({
       services = null;
     }
     if (services === null) return {};
+    const frameworkLoaders = /* @__PURE__ */ new Set();
+    const rememberFrameworkLoader = (identifier) => {
+      const variable = ASTUtils14.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_TYPES47.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES47.Identifier) return false;
+      const variable = ASTUtils14.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_TYPES47.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES47.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_TYPES47.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+          }
+        }
+      },
       CallExpression(node) {
-        if (!isDirectAsyncReturn(node)) return;
+        const owner = directAsyncReturnOwner(node);
+        if (owner === null || isFrameworkLoaderCallback(owner)) return;
         const receiver = promiseThenReceiver(node);
         if (receiver === null || !isProvenPromiseLike(receiver, services)) {
           return;
@@ -11263,7 +11419,7 @@ var prefer_await_in_async_return_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES47 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES48 } from "@typescript-eslint/utils";
 var preferSchemaForApiPayloadDocumentation = {
   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.",
@@ -11278,9 +11434,9 @@ var preferSchemaForApiPayloadDocumentation = {
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === AST_NODE_TYPES47.TSAsExpression || current.type === AST_NODE_TYPES47.TSTypeAssertion || current.type === AST_NODE_TYPES47.TSNonNullExpression || current.type === AST_NODE_TYPES47.TSSatisfiesExpression) {
+    if (current.type === AST_NODE_TYPES48.TSAsExpression || current.type === AST_NODE_TYPES48.TSTypeAssertion || current.type === AST_NODE_TYPES48.TSNonNullExpression || current.type === AST_NODE_TYPES48.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === AST_NODE_TYPES47.ChainExpression) {
+    } else if (current.type === AST_NODE_TYPES48.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -11295,23 +11451,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === AST_NODE_TYPES47.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES47.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === AST_NODE_TYPES48.MemberExpression && !inner.computed && inner.property.type === AST_NODE_TYPES48.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node, isKnownLocalText) => {
   let current = unwrap4(node);
   if (current === null) return false;
-  if (current.type === AST_NODE_TYPES47.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES48.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== AST_NODE_TYPES47.CallExpression) {
+  if (current === null || current.type !== AST_NODE_TYPES48.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== AST_NODE_TYPES47.MemberExpression) {
+  if (callee === null || callee.type !== AST_NODE_TYPES48.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== AST_NODE_TYPES47.Identifier) {
+  if (property === null || property.type !== AST_NODE_TYPES48.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -11321,17 +11477,17 @@ var isRawPayloadSource = (node, isKnownLocalText) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES47.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
+  return property.name === "parse" && object !== null && object.type === AST_NODE_TYPES48.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isDirectLocalFileRead = (node) => {
   let current = unwrap4(node);
-  if (current?.type === AST_NODE_TYPES47.AwaitExpression) {
+  if (current?.type === AST_NODE_TYPES48.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current?.type !== AST_NODE_TYPES47.CallExpression) return false;
+  if (current?.type !== AST_NODE_TYPES48.CallExpression) return false;
   const callee = unwrap4(current.callee);
-  const name = callee?.type === AST_NODE_TYPES47.Identifier ? callee.name : callee?.type === AST_NODE_TYPES47.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES47.Identifier ? callee.property.name : null;
+  const name = callee?.type === AST_NODE_TYPES48.Identifier ? callee.name : callee?.type === AST_NODE_TYPES48.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES48.Identifier ? callee.property.name : null;
   return name !== null && FILE_READ_RE.test(name);
 };
 var isLocalFileRead = (node) => {
@@ -11358,15 +11514,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_TYPES47.CallExpression) continue;
+    if (current.type !== AST_NODE_TYPES48.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === AST_NODE_TYPES47.MemberExpression) {
+    while (callee.type === AST_NODE_TYPES48.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === AST_NODE_TYPES47.CallExpression) {
+    if (callee.type === AST_NODE_TYPES48.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === AST_NODE_TYPES47.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === AST_NODE_TYPES48.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -11385,22 +11541,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_TYPES47.TSAsExpression || parent.type === AST_NODE_TYPES47.TSTypeAssertion || parent.type === AST_NODE_TYPES47.TSNonNullExpression || parent.type === AST_NODE_TYPES47.TSSatisfiesExpression || parent.type === AST_NODE_TYPES47.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === AST_NODE_TYPES48.TSAsExpression || parent.type === AST_NODE_TYPES48.TSTypeAssertion || parent.type === AST_NODE_TYPES48.TSNonNullExpression || parent.type === AST_NODE_TYPES48.TSSatisfiesExpression || parent.type === AST_NODE_TYPES48.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === AST_NODE_TYPES47.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === AST_NODE_TYPES48.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== AST_NODE_TYPES47.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== AST_NODE_TYPES48.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === AST_NODE_TYPES47.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES47.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES47.Identifier && callee.property.name === "isArray") {
+  if (callee.type === AST_NODE_TYPES48.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES48.Identifier && callee.object.name === "Array" && callee.property.type === AST_NODE_TYPES48.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === AST_NODE_TYPES47.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === AST_NODE_TYPES48.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "bigint",
@@ -11411,13 +11567,13 @@ var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
   "undefined"
 ]);
 var bindingValidationPolarity = (test, bindingName) => {
-  if (test.type === AST_NODE_TYPES47.UnaryExpression && test.operator === "!") {
+  if (test.type === AST_NODE_TYPES48.UnaryExpression && test.operator === "!") {
     const inner = bindingValidationPolarity(test.argument, bindingName);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === AST_NODE_TYPES47.BinaryExpression) {
-    const typeofName = (node) => node.type === AST_NODE_TYPES47.UnaryExpression && node.operator === "typeof" && node.argument.type === AST_NODE_TYPES47.Identifier ? node.argument.name : null;
-    const literalType = (node) => node.type === AST_NODE_TYPES47.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+  if (test.type === AST_NODE_TYPES48.BinaryExpression) {
+    const typeofName = (node) => node.type === AST_NODE_TYPES48.UnaryExpression && node.operator === "typeof" && node.argument.type === AST_NODE_TYPES48.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === AST_NODE_TYPES48.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 === "==") {
@@ -11425,9 +11581,9 @@ var bindingValidationPolarity = (test, bindingName) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === AST_NODE_TYPES47.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === AST_NODE_TYPES47.Identifier && test.arguments[0].name === bindingName && test.callee.type === AST_NODE_TYPES47.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES47.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES47.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === AST_NODE_TYPES48.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === AST_NODE_TYPES48.Identifier && test.arguments[0].name === bindingName && test.callee.type === AST_NODE_TYPES48.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES48.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES48.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
 };
-var plainMemberAccess = (node) => node.type === AST_NODE_TYPES47.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES47.Identifier && node.property.type === AST_NODE_TYPES47.Identifier ? { object: node.object.name, property: node.property.name } : null;
+var plainMemberAccess = (node) => node.type === AST_NODE_TYPES48.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES48.Identifier && node.property.type === AST_NODE_TYPES48.Identifier ? { object: node.object.name, property: node.property.name } : null;
 var isSamePlainMember = (node, access) => {
   const candidate = plainMemberAccess(node);
   return candidate !== null && candidate.object === access.object && candidate.property === access.property;
@@ -11435,19 +11591,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_TYPES47.ConditionalExpression) {
+    if (current.type === AST_NODE_TYPES48.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_TYPES47.IfStatement) {
+    if (current.type === AST_NODE_TYPES48.IfStatement) {
       const polarity = bindingValidationPolarity(current.test, bindingName);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === AST_NODE_TYPES47.FunctionDeclaration || current.type === AST_NODE_TYPES47.FunctionExpression || current.type === AST_NODE_TYPES47.ArrowFunctionExpression) {
+    if (current.type === AST_NODE_TYPES48.FunctionDeclaration || current.type === AST_NODE_TYPES48.FunctionExpression || current.type === AST_NODE_TYPES48.ArrowFunctionExpression) {
       return false;
     }
   }
@@ -11455,32 +11611,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_TYPES47.ConditionalExpression) {
+    if (current.type === AST_NODE_TYPES48.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_TYPES47.IfStatement) {
+    if (current.type === AST_NODE_TYPES48.IfStatement) {
       const polarity = memberValidationPolarity(current.test, access);
       if (polarity === "valid-when-true" && nodeWithin2(node, current.consequent) || polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(node, current.alternate)) {
         return true;
       }
     }
-    if (current.type === AST_NODE_TYPES47.FunctionDeclaration || current.type === AST_NODE_TYPES47.FunctionExpression || current.type === AST_NODE_TYPES47.ArrowFunctionExpression) {
+    if (current.type === AST_NODE_TYPES48.FunctionDeclaration || current.type === AST_NODE_TYPES48.FunctionExpression || current.type === AST_NODE_TYPES48.ArrowFunctionExpression) {
       return false;
     }
   }
   return false;
 };
 var memberValidationPolarity = (test, access) => {
-  if (test.type === AST_NODE_TYPES47.UnaryExpression && test.operator === "!") {
+  if (test.type === AST_NODE_TYPES48.UnaryExpression && test.operator === "!") {
     const inner = memberValidationPolarity(test.argument, access);
     return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
   }
-  if (test.type === AST_NODE_TYPES47.BinaryExpression) {
-    const isMatchingTypeof = (node) => node.type === AST_NODE_TYPES47.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
-    const isPrimitiveType = (node) => node.type === AST_NODE_TYPES47.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value);
+  if (test.type === AST_NODE_TYPES48.BinaryExpression) {
+    const isMatchingTypeof = (node) => node.type === AST_NODE_TYPES48.UnaryExpression && node.operator === "typeof" && isSamePlainMember(node.argument, access);
+    const isPrimitiveType = (node) => node.type === AST_NODE_TYPES48.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;
     }
@@ -11489,15 +11645,15 @@ var memberValidationPolarity = (test, access) => {
     }
     return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
   }
-  return test.type === AST_NODE_TYPES47.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== AST_NODE_TYPES47.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === AST_NODE_TYPES47.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES47.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES47.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+  return test.type === AST_NODE_TYPES48.CallExpression && test.arguments.length === 1 && test.arguments[0] !== void 0 && test.arguments[0].type !== AST_NODE_TYPES48.SpreadElement && isSamePlainMember(test.arguments[0], access) && test.callee.type === AST_NODE_TYPES48.MemberExpression && !test.callee.computed && test.callee.object.type === AST_NODE_TYPES48.Identifier && test.callee.object.name === "Array" && test.callee.property.type === AST_NODE_TYPES48.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_TYPES47.BinaryExpression || current.type === AST_NODE_TYPES47.CallExpression || current.type === AST_NODE_TYPES47.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+      if ((current.type === AST_NODE_TYPES48.BinaryExpression || current.type === AST_NODE_TYPES48.CallExpression || current.type === AST_NODE_TYPES48.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
         return true;
       }
-      if (current.type !== AST_NODE_TYPES47.UnaryExpression && current.type !== AST_NODE_TYPES47.MemberExpression && current.type !== AST_NODE_TYPES47.CallExpression) {
+      if (current.type !== AST_NODE_TYPES48.UnaryExpression && current.type !== AST_NODE_TYPES48.MemberExpression && current.type !== AST_NODE_TYPES48.CallExpression) {
         return false;
       }
     }
@@ -11505,7 +11661,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   };
   const isGuardedUse = (identifier) => {
     for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
-      if (current.type === AST_NODE_TYPES47.ConditionalExpression) {
+      if (current.type === AST_NODE_TYPES48.ConditionalExpression) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -11514,7 +11670,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === AST_NODE_TYPES47.IfStatement) {
+      if (current.type === AST_NODE_TYPES48.IfStatement) {
         const polarity = bindingValidationPolarity(current.test, identifier.name);
         if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
           return true;
@@ -11523,14 +11679,14 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
           return true;
         }
       }
-      if (current.type === AST_NODE_TYPES47.FunctionDeclaration || current.type === AST_NODE_TYPES47.FunctionExpression || current.type === AST_NODE_TYPES47.ArrowFunctionExpression) {
+      if (current.type === AST_NODE_TYPES48.FunctionDeclaration || current.type === AST_NODE_TYPES48.FunctionExpression || current.type === AST_NODE_TYPES48.ArrowFunctionExpression) {
         return false;
       }
     }
     return false;
   };
   const declarator = member.parent;
-  if (declarator.type !== AST_NODE_TYPES47.VariableDeclarator || declarator.init !== member || declarator.id.type !== AST_NODE_TYPES47.Identifier || declarator.parent.type !== AST_NODE_TYPES47.VariableDeclaration || declarator.parent.kind !== "const") {
+  if (declarator.type !== AST_NODE_TYPES48.VariableDeclarator || declarator.init !== member || declarator.id.type !== AST_NODE_TYPES48.Identifier || declarator.parent.type !== AST_NODE_TYPES48.VariableDeclaration || declarator.parent.kind !== "const") {
     return false;
   }
   const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
@@ -11538,7 +11694,7 @@ var isFullyValidatedExtractedBinding = (member, source, context) => {
   let hasValueUse = false;
   for (const reference of extracted.references) {
     const identifier = reference.identifier;
-    if (identifier.type !== AST_NODE_TYPES47.Identifier) return false;
+    if (identifier.type !== AST_NODE_TYPES48.Identifier) return false;
     if (nodeWithin2(identifier, declarator)) continue;
     if (isValidationReference(identifier)) continue;
     hasValueUse = true;
@@ -11551,17 +11707,17 @@ var isGuardTestPosition = (node) => {
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case AST_NODE_TYPES47.UnaryExpression:
-      case AST_NODE_TYPES47.LogicalExpression:
-      case AST_NODE_TYPES47.ChainExpression:
+      case AST_NODE_TYPES48.UnaryExpression:
+      case AST_NODE_TYPES48.LogicalExpression:
+      case AST_NODE_TYPES48.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case AST_NODE_TYPES47.IfStatement:
-      case AST_NODE_TYPES47.ConditionalExpression:
-      case AST_NODE_TYPES47.WhileStatement:
-      case AST_NODE_TYPES47.DoWhileStatement:
-      case AST_NODE_TYPES47.ForStatement:
+      case AST_NODE_TYPES48.IfStatement:
+      case AST_NODE_TYPES48.ConditionalExpression:
+      case AST_NODE_TYPES48.WhileStatement:
+      case AST_NODE_TYPES48.DoWhileStatement:
+      case AST_NODE_TYPES48.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -11571,7 +11727,7 @@ var isGuardTestPosition = (node) => {
 };
 var unvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES47.Identifier) {
+  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES48.Identifier) {
     return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -11600,7 +11756,7 @@ var prefer_schema_for_api_payload_default = createRule({
     const localFileTextVariables = /* @__PURE__ */ new Set();
     const localFileTextRef = (node, scope) => {
       const unwrapped = unwrap4(node);
-      if (unwrapped?.type !== AST_NODE_TYPES47.Identifier) return null;
+      if (unwrapped?.type !== AST_NODE_TYPES48.Identifier) return null;
       const variable = findVariable2(scope, unwrapped.name);
       return variable !== null && localFileTextVariables.has(variable) ? variable : null;
     };
@@ -11669,7 +11825,7 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === AST_NODE_TYPES47.Identifier) {
+        if (node.id.type === AST_NODE_TYPES48.Identifier) {
           const variable = context.sourceCode.getDeclaredVariables(node)[0];
           if (variable !== void 0) {
             updateLocalFileText(variable, node.init, scope);
@@ -11677,7 +11833,7 @@ var prefer_schema_for_api_payload_default = createRule({
           trackInitializer(node, scope);
           return;
         }
-        if (node.id.type === AST_NODE_TYPES47.ObjectPattern || node.id.type === AST_NODE_TYPES47.ArrayPattern) {
+        if (node.id.type === AST_NODE_TYPES48.ObjectPattern || node.id.type === AST_NODE_TYPES48.ArrayPattern) {
           if (isRawPayloadSource(
             node.init,
             (candidate) => localFileTextRef(candidate, scope) !== null
@@ -11694,7 +11850,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === AST_NODE_TYPES47.Identifier) {
+        if (node.left.type === AST_NODE_TYPES48.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           const isLocalText = (candidate) => localFileTextRef(candidate, scope) !== null;
@@ -11708,7 +11864,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === AST_NODE_TYPES47.ObjectPattern || node.left.type === AST_NODE_TYPES47.ArrayPattern) {
+        if (node.left.type === AST_NODE_TYPES48.ObjectPattern || node.left.type === AST_NODE_TYPES48.ArrayPattern) {
           if (isRawPayloadSource(
             node.right,
             (candidate) => localFileTextRef(candidate, scope) !== null
@@ -11728,15 +11884,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== AST_NODE_TYPES47.Identifier) return;
+        if (node.callee.type !== AST_NODE_TYPES48.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_TYPES47.SpreadElement) continue;
+          if (arg.type === AST_NODE_TYPES48.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES47.Identifier) {
+          if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES48.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -11753,14 +11909,14 @@ var prefer_schema_for_api_payload_default = createRule({
           (candidate) => localFileTextRef(candidate, scope) !== null
         )) {
           const parent = node.parent;
-          if (parent.type === AST_NODE_TYPES47.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES47.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === AST_NODE_TYPES48.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES48.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_TYPES47.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
-        if (variable !== null && obj?.type === AST_NODE_TYPES47.Identifier) {
+        const variable = obj?.type === AST_NODE_TYPES48.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null && obj?.type === AST_NODE_TYPES48.Identifier) {
           if (isUseWithinValidatedBranch(node, obj.name)) {
             return;
           }
@@ -11780,7 +11936,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES48 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES49 } from "@typescript-eslint/utils";
 import { existsSync, readdirSync, readFileSync } from "fs";
 import { dirname, join, parse } from "path";
 
@@ -11892,7 +12048,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_TYPES48.JSXElement) {
+    if (current.type === AST_NODE_TYPES49.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -11902,8 +12058,8 @@ var isInsideSvg = (node) => {
 };
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === AST_NODE_TYPES48.JSXIdentifier) return name.name;
-  if (name.type === AST_NODE_TYPES48.JSXMemberExpression && name.property.type === AST_NODE_TYPES48.JSXIdentifier) {
+  if (name.type === AST_NODE_TYPES49.JSXIdentifier) return name.name;
+  if (name.type === AST_NODE_TYPES49.JSXMemberExpression && name.property.type === AST_NODE_TYPES49.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -11929,7 +12085,7 @@ function isSvgLikeElementName(name) {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === AST_NODE_TYPES48.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES48.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES48.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES48.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === AST_NODE_TYPES49.Property && propName(current.key) === "path" && current.parent.type === AST_NODE_TYPES49.ObjectExpression && current.parent.parent.type === AST_NODE_TYPES49.CallExpression && current.parent.parent.callee.type === AST_NODE_TYPES49.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -12063,12 +12219,12 @@ var expandWorkspaceGlob = (root, glob) => {
   return readdirSync(parent, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => join(parent, entry.name));
 };
 var propName = (key) => {
-  if (key.type === AST_NODE_TYPES48.Identifier) return key.name;
-  if (key.type === AST_NODE_TYPES48.Literal && typeof key.value === "string") return key.value;
+  if (key.type === AST_NODE_TYPES49.Identifier) return key.name;
+  if (key.type === AST_NODE_TYPES49.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== AST_NODE_TYPES48.ImportDeclaration && statement.type !== AST_NODE_TYPES48.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES48.ExportAllDeclaration) {
+  if (statement.type !== AST_NODE_TYPES49.ImportDeclaration && statement.type !== AST_NODE_TYPES49.ExportNamedDeclaration && statement.type !== AST_NODE_TYPES49.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -12121,27 +12277,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case AST_NODE_TYPES48.Literal:
+        case AST_NODE_TYPES49.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case AST_NODE_TYPES48.TemplateLiteral:
+        case AST_NODE_TYPES49.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case AST_NODE_TYPES48.ArrayExpression:
+        case AST_NODE_TYPES49.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== AST_NODE_TYPES48.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== AST_NODE_TYPES49.SpreadElement) checkClassNode(element);
           }
           break;
-        case AST_NODE_TYPES48.ObjectExpression:
+        case AST_NODE_TYPES49.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === AST_NODE_TYPES48.Property) checkClassNode(property.value);
+            if (property.type === AST_NODE_TYPES49.Property) checkClassNode(property.value);
           }
           break;
-        case AST_NODE_TYPES48.ConditionalExpression:
+        case AST_NODE_TYPES49.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case AST_NODE_TYPES48.LogicalExpression:
+        case AST_NODE_TYPES49.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -12149,32 +12305,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === AST_NODE_TYPES48.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === AST_NODE_TYPES49.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         report(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === AST_NODE_TYPES48.Literal) checkClassNode(node.value);
-        else if (node.value.type === AST_NODE_TYPES48.JSXExpressionContainer) {
-          if (node.value.expression.type !== AST_NODE_TYPES48.JSXEmptyExpression) {
+        if (node.value.type === AST_NODE_TYPES49.Literal) checkClassNode(node.value);
+        else if (node.value.type === AST_NODE_TYPES49.JSXExpressionContainer) {
+          if (node.value.expression.type !== AST_NODE_TYPES49.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === AST_NODE_TYPES48.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES48.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === AST_NODE_TYPES49.Identifier && node.callee.name === "require" && node.arguments[0]?.type === AST_NODE_TYPES49.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === AST_NODE_TYPES48.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === AST_NODE_TYPES49.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== AST_NODE_TYPES48.SpreadElement) checkClassNode(arg);
+            if (arg.type !== AST_NODE_TYPES49.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === AST_NODE_TYPES48.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === AST_NODE_TYPES49.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -12184,9 +12340,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_TYPES48.Literal) return;
+        if (node.value?.type !== AST_NODE_TYPES49.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === AST_NODE_TYPES48.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === AST_NODE_TYPES49.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -12200,7 +12356,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_TYPES48.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === AST_NODE_TYPES49.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -12402,7 +12558,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES49 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES50 } from "@typescript-eslint/utils";
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var SYNTHETIC_LITERAL_MATCHERS = /* @__PURE__ */ new Map([
   ["toBeNull", "null"],
@@ -12427,11 +12583,11 @@ var preferWholeObjectAssertionDocumentation = {
 };
 function literalText(node, getText) {
   switch (node.type) {
-    case AST_NODE_TYPES49.Literal:
+    case AST_NODE_TYPES50.Literal:
       return "regex" in node ? null : getText(node);
-    case AST_NODE_TYPES49.TemplateLiteral:
+    case AST_NODE_TYPES50.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case AST_NODE_TYPES49.UnaryExpression:
+    case AST_NODE_TYPES50.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -12439,15 +12595,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case AST_NODE_TYPES49.Identifier:
-    case AST_NODE_TYPES49.ThisExpression:
+    case AST_NODE_TYPES50.Identifier:
+    case AST_NODE_TYPES50.ThisExpression:
       return true;
-    case AST_NODE_TYPES49.MemberExpression:
+    case AST_NODE_TYPES50.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === AST_NODE_TYPES49.Literal && isPureReceiver(node.object);
+        return node.property.type === AST_NODE_TYPES50.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -12455,11 +12611,21 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== AST_NODE_TYPES49.Literal || typeof node.value !== "number") {
+  if (node.type !== AST_NODE_TYPES50.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
 }
+function propertyAccess(node) {
+  const path = [];
+  let current = node;
+  while (current.type === AST_NODE_TYPES50.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== AST_NODE_TYPES50.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+    path.unshift(current.property.name);
+    current = current.object;
+  }
+  return path.length > 0 && isPureReceiver(current) ? { receiver: current, path } : null;
+}
 var prefer_whole_object_assertion_default = createRule({
   name: "prefer-whole-object-assertion",
   documentation: preferWholeObjectAssertionDocumentation,
@@ -12482,57 +12648,59 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== AST_NODE_TYPES49.ExpressionStatement) {
+      if (statement.type !== AST_NODE_TYPES50.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== AST_NODE_TYPES49.CallExpression) {
+      if (call.type !== AST_NODE_TYPES50.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== AST_NODE_TYPES49.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES49.Identifier) {
+      if (callee.type !== AST_NODE_TYPES50.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES50.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== AST_NODE_TYPES49.CallExpression || expectCall.callee.type !== AST_NODE_TYPES49.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== AST_NODE_TYPES50.CallExpression || expectCall.callee.type !== AST_NODE_TYPES50.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== AST_NODE_TYPES49.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== AST_NODE_TYPES50.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
         return null;
       }
       let key;
+      let receiver;
       if (actual.computed) {
         const index = literalIndex(actual.property);
         if (index === null) {
           return null;
         }
         key = { kind: "index", index };
+        receiver = actual.object;
       } else {
-        if (actual.property.type !== AST_NODE_TYPES49.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
-          return null;
-        }
-        key = { kind: "property", name: actual.property.name };
+        const access = propertyAccess(actual);
+        if (access === null) return null;
+        key = { kind: "property", path: access.path };
+        receiver = access.receiver;
       }
       const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
       if (synthetic !== void 0 && call.arguments.length === 0) {
-        return { statement, receiver: actual.object, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
+        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
       }
       if (!MERGEABLE_MATCHERS.has(matcher)) {
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES49.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === AST_NODE_TYPES50.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
       return {
         statement,
-        receiver: actual.object,
+        receiver,
         key,
         matcher,
         expectedText: literal ?? sourceCode.getText(expected),
@@ -12545,7 +12713,8 @@ var prefer_whole_object_assertion_default = createRule({
       );
     }
     function reportPropertyRun(run) {
-      const names = /* @__PURE__ */ new Set();
+      const tree = /* @__PURE__ */ new Map();
+      const paths = [];
       for (const assertion of run) {
         if (assertion.key.kind !== "property" || !assertion.expectedIsLiteral) {
           return;
@@ -12553,19 +12722,44 @@ var prefer_whole_object_assertion_default = createRule({
         if (!MERGEABLE_MATCHERS.has(assertion.matcher) && !SYNTHETIC_LITERAL_MATCHERS.has(assertion.matcher)) {
           return;
         }
-        if (names.has(assertion.key.name)) {
-          return;
+        paths.push([...assertion.key.path]);
+      }
+      const commonPrefix = [];
+      for (let index = 0; ; index += 1) {
+        const candidate = paths[0]?.[index];
+        if (candidate === void 0 || paths.some((path) => path[index] !== candidate || path.length === index + 1)) {
+          break;
+        }
+        commonPrefix.push(candidate);
+      }
+      for (const [assertionIndex, assertion] of run.entries()) {
+        if (assertion.key.kind !== "property") return;
+        let branch = tree;
+        const relativePath = paths[assertionIndex]?.slice(commonPrefix.length) ?? [];
+        for (const [index, name] of relativePath.entries()) {
+          const leaf = index === relativePath.length - 1;
+          const existing = branch.get(name);
+          if (leaf) {
+            if (existing !== void 0) return;
+            branch.set(name, assertion.expectedText);
+          } else if (existing === void 0) {
+            const nested = /* @__PURE__ */ new Map();
+            branch.set(name, nested);
+            branch = nested;
+          } else if (existing instanceof Map) {
+            branch = existing;
+          } else {
+            return;
+          }
         }
-        names.add(assertion.key.name);
       }
       const first = run[0];
       if (first === void 0) {
         return;
       }
-      const receiverText = sourceCode.getText(first.receiver);
-      const properties = run.map(
-        (assertion) => assertion.key.kind === "property" ? `${assertion.key.name}: ${assertion.expectedText}` : ""
-      ).join(", ");
+      const receiverText = `${sourceCode.getText(first.receiver)}${commonPrefix.map((name) => `.${name}`).join("")}`;
+      const renderTree = (value) => [...value.entries()].map(([name, child]) => `${name}: ${child instanceof Map ? `{ ${renderTree(child)} }` : child}`).join(", ");
+      const properties = renderTree(tree);
       context.report({
         node: first.statement,
         messageId: "combineAssertions",
@@ -12641,7 +12835,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50, ASTUtils as ASTUtils14 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES51, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
 var repeatedStaticCallCasesDocumentation = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -12662,67 +12856,67 @@ var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
 function staticMemberName5(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES50.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES50.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === AST_NODE_TYPES51.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES51.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function importedName3(identifier, context, modules) {
-  const variable = ASTUtils14.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = ASTUtils15.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_TYPES50.ImportSpecifier) continue;
+    if (definition.node.type !== AST_NODE_TYPES51.ImportSpecifier) continue;
     const declaration = definition.node.parent;
-    if (declaration.type !== AST_NODE_TYPES50.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
+    if (declaration.type !== AST_NODE_TYPES51.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     const imported = definition.node.imported;
-    return imported.type === AST_NODE_TYPES50.Identifier ? imported.name : String(imported.value);
+    return imported.type === AST_NODE_TYPES51.Identifier ? imported.name : String(imported.value);
   }
   return null;
 }
 function isDirectTestCallback2(node, context) {
-  if (node.type !== AST_NODE_TYPES50.ArrowFunctionExpression && node.type !== AST_NODE_TYPES50.FunctionExpression) return false;
+  if (node.type !== AST_NODE_TYPES51.ArrowFunctionExpression && node.type !== AST_NODE_TYPES51.FunctionExpression) return false;
   const call = node.parent;
-  if (call?.type !== AST_NODE_TYPES50.CallExpression || !call.arguments.includes(node)) return false;
+  if (call?.type !== AST_NODE_TYPES51.CallExpression || !call.arguments.includes(node)) return false;
   const root = testRoot2(call.callee);
   return root !== null && TEST_NAMES2.has(importedName3(root, context, TEST_MODULES4) ?? "");
 }
 function testRoot2(callee) {
-  if (callee.type === AST_NODE_TYPES50.Identifier) return callee;
-  if (callee.type !== AST_NODE_TYPES50.MemberExpression) return null;
+  if (callee.type === AST_NODE_TYPES51.Identifier) return callee;
+  if (callee.type !== AST_NODE_TYPES51.MemberExpression) return null;
   const modifier = staticMemberName5(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
-  if (node.type === AST_NODE_TYPES50.TSAsExpression || node.type === AST_NODE_TYPES50.TSTypeAssertion || node.type === AST_NODE_TYPES50.TSSatisfiesExpression || node.type === AST_NODE_TYPES50.TSNonNullExpression) return isStatic(node.expression);
+  if (node.type === AST_NODE_TYPES51.TSAsExpression || node.type === AST_NODE_TYPES51.TSTypeAssertion || node.type === AST_NODE_TYPES51.TSSatisfiesExpression || node.type === AST_NODE_TYPES51.TSNonNullExpression) return isStatic(node.expression);
   switch (node.type) {
-    case AST_NODE_TYPES50.Literal:
+    case AST_NODE_TYPES51.Literal:
       return true;
-    case AST_NODE_TYPES50.TemplateLiteral:
+    case AST_NODE_TYPES51.TemplateLiteral:
       return node.expressions.length === 0;
-    case AST_NODE_TYPES50.UnaryExpression:
+    case AST_NODE_TYPES51.UnaryExpression:
       return (node.operator === "+" || node.operator === "-") && isStatic(node.argument);
-    case AST_NODE_TYPES50.ArrayExpression:
-      return node.elements.every((item) => item !== null && item.type !== AST_NODE_TYPES50.SpreadElement && isStatic(item));
-    case AST_NODE_TYPES50.ObjectExpression:
-      return node.properties.every((property) => property.type === AST_NODE_TYPES50.Property && !property.computed && property.kind === "init" && property.value.type !== AST_NODE_TYPES50.AssignmentPattern && isStatic(property.value));
+    case AST_NODE_TYPES51.ArrayExpression:
+      return node.elements.every((item) => item !== null && item.type !== AST_NODE_TYPES51.SpreadElement && isStatic(item));
+    case AST_NODE_TYPES51.ObjectExpression:
+      return node.properties.every((property) => property.type === AST_NODE_TYPES51.Property && !property.computed && property.kind === "init" && property.value.type !== AST_NODE_TYPES51.AssignmentPattern && isStatic(property.value));
     default:
       return false;
   }
 }
 function staticShape(node) {
-  if (node.type === AST_NODE_TYPES50.TSAsExpression || node.type === AST_NODE_TYPES50.TSTypeAssertion || node.type === AST_NODE_TYPES50.TSSatisfiesExpression || node.type === AST_NODE_TYPES50.TSNonNullExpression) return staticShape(node.expression);
+  if (node.type === AST_NODE_TYPES51.TSAsExpression || node.type === AST_NODE_TYPES51.TSTypeAssertion || node.type === AST_NODE_TYPES51.TSSatisfiesExpression || node.type === AST_NODE_TYPES51.TSNonNullExpression) return staticShape(node.expression);
   switch (node.type) {
-    case AST_NODE_TYPES50.Literal:
+    case AST_NODE_TYPES51.Literal:
       return `literal:${typeof node.value}`;
-    case AST_NODE_TYPES50.TemplateLiteral:
+    case AST_NODE_TYPES51.TemplateLiteral:
       return "template";
-    case AST_NODE_TYPES50.UnaryExpression:
+    case AST_NODE_TYPES51.UnaryExpression:
       return `unary:${node.operator}:${staticShape(node.argument)}`;
-    case AST_NODE_TYPES50.ArrayExpression:
-      return `array(${node.elements.map((item) => item === null || item.type === AST_NODE_TYPES50.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
-    case AST_NODE_TYPES50.ObjectExpression:
+    case AST_NODE_TYPES51.ArrayExpression:
+      return `array(${node.elements.map((item) => item === null || item.type === AST_NODE_TYPES51.SpreadElement ? "invalid" : staticShape(item)).join(",")})`;
+    case AST_NODE_TYPES51.ObjectExpression:
       return `object(${node.properties.map((property) => {
-        if (property.type !== AST_NODE_TYPES50.Property || property.computed || property.value.type === AST_NODE_TYPES50.AssignmentPattern) return "invalid";
-        const key = property.key.type === AST_NODE_TYPES50.Identifier ? property.key.name : String(property.key.value);
+        if (property.type !== AST_NODE_TYPES51.Property || property.computed || property.value.type === AST_NODE_TYPES51.AssignmentPattern) return "invalid";
+        const key = property.key.type === AST_NODE_TYPES51.Identifier ? property.key.name : String(property.key.value);
         return `${key}:${staticShape(property.value)}`;
       }).join(",")})`;
     default:
@@ -12730,16 +12924,16 @@ function staticShape(node) {
   }
 }
 function assertionShape(statement, context) {
-  if (statement.type !== AST_NODE_TYPES50.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES50.CallExpression) return null;
+  if (statement.type !== AST_NODE_TYPES51.ExpressionStatement || statement.expression.type !== AST_NODE_TYPES51.CallExpression) return null;
   const matcherCall = statement.expression;
-  if (matcherCall.callee.type !== AST_NODE_TYPES50.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== AST_NODE_TYPES50.Identifier || matcherCall.arguments.length !== 1) return null;
+  if (matcherCall.callee.type !== AST_NODE_TYPES51.MemberExpression || matcherCall.callee.computed || matcherCall.callee.property.type !== AST_NODE_TYPES51.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_TYPES50.Identifier || importedName3(chain.call.callee, context, ASSERTION_MODULES3) !== "expect" || chain.call.arguments.length !== 1) return null;
+  if (chain === null || chain.call.callee.type !== AST_NODE_TYPES51.Identifier || importedName3(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_TYPES50.CallExpression || observed.callee.type !== AST_NODE_TYPES50.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === AST_NODE_TYPES50.SpreadElement || !isStatic(arg)) || expected?.type === AST_NODE_TYPES50.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
+  if (observed?.type !== AST_NODE_TYPES51.CallExpression || observed.callee.type !== AST_NODE_TYPES51.Identifier || observed.arguments.length === 0 || observed.arguments.some((arg) => arg.type === AST_NODE_TYPES51.SpreadElement || !isStatic(arg)) || expected?.type === AST_NODE_TYPES51.SpreadElement || expected === void 0 || !isStatic(expected)) return null;
   const skeleton = `${observed.callee.name}/${observed.arguments.map((item) => staticShape(item)).join(",")}/${chain.modifiers.join(".")}/${matcher}/${staticShape(expected)}`;
   const values = [...observed.arguments, expected].map((item) => context.sourceCode.getText(item)).join("\0");
   return { statement, skeleton, values };
@@ -12747,13 +12941,13 @@ function assertionShape(statement, context) {
 function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
-  while (receiver.type === AST_NODE_TYPES50.MemberExpression) {
+  while (receiver.type === AST_NODE_TYPES51.MemberExpression) {
     const modifier = staticMemberName5(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
   }
-  return receiver.type === AST_NODE_TYPES50.CallExpression ? { call: receiver, modifiers } : null;
+  return receiver.type === AST_NODE_TYPES51.CallExpression ? { call: receiver, modifiers } : null;
 }
 var repeated_static_call_cases_default = createRule({
   name: "repeated-static-call-cases",
@@ -12773,7 +12967,7 @@ var repeated_static_call_cases_default = createRule({
     return {
       "CallExpression > ArrowFunctionExpression, CallExpression > FunctionExpression"(node) {
         const call = node.parent;
-        if (call?.type === AST_NODE_TYPES50.CallExpression) {
+        if (call?.type === AST_NODE_TYPES51.CallExpression) {
           const duplicate = duplicateTestBodyCandidate(call, sourceCode);
           if (duplicate !== null && duplicate.body === node) {
             const groups = duplicateGroups.get(duplicate.container) ?? /* @__PURE__ */ new Map();
@@ -12783,7 +12977,7 @@ var repeated_static_call_cases_default = createRule({
             duplicateGroups.set(duplicate.container, groups);
           }
         }
-        if (!isDirectTestCallback2(node, context) || node.body.type !== AST_NODE_TYPES50.BlockStatement) return;
+        if (!isDirectTestCallback2(node, context) || node.body.type !== AST_NODE_TYPES51.BlockStatement) return;
         let run = [];
         const flush = () => {
           if (run.length >= MIN_CASES2 && new Set(run.map((item) => item.values)).size > 1) {
@@ -12824,7 +13018,7 @@ var repeated_static_call_cases_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES51 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES52 } from "@typescript-eslint/utils";
 var preferZodInferDocumentation = {
   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.",
@@ -12877,47 +13071,47 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [AST_NODE_TYPES51.TSStringKeyword],
-  email: [AST_NODE_TYPES51.TSStringKeyword],
-  url: [AST_NODE_TYPES51.TSStringKeyword],
-  uuid: [AST_NODE_TYPES51.TSStringKeyword],
-  ulid: [AST_NODE_TYPES51.TSStringKeyword],
-  cuid: [AST_NODE_TYPES51.TSStringKeyword],
-  cuid2: [AST_NODE_TYPES51.TSStringKeyword],
-  nanoid: [AST_NODE_TYPES51.TSStringKeyword],
-  iso: [AST_NODE_TYPES51.TSStringKeyword],
-  number: [AST_NODE_TYPES51.TSNumberKeyword],
-  int: [AST_NODE_TYPES51.TSNumberKeyword],
-  float32: [AST_NODE_TYPES51.TSNumberKeyword],
-  float64: [AST_NODE_TYPES51.TSNumberKeyword],
-  boolean: [AST_NODE_TYPES51.TSBooleanKeyword],
-  bigint: [AST_NODE_TYPES51.TSBigIntKeyword],
-  symbol: [AST_NODE_TYPES51.TSSymbolKeyword],
-  any: [AST_NODE_TYPES51.TSAnyKeyword],
-  unknown: [AST_NODE_TYPES51.TSUnknownKeyword],
-  never: [AST_NODE_TYPES51.TSNeverKeyword],
-  void: [AST_NODE_TYPES51.TSVoidKeyword],
-  null: [AST_NODE_TYPES51.TSNullKeyword],
-  undefined: [AST_NODE_TYPES51.TSUndefinedKeyword],
-  literal: [AST_NODE_TYPES51.TSLiteralType],
-  date: [AST_NODE_TYPES51.TSTypeReference],
-  array: [AST_NODE_TYPES51.TSArrayType, AST_NODE_TYPES51.TSTypeReference],
-  tuple: [AST_NODE_TYPES51.TSTupleType],
-  object: [AST_NODE_TYPES51.TSTypeLiteral, AST_NODE_TYPES51.TSTypeReference],
-  strictObject: [AST_NODE_TYPES51.TSTypeLiteral, AST_NODE_TYPES51.TSTypeReference],
-  looseObject: [AST_NODE_TYPES51.TSTypeLiteral, AST_NODE_TYPES51.TSTypeReference],
-  record: [AST_NODE_TYPES51.TSTypeReference, AST_NODE_TYPES51.TSTypeLiteral],
-  map: [AST_NODE_TYPES51.TSTypeReference],
-  set: [AST_NODE_TYPES51.TSTypeReference],
-  promise: [AST_NODE_TYPES51.TSTypeReference],
-  enum: [AST_NODE_TYPES51.TSUnionType, AST_NODE_TYPES51.TSTypeReference, AST_NODE_TYPES51.TSLiteralType],
-  nativeEnum: [AST_NODE_TYPES51.TSUnionType, AST_NODE_TYPES51.TSTypeReference, AST_NODE_TYPES51.TSLiteralType],
-  union: [AST_NODE_TYPES51.TSUnionType, AST_NODE_TYPES51.TSTypeReference],
-  discriminatedUnion: [AST_NODE_TYPES51.TSUnionType, AST_NODE_TYPES51.TSTypeReference],
-  intersection: [AST_NODE_TYPES51.TSIntersectionType, AST_NODE_TYPES51.TSTypeReference]
+  string: [AST_NODE_TYPES52.TSStringKeyword],
+  email: [AST_NODE_TYPES52.TSStringKeyword],
+  url: [AST_NODE_TYPES52.TSStringKeyword],
+  uuid: [AST_NODE_TYPES52.TSStringKeyword],
+  ulid: [AST_NODE_TYPES52.TSStringKeyword],
+  cuid: [AST_NODE_TYPES52.TSStringKeyword],
+  cuid2: [AST_NODE_TYPES52.TSStringKeyword],
+  nanoid: [AST_NODE_TYPES52.TSStringKeyword],
+  iso: [AST_NODE_TYPES52.TSStringKeyword],
+  number: [AST_NODE_TYPES52.TSNumberKeyword],
+  int: [AST_NODE_TYPES52.TSNumberKeyword],
+  float32: [AST_NODE_TYPES52.TSNumberKeyword],
+  float64: [AST_NODE_TYPES52.TSNumberKeyword],
+  boolean: [AST_NODE_TYPES52.TSBooleanKeyword],
+  bigint: [AST_NODE_TYPES52.TSBigIntKeyword],
+  symbol: [AST_NODE_TYPES52.TSSymbolKeyword],
+  any: [AST_NODE_TYPES52.TSAnyKeyword],
+  unknown: [AST_NODE_TYPES52.TSUnknownKeyword],
+  never: [AST_NODE_TYPES52.TSNeverKeyword],
+  void: [AST_NODE_TYPES52.TSVoidKeyword],
+  null: [AST_NODE_TYPES52.TSNullKeyword],
+  undefined: [AST_NODE_TYPES52.TSUndefinedKeyword],
+  literal: [AST_NODE_TYPES52.TSLiteralType],
+  date: [AST_NODE_TYPES52.TSTypeReference],
+  array: [AST_NODE_TYPES52.TSArrayType, AST_NODE_TYPES52.TSTypeReference],
+  tuple: [AST_NODE_TYPES52.TSTupleType],
+  object: [AST_NODE_TYPES52.TSTypeLiteral, AST_NODE_TYPES52.TSTypeReference],
+  strictObject: [AST_NODE_TYPES52.TSTypeLiteral, AST_NODE_TYPES52.TSTypeReference],
+  looseObject: [AST_NODE_TYPES52.TSTypeLiteral, AST_NODE_TYPES52.TSTypeReference],
+  record: [AST_NODE_TYPES52.TSTypeReference, AST_NODE_TYPES52.TSTypeLiteral],
+  map: [AST_NODE_TYPES52.TSTypeReference],
+  set: [AST_NODE_TYPES52.TSTypeReference],
+  promise: [AST_NODE_TYPES52.TSTypeReference],
+  enum: [AST_NODE_TYPES52.TSUnionType, AST_NODE_TYPES52.TSTypeReference, AST_NODE_TYPES52.TSLiteralType],
+  nativeEnum: [AST_NODE_TYPES52.TSUnionType, AST_NODE_TYPES52.TSTypeReference, AST_NODE_TYPES52.TSLiteralType],
+  union: [AST_NODE_TYPES52.TSUnionType, AST_NODE_TYPES52.TSTypeReference],
+  discriminatedUnion: [AST_NODE_TYPES52.TSUnionType, AST_NODE_TYPES52.TSTypeReference],
+  intersection: [AST_NODE_TYPES52.TSIntersectionType, AST_NODE_TYPES52.TSTypeReference]
 };
 function primitiveLiteralKey(node) {
-  if (node.type !== AST_NODE_TYPES51.Literal) {
+  if (node.type !== AST_NODE_TYPES52.Literal) {
     return null;
   }
   if (node.value === null) {
@@ -12949,13 +13143,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "literal") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === AST_NODE_TYPES51.SpreadElement) {
+    if (argument === void 0 || argument.type === AST_NODE_TYPES52.SpreadElement) {
       return null;
     }
-    if (argument.type === AST_NODE_TYPES51.ArrayExpression) {
+    if (argument.type === AST_NODE_TYPES52.ArrayExpression) {
       return exactDomain(
         argument.elements.map(
-          (element) => element === null || element.type === AST_NODE_TYPES51.SpreadElement ? null : primitiveLiteralKey(element)
+          (element) => element === null || element.type === AST_NODE_TYPES52.SpreadElement ? null : primitiveLiteralKey(element)
         )
       );
     }
@@ -12963,13 +13157,13 @@ function staticZodDomain(leaf, call) {
   }
   if (leaf === "enum") {
     const [argument] = call.arguments;
-    if (argument === void 0 || argument.type === AST_NODE_TYPES51.SpreadElement) {
+    if (argument === void 0 || argument.type === AST_NODE_TYPES52.SpreadElement) {
       return null;
     }
-    if (argument.type === AST_NODE_TYPES51.ArrayExpression) {
+    if (argument.type === AST_NODE_TYPES52.ArrayExpression) {
       return exactDomain(
         argument.elements.map((element) => {
-          if (element === null || element.type === AST_NODE_TYPES51.SpreadElement) {
+          if (element === null || element.type === AST_NODE_TYPES52.SpreadElement) {
             return null;
           }
           const key = primitiveLiteralKey(element);
@@ -12977,10 +13171,10 @@ function staticZodDomain(leaf, call) {
         })
       );
     }
-    if (argument.type === AST_NODE_TYPES51.ObjectExpression) {
+    if (argument.type === AST_NODE_TYPES52.ObjectExpression) {
       return exactDomain(
         argument.properties.map((property) => {
-          if (property.type !== AST_NODE_TYPES51.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
+          if (property.type !== AST_NODE_TYPES52.Property || property.computed || property.kind !== "init" || property.method || property.shorthand) {
             return null;
           }
           const key = primitiveLiteralKey(property.value);
@@ -13007,15 +13201,15 @@ function sameDomain(left, right) {
   return true;
 }
 function isExportedDeclaration(node) {
-  return node.parent?.type === AST_NODE_TYPES51.ExportNamedDeclaration;
+  return node.parent?.type === AST_NODE_TYPES52.ExportNamedDeclaration;
 }
 function isModuleLevelConst(node) {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES51.VariableDeclaration || declaration.kind !== "const") {
+  if (declaration.type !== AST_NODE_TYPES52.VariableDeclaration || declaration.kind !== "const") {
     return false;
   }
   const container = declaration.parent;
-  return container.type === AST_NODE_TYPES51.Program || container.type === AST_NODE_TYPES51.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES51.Program;
+  return container.type === AST_NODE_TYPES52.Program || container.type === AST_NODE_TYPES52.ExportNamedDeclaration && container.parent.type === AST_NODE_TYPES52.Program;
 }
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -13024,20 +13218,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== AST_NODE_TYPES51.TSUnionType) {
+  if (annotation.type !== AST_NODE_TYPES52.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === AST_NODE_TYPES51.TSNullKeyword
+      nullable: annotation.type === AST_NODE_TYPES52.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === AST_NODE_TYPES51.TSNullKeyword) {
+    if (member.type === AST_NODE_TYPES52.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === AST_NODE_TYPES51.TSUndefinedKeyword) {
+    if (member.type === AST_NODE_TYPES52.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -13071,18 +13265,18 @@ function leafAgrees(field, annotation) {
     return null;
   }
   if (leaf === "date") {
-    return core.type === AST_NODE_TYPES51.TSTypeReference && core.typeName.type === AST_NODE_TYPES51.Identifier && core.typeName.name === "Date";
+    return core.type === AST_NODE_TYPES52.TSTypeReference && core.typeName.type === AST_NODE_TYPES52.Identifier && core.typeName.name === "Date";
   }
   return expected.includes(core.type);
 }
 function typeLiteralDomain(annotation) {
-  const members = annotation.type === AST_NODE_TYPES51.TSUnionType ? annotation.types : [annotation];
+  const members = annotation.type === AST_NODE_TYPES52.TSUnionType ? annotation.types : [annotation];
   const keys = [];
   for (const member of members) {
-    if (member.type === AST_NODE_TYPES51.TSNullKeyword) {
+    if (member.type === AST_NODE_TYPES52.TSNullKeyword) {
       continue;
     }
-    if (member.type !== AST_NODE_TYPES51.TSLiteralType) {
+    if (member.type !== AST_NODE_TYPES52.TSLiteralType) {
       return null;
     }
     keys.push(primitiveLiteralKey(member.literal));
@@ -13090,11 +13284,11 @@ function typeLiteralDomain(annotation) {
   return exactDomain(keys);
 }
 function staticStringUnionDomain(node) {
-  if (node.type !== AST_NODE_TYPES51.TSUnionType) {
+  if (node.type !== AST_NODE_TYPES52.TSUnionType) {
     return null;
   }
   const keys = node.types.map((member) => {
-    if (member.type !== AST_NODE_TYPES51.TSLiteralType) {
+    if (member.type !== AST_NODE_TYPES52.TSLiteralType) {
       return null;
     }
     const key = primitiveLiteralKey(member.literal);
@@ -13162,14 +13356,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === AST_NODE_TYPES51.CallExpression) {
+      while (current.type === AST_NODE_TYPES52.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES51.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES51.Identifier) {
+        if (callee.type !== AST_NODE_TYPES52.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES52.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES51.Identifier) {
+        if (receiver.type === AST_NODE_TYPES52.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -13178,14 +13372,14 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName2(call) {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES51.MemberExpression && callee.property.type === AST_NODE_TYPES51.Identifier ? callee.property.name : "";
+      return callee.type === AST_NODE_TYPES52.MemberExpression && callee.property.type === AST_NODE_TYPES52.Identifier ? callee.property.name : "";
     }
     function recordZodImport(node) {
       if (!isZodModule(node.source.value)) {
         return;
       }
       for (const specifier of node.specifiers) {
-        if (specifier.type === AST_NODE_TYPES51.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES51.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES51.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES51.Identifier && specifier.imported.name === "z") {
+        if (specifier.type === AST_NODE_TYPES52.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES52.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES52.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES52.Identifier && specifier.imported.name === "z") {
           zodNamespaces.add(specifier.local.name);
         }
       }
@@ -13195,13 +13389,13 @@ var prefer_zod_infer_default = createRule({
       let current = node;
       let leaf = null;
       let leafCall = null;
-      while (current.type === AST_NODE_TYPES51.CallExpression) {
+      while (current.type === AST_NODE_TYPES52.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== AST_NODE_TYPES51.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES51.Identifier) {
+        if (callee.type !== AST_NODE_TYPES52.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES52.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === AST_NODE_TYPES51.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === AST_NODE_TYPES52.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           leafCall = current;
           break;
@@ -13232,20 +13426,20 @@ var prefer_zod_infer_default = createRule({
       return domain instanceof Set && domain.size >= 2 ? domain : null;
     }
     function inferredSchemaName(node) {
-      if (node.type !== AST_NODE_TYPES51.TSTypeReference || node.typeName.type !== AST_NODE_TYPES51.TSQualifiedName || node.typeName.left.type !== AST_NODE_TYPES51.Identifier || !zodNamespaces.has(node.typeName.left.name) || node.typeName.right.name !== "infer") {
+      if (node.type !== AST_NODE_TYPES52.TSTypeReference || node.typeName.type !== AST_NODE_TYPES52.TSQualifiedName || node.typeName.left.type !== AST_NODE_TYPES52.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_TYPES51.TSTypeQuery && argument.exprName.type === AST_NODE_TYPES51.Identifier ? argument.exprName.name : null;
+      return arguments_.length === 1 && argument?.type === AST_NODE_TYPES52.TSTypeQuery && argument.exprName.type === AST_NODE_TYPES52.Identifier ? argument.exprName.name : null;
     }
     function recordLiteralUnions(members, owner, ownerName, exported) {
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES51.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
+        if (member.type !== AST_NODE_TYPES52.TSPropertySignature || member.computed || member.optional || member.readonly || member.typeAnnotation === void 0) {
           continue;
         }
         const key = member.key;
-        const propertyName3 = key.type === AST_NODE_TYPES51.Identifier ? key.name : key.type === AST_NODE_TYPES51.Literal && typeof key.value === "string" ? key.value : null;
+        const propertyName3 = key.type === AST_NODE_TYPES52.Identifier ? key.name : key.type === AST_NODE_TYPES52.Literal && typeof key.value === "string" ? key.value : null;
         if (propertyName3 === null) {
           continue;
         }
@@ -13255,7 +13449,7 @@ var prefer_zod_infer_default = createRule({
         }
         const annotation = member.typeAnnotation.typeAnnotation;
         const domain = staticStringUnionDomain(annotation);
-        if (domain === null || annotation.type !== AST_NODE_TYPES51.TSUnionType) {
+        if (domain === null || annotation.type !== AST_NODE_TYPES52.TSUnionType) {
           continue;
         }
         literalUnionOccurrences.push({
@@ -13286,16 +13480,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== AST_NODE_TYPES51.ObjectExpression) {
+      if (shape === void 0 || shape.type !== AST_NODE_TYPES52.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== AST_NODE_TYPES51.Property || property.computed) {
+        if (property.type !== AST_NODE_TYPES52.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === AST_NODE_TYPES51.Identifier ? key.name : key.type === AST_NODE_TYPES51.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === AST_NODE_TYPES52.Identifier ? key.name : key.type === AST_NODE_TYPES52.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -13306,11 +13500,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== AST_NODE_TYPES51.TSPropertySignature || member.computed) {
+        if (member.type !== AST_NODE_TYPES52.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === AST_NODE_TYPES51.Identifier ? key.name : key.type === AST_NODE_TYPES51.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === AST_NODE_TYPES52.Identifier ? key.name : key.type === AST_NODE_TYPES52.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -13325,8 +13519,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === AST_NODE_TYPES51.TSTypeReference) {
-        if (node.typeName.type === AST_NODE_TYPES51.Identifier) {
+      if (node.type === AST_NODE_TYPES52.TSTypeReference) {
+        if (node.typeName.type === AST_NODE_TYPES52.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -13334,11 +13528,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === AST_NODE_TYPES51.TSArrayType) {
+      if (node.type === AST_NODE_TYPES52.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === AST_NODE_TYPES51.TSUnionType || node.type === AST_NODE_TYPES51.TSIntersectionType) {
+      if (node.type === AST_NODE_TYPES52.TSUnionType || node.type === AST_NODE_TYPES52.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -13382,7 +13576,7 @@ var prefer_zod_infer_default = createRule({
     return {
       Program(node) {
         for (const statement of node.body) {
-          if (statement.type === AST_NODE_TYPES51.ImportDeclaration) {
+          if (statement.type === AST_NODE_TYPES52.ImportDeclaration) {
             recordZodImport(statement);
           }
         }
@@ -13391,7 +13585,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES51.Identifier || node.init == null) {
+        if (node.id.type !== AST_NODE_TYPES52.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -13408,14 +13602,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_TYPES51.Identifier && node.property.type === AST_NODE_TYPES51.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === AST_NODE_TYPES52.Identifier && node.property.type === AST_NODE_TYPES52.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === AST_NODE_TYPES51.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES51.TSQualifiedName && typeName.right.type === AST_NODE_TYPES51.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === AST_NODE_TYPES52.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES52.TSQualifiedName && typeName.right.type === AST_NODE_TYPES52.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -13447,7 +13641,7 @@ var prefer_zod_infer_default = createRule({
             typeName: node.id.name
           });
         }
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES51.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== AST_NODE_TYPES52.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -13548,7 +13742,7 @@ var prefer_zod_infer_default = createRule({
 // src/rules/require-assert-never.ts
 import {
   ESLintUtils as ESLintUtils4,
-  AST_NODE_TYPES as AST_NODE_TYPES52
+  AST_NODE_TYPES as AST_NODE_TYPES53
 } from "@typescript-eslint/utils";
 import ts3 from "typescript";
 var requireAssertNeverDocumentation = {
@@ -13562,14 +13756,14 @@ var requireAssertNeverDocumentation = {
   ]
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === AST_NODE_TYPES52.EmptyStatement) return false;
-  if (statement.type === AST_NODE_TYPES52.BreakStatement) {
+  if (statement.type === AST_NODE_TYPES53.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES53.BreakStatement) {
     return statement.label !== null;
   }
-  if (statement.type === AST_NODE_TYPES52.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES52.TSInterfaceDeclaration) {
+  if (statement.type === AST_NODE_TYPES53.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES53.TSInterfaceDeclaration) {
     return false;
   }
-  if (statement.type === AST_NODE_TYPES52.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES53.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -13585,7 +13779,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_TYPES52.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === AST_NODE_TYPES53.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -13668,7 +13862,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES54, ASTUtils as ASTUtils16 } from "@typescript-eslint/utils";
 var requireFetchTimeoutDocumentation = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -13694,14 +13888,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== AST_NODE_TYPES53.ObjectExpression) {
+  if (init.type !== AST_NODE_TYPES54.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === AST_NODE_TYPES53.SpreadElement) {
+    if (prop.type === AST_NODE_TYPES54.SpreadElement) {
       return false;
     }
-    if (prop.key.type === AST_NODE_TYPES53.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES53.Literal && prop.key.value === "signal") {
+    if (prop.key.type === AST_NODE_TYPES54.Identifier && prop.key.name === "signal" || prop.key.type === AST_NODE_TYPES54.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -13711,7 +13905,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === AST_NODE_TYPES53.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES53.TemplateLiteral || node.type === AST_NODE_TYPES53.NewExpression && node.callee.type === AST_NODE_TYPES53.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === AST_NODE_TYPES54.Literal && typeof node.value === "string" || node.type === AST_NODE_TYPES54.TemplateLiteral || node.type === AST_NODE_TYPES54.NewExpression && node.callee.type === AST_NODE_TYPES54.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -13749,30 +13943,30 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils15.findVariable(scope, identifier.name);
+      const variable = ASTUtils16.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === AST_NODE_TYPES53.Identifier) {
+      if (callee.type === AST_NODE_TYPES54.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === AST_NODE_TYPES53.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES53.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES53.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === AST_NODE_TYPES54.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES54.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES54.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = ASTUtils15.findVariable(
+      const variable = ASTUtils16.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_TYPES53.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== AST_NODE_TYPES54.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_TYPES53.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES53.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES53.AssignmentExpression || member.parent.left !== member) {
+        if (member.type !== AST_NODE_TYPES54.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES54.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES54.AssignmentExpression || member.parent.left !== member) {
           return false;
         }
       }
@@ -13787,7 +13981,7 @@ var require_fetch_timeout_default = createRule({
         if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES53.Identifier && localConstInitProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES54.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -13796,7 +13990,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-port-for-service.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES54 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES55 } from "@typescript-eslint/utils";
 var requirePortForServiceDocumentation = {
   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.",
@@ -13821,45 +14015,45 @@ var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
 var staticMemberName6 = (member) => {
-  if (member.property.type === AST_NODE_TYPES54.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === AST_NODE_TYPES54.Identifier) return member.property.name;
-  return member.computed && member.property.type === AST_NODE_TYPES54.Literal && typeof member.property.value === "string" ? member.property.value : null;
+  if (member.property.type === AST_NODE_TYPES55.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === AST_NODE_TYPES55.Identifier) return member.property.name;
+  return member.computed && member.property.type === AST_NODE_TYPES55.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_TYPES54.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === AST_NODE_TYPES55.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_TYPES54.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES54.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES55.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES55.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === AST_NODE_TYPES54.TSExportAssignment && statement.expression.type === AST_NODE_TYPES54.Identifier) {
+    } else if (statement.type === AST_NODE_TYPES55.TSExportAssignment && statement.expression.type === AST_NODE_TYPES55.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES54.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES54.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === AST_NODE_TYPES55.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES55.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === AST_NODE_TYPES54.TSUnionType) {
+  if (annotation?.type === AST_NODE_TYPES55.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== AST_NODE_TYPES54.TSUndefinedKeyword && member.type !== AST_NODE_TYPES54.TSNullKeyword
+      (member) => member.type !== AST_NODE_TYPES55.TSUndefinedKeyword && member.type !== AST_NODE_TYPES55.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES54.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== AST_NODE_TYPES55.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === AST_NODE_TYPES54.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES54.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === AST_NODE_TYPES55.Identifier ? typeName.name : typeName.type === AST_NODE_TYPES55.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === AST_NODE_TYPES54.Identifier ? name.name : name.type === AST_NODE_TYPES54.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === AST_NODE_TYPES55.Identifier ? name.name : name.type === AST_NODE_TYPES55.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_TYPES54.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== AST_NODE_TYPES54.Identifier) continue;
+    if (member.type !== AST_NODE_TYPES55.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== AST_NODE_TYPES55.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -13870,18 +14064,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES54.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES54.TSInterfaceDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES55.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES55.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== AST_NODE_TYPES54.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== AST_NODE_TYPES55.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === AST_NODE_TYPES54.TSFunctionType || aliased.type === AST_NODE_TYPES54.TSConstructorType) {
+    if (aliased.type === AST_NODE_TYPES55.TSFunctionType || aliased.type === AST_NODE_TYPES55.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === AST_NODE_TYPES54.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES54.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES54.TSTypeLiteral) : [];
+    const literals = aliased.type === AST_NODE_TYPES55.TSTypeLiteral ? [aliased] : aliased.type === AST_NODE_TYPES55.TSIntersectionType ? aliased.types.filter((part) => part.type === AST_NODE_TYPES55.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -13909,10 +14103,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === AST_NODE_TYPES54.ArrowFunctionExpression || current.type === AST_NODE_TYPES54.FunctionExpression || current.type === AST_NODE_TYPES54.FunctionDeclaration || current.type === AST_NODE_TYPES54.ClassExpression || current.type === AST_NODE_TYPES54.ClassDeclaration) continue;
-      const expression = current.type === AST_NODE_TYPES54.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === AST_NODE_TYPES54.AssignmentExpression && expression.left.type === AST_NODE_TYPES54.MemberExpression && expression.left.object.type === AST_NODE_TYPES54.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== AST_NODE_TYPES54.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES54.MemberExpression || expression.left.object.type !== AST_NODE_TYPES54.ThisExpression || storedField === null) {
+      if (current.type === AST_NODE_TYPES55.ArrowFunctionExpression || current.type === AST_NODE_TYPES55.FunctionExpression || current.type === AST_NODE_TYPES55.FunctionDeclaration || current.type === AST_NODE_TYPES55.ClassExpression || current.type === AST_NODE_TYPES55.ClassDeclaration) continue;
+      const expression = current.type === AST_NODE_TYPES55.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === AST_NODE_TYPES55.AssignmentExpression && expression.left.type === AST_NODE_TYPES55.MemberExpression && expression.left.object.type === AST_NODE_TYPES55.ThisExpression ? staticMemberName6(expression.left) : null;
+      if (expression?.type !== AST_NODE_TYPES55.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES55.MemberExpression || expression.left.object.type !== AST_NODE_TYPES55.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -13925,14 +14119,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === AST_NODE_TYPES54.TSNonNullExpression || source.type === AST_NODE_TYPES54.TSAsExpression || source.type === AST_NODE_TYPES54.TSSatisfiesExpression || source.type === AST_NODE_TYPES54.TSTypeAssertion) source = source.expression;
-      if (source.type === AST_NODE_TYPES54.NewExpression) {
+      while (source.type === AST_NODE_TYPES55.TSNonNullExpression || source.type === AST_NODE_TYPES55.TSAsExpression || source.type === AST_NODE_TYPES55.TSSatisfiesExpression || source.type === AST_NODE_TYPES55.TSTypeAssertion) source = source.expression;
+      if (source.type === AST_NODE_TYPES55.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === AST_NODE_TYPES54.Identifier) {
+      } else if (source.type === AST_NODE_TYPES55.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === AST_NODE_TYPES54.MemberExpression && source.object.type === AST_NODE_TYPES54.Identifier) {
+      } else if (source.type === AST_NODE_TYPES55.MemberExpression && source.object.type === AST_NODE_TYPES55.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -13942,7 +14136,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared)) {
-      const fields = parameter.type === AST_NODE_TYPES54.TSParameterProperty ? [reference.name] : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === AST_NODE_TYPES55.TSParameterProperty ? [reference.name] : [...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;
@@ -13957,8 +14151,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared) => {
   let target = parameter;
-  if (target.type === AST_NODE_TYPES54.AssignmentPattern) target = target.left;
-  if (target.type === AST_NODE_TYPES54.ObjectPattern) {
+  if (target.type === AST_NODE_TYPES55.AssignmentPattern) target = target.left;
+  if (target.type === AST_NODE_TYPES55.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -13966,9 +14160,9 @@ var parameterCollaborators = (parameter, declared) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === AST_NODE_TYPES54.TSParameterProperty) target = target.parameter;
-  if (target.type === AST_NODE_TYPES54.AssignmentPattern) target = target.left;
-  if (target.type !== AST_NODE_TYPES54.Identifier) return null;
+  if (target.type === AST_NODE_TYPES55.TSParameterProperty) target = target.parameter;
+  if (target.type === AST_NODE_TYPES55.AssignmentPattern) target = target.left;
+  if (target.type !== AST_NODE_TYPES55.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -13980,11 +14174,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== AST_NODE_TYPES54.Property || property.computed) continue;
-    if (property.key.type !== AST_NODE_TYPES54.Identifier) continue;
+    if (property.type !== AST_NODE_TYPES55.Property || property.computed) continue;
+    if (property.key.type !== AST_NODE_TYPES55.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === AST_NODE_TYPES54.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== AST_NODE_TYPES54.Identifier) continue;
+    const bound = property.value.type === AST_NODE_TYPES55.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== AST_NODE_TYPES55.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -13993,21 +14187,21 @@ var objectPatternCollaborators = (pattern, declared) => {
   return collaborators;
 };
 var bagMemberTypes = (annotation, declared) => {
-  if (annotation.type === AST_NODE_TYPES54.TSTypeLiteral) {
+  if (annotation.type === AST_NODE_TYPES55.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== AST_NODE_TYPES54.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES54.Identifier) {
+  if (annotation.type !== AST_NODE_TYPES55.TSTypeReference || annotation.typeName.type !== AST_NODE_TYPES55.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === AST_NODE_TYPES54.CallExpression) {
+  if (node.type === AST_NODE_TYPES55.CallExpression) {
     const { callee } = node;
-    if (callee.type === AST_NODE_TYPES54.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === AST_NODE_TYPES54.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES54.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === AST_NODE_TYPES55.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === AST_NODE_TYPES55.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES55.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === AST_NODE_TYPES54.TSTypeReference && node.typeName.type === AST_NODE_TYPES54.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === AST_NODE_TYPES55.TSTypeReference && node.typeName.type === AST_NODE_TYPES55.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -14034,19 +14228,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === AST_NODE_TYPES54.ChainExpression || callee.type === AST_NODE_TYPES54.TSAsExpression || callee.type === AST_NODE_TYPES54.TSNonNullExpression || callee.type === AST_NODE_TYPES54.TSSatisfiesExpression || callee.type === AST_NODE_TYPES54.TSTypeAssertion) callee = callee.expression;
-  return callee.type === AST_NODE_TYPES54.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === AST_NODE_TYPES55.ChainExpression || callee.type === AST_NODE_TYPES55.TSAsExpression || callee.type === AST_NODE_TYPES55.TSNonNullExpression || callee.type === AST_NODE_TYPES55.TSSatisfiesExpression || callee.type === AST_NODE_TYPES55.TSTypeAssertion) callee = callee.expression;
+  return callee.type === AST_NODE_TYPES55.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate) => {
   let node = candidate;
-  while (node.type === AST_NODE_TYPES54.ChainExpression || node.type === AST_NODE_TYPES54.TSAsExpression || node.type === AST_NODE_TYPES54.TSNonNullExpression || node.type === AST_NODE_TYPES54.TSSatisfiesExpression || node.type === AST_NODE_TYPES54.TSTypeAssertion) node = node.expression;
-  return node.type === AST_NODE_TYPES54.MemberExpression && node.object.type === AST_NODE_TYPES54.ThisExpression ? staticMemberName6(node) : null;
+  while (node.type === AST_NODE_TYPES55.ChainExpression || node.type === AST_NODE_TYPES55.TSAsExpression || node.type === AST_NODE_TYPES55.TSNonNullExpression || node.type === AST_NODE_TYPES55.TSSatisfiesExpression || node.type === AST_NODE_TYPES55.TSTypeAssertion) node = node.expression;
+  return node.type === AST_NODE_TYPES55.MemberExpression && node.object.type === AST_NODE_TYPES55.ThisExpression ? staticMemberName6(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === AST_NODE_TYPES54.ClassDeclaration || current.type === AST_NODE_TYPES54.ClassExpression || current.type === AST_NODE_TYPES54.FunctionDeclaration || current.type === AST_NODE_TYPES54.FunctionExpression) return;
-    if (current.type === AST_NODE_TYPES54.CallExpression) {
+    if (current.type === AST_NODE_TYPES55.ClassDeclaration || current.type === AST_NODE_TYPES55.ClassExpression || current.type === AST_NODE_TYPES55.FunctionDeclaration || current.type === AST_NODE_TYPES55.FunctionExpression) return;
+    if (current.type === AST_NODE_TYPES55.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -14059,14 +14253,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === AST_NODE_TYPES54.StaticBlock || member.static) continue;
-    if (member.type === AST_NODE_TYPES54.MethodDefinition) {
+    if (member.type === AST_NODE_TYPES55.StaticBlock || member.static) continue;
+    if (member.type === AST_NODE_TYPES55.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== AST_NODE_TYPES54.PropertyDefinition || member.value === null) continue;
+    if (member.type !== AST_NODE_TYPES55.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === AST_NODE_TYPES54.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === AST_NODE_TYPES55.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -14086,25 +14280,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES54.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES54.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES55.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES55.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === AST_NODE_TYPES54.PropertyDefinition) {
+    if (member.type === AST_NODE_TYPES55.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.value?.type !== AST_NODE_TYPES54.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES54.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES54.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES54.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES54.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === AST_NODE_TYPES54.Identifier ? member.key.name : "\u2026");
+      if (member.value?.type !== AST_NODE_TYPES55.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES55.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES55.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES55.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES55.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === AST_NODE_TYPES55.Identifier ? member.key.name : "\u2026");
       continue;
     }
-    if (member.type !== AST_NODE_TYPES54.MethodDefinition) continue;
+    if (member.type !== AST_NODE_TYPES55.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === AST_NODE_TYPES54.PrivateIdentifier) continue;
-    if (member.key.type === AST_NODE_TYPES54.Identifier) names.push(member.key.name);
+    if (member.key.type === AST_NODE_TYPES55.PrivateIdentifier) continue;
+    if (member.key.type === AST_NODE_TYPES55.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -14112,13 +14306,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_TYPES54.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === AST_NODE_TYPES55.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_TYPES54.TSTypeReference && result.typeName.type === AST_NODE_TYPES54.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === AST_NODE_TYPES55.TSTypeReference && result.typeName.type === AST_NODE_TYPES55.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -14126,10 +14320,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_TYPES54.ExportNamedDeclaration || statement.type === AST_NODE_TYPES54.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES54.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === AST_NODE_TYPES55.ExportNamedDeclaration || statement.type === AST_NODE_TYPES55.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES55.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === AST_NODE_TYPES54.Identifier) {
+      if (declaration.superClass?.type === AST_NODE_TYPES55.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -14151,43 +14345,43 @@ 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_TYPES54.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES54.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES54.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES54.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === AST_NODE_TYPES55.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES55.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === AST_NODE_TYPES55.TSFunctionType || declaration.typeAnnotation.type === AST_NODE_TYPES55.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES54.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES54.TSTypeAliasDeclaration) {
+    const declaration = statement.type === AST_NODE_TYPES55.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES55.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES54.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === AST_NODE_TYPES55.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === AST_NODE_TYPES54.TSTypeReference && part.typeName.type === AST_NODE_TYPES54.Identifier) {
+        if (part.type === AST_NODE_TYPES55.TSTypeReference && part.typeName.type === AST_NODE_TYPES55.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== AST_NODE_TYPES54.TSTypeLiteral) continue;
+        if (part.type !== AST_NODE_TYPES55.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== AST_NODE_TYPES54.TSMethodSignature && member.type !== AST_NODE_TYPES54.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== AST_NODE_TYPES54.Identifier) continue;
-          if (member.type === AST_NODE_TYPES54.TSMethodSignature) {
+          if (member.type !== AST_NODE_TYPES55.TSMethodSignature && member.type !== AST_NODE_TYPES55.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== AST_NODE_TYPES55.Identifier) continue;
+          if (member.type === AST_NODE_TYPES55.TSMethodSignature) {
             callables2.add(member.key.name);
             continue;
           }
-          if (member.type !== AST_NODE_TYPES54.TSPropertySignature) continue;
+          if (member.type !== AST_NODE_TYPES55.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === AST_NODE_TYPES54.TSFunctionType || annotation?.type === AST_NODE_TYPES54.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES54.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === AST_NODE_TYPES55.TSFunctionType || annotation?.type === AST_NODE_TYPES55.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES55.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       continue;
     }
-    if (declaration?.type !== AST_NODE_TYPES54.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== AST_NODE_TYPES55.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== AST_NODE_TYPES54.TSMethodSignature && member.type !== AST_NODE_TYPES54.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== AST_NODE_TYPES54.Identifier) continue;
-      if (member.type === AST_NODE_TYPES54.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES54.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES54.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES54.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      if (member.type !== AST_NODE_TYPES55.TSMethodSignature && member.type !== AST_NODE_TYPES55.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== AST_NODE_TYPES55.Identifier) continue;
+      if (member.type === AST_NODE_TYPES55.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES55.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES55.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES55.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -14195,7 +14389,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === AST_NODE_TYPES54.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === AST_NODE_TYPES55.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -14222,7 +14416,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== AST_NODE_TYPES54.Identifier) return true;
+    if (node.superClass.type !== AST_NODE_TYPES55.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -14234,7 +14428,7 @@ function hasServicePort(node, methods, classes, interfaces) {
   if (node.implements.length === 0) return false;
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== AST_NODE_TYPES54.Identifier) return true;
+    if (implementation.expression.type !== AST_NODE_TYPES55.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -14277,7 +14471,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_TYPES54.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === AST_NODE_TYPES55.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -14312,7 +14506,7 @@ var require_port_for_service_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES55 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES56 } from "@typescript-eslint/utils";
 var requireStaticNextMatcherDocumentation = {
   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.",
@@ -14325,34 +14519,34 @@ var requireStaticNextMatcherDocumentation = {
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === AST_NODE_TYPES55.TSAsExpression || node.type === AST_NODE_TYPES55.TSSatisfiesExpression || node.type === AST_NODE_TYPES55.TSNonNullExpression || node.type === AST_NODE_TYPES55.TSTypeAssertion) {
+  if (node.type === AST_NODE_TYPES56.TSAsExpression || node.type === AST_NODE_TYPES56.TSSatisfiesExpression || node.type === AST_NODE_TYPES56.TSNonNullExpression || node.type === AST_NODE_TYPES56.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === AST_NODE_TYPES55.Literal) {
+  if (value.type === AST_NODE_TYPES56.Literal) {
     return true;
   }
-  if (value.type === AST_NODE_TYPES55.TemplateLiteral) {
+  if (value.type === AST_NODE_TYPES56.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === AST_NODE_TYPES55.ArrayExpression) {
+  if (value.type === AST_NODE_TYPES56.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== AST_NODE_TYPES55.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== AST_NODE_TYPES56.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === AST_NODE_TYPES55.ObjectExpression) {
+  if (value.type === AST_NODE_TYPES56.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === AST_NODE_TYPES55.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES55.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === AST_NODE_TYPES56.Property && property.kind === "init" && !property.computed && property.value.type !== AST_NODE_TYPES56.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === AST_NODE_TYPES55.Identifier) return property.key.name;
+  if (property.key.type === AST_NODE_TYPES56.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -14375,19 +14569,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== AST_NODE_TYPES55.VariableDeclaration) {
+        if (node.declaration?.type !== AST_NODE_TYPES56.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== AST_NODE_TYPES55.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== AST_NODE_TYPES56.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== AST_NODE_TYPES55.ObjectExpression) {
+          if (config.type !== AST_NODE_TYPES56.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== AST_NODE_TYPES55.Property || propertyName2(property) !== "matcher" || property.value.type === AST_NODE_TYPES55.AssignmentPattern) {
+            if (property.type !== AST_NODE_TYPES56.Property || propertyName2(property) !== "matcher" || property.value.type === AST_NODE_TYPES56.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -14402,8 +14596,8 @@ var require_static_next_matcher_default = createRule({
 
 // src/rules/require-zod-form-validation.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES56,
-  ASTUtils as ASTUtils16
+  AST_NODE_TYPES as AST_NODE_TYPES57,
+  ASTUtils as ASTUtils17
 } from "@typescript-eslint/utils";
 var requireZodFormValidationDocumentation = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
@@ -14429,14 +14623,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES56.Identifier) {
+    if (current.type === AST_NODE_TYPES57.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES56.CallExpression) {
+    if (current.type === AST_NODE_TYPES57.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES56.MemberExpression) {
+    if (current.type === AST_NODE_TYPES57.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -14445,12 +14639,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === AST_NODE_TYPES56.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES57.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES56.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES57.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES56.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES56.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES57.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES57.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -14471,7 +14665,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => ASTUtils16.findVariable(
+    const resolvedBinding = (identifier) => ASTUtils17.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -14481,16 +14675,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES56.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES57.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === AST_NODE_TYPES56.ObjectExpression || init?.type === AST_NODE_TYPES56.ArrayExpression || init?.type === AST_NODE_TYPES56.Literal || init?.type === AST_NODE_TYPES56.ArrowFunctionExpression || init?.type === AST_NODE_TYPES56.FunctionExpression;
+      return init?.type === AST_NODE_TYPES57.ObjectExpression || init?.type === AST_NODE_TYPES57.ArrayExpression || init?.type === AST_NODE_TYPES57.Literal || init?.type === AST_NODE_TYPES57.ArrowFunctionExpression || init?.type === AST_NODE_TYPES57.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== AST_NODE_TYPES56.CallExpression) return false;
+      if (node.type !== AST_NODE_TYPES57.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES56.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES56.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES57.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES57.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -14499,14 +14693,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_TYPES56.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES57.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_TYPES56.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES57.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -14517,8 +14711,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES56.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES56.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES57.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES57.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -14534,16 +14728,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_TYPES56.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES56.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES57.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES57.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === AST_NODE_TYPES56.TSAsExpression || parent.type === AST_NODE_TYPES56.TSSatisfiesExpression || parent.type === AST_NODE_TYPES56.TSNonNullExpression || parent.type === AST_NODE_TYPES56.ChainExpression) && parent.expression === current) {
+      while ((parent.type === AST_NODE_TYPES57.TSAsExpression || parent.type === AST_NODE_TYPES57.TSSatisfiesExpression || parent.type === AST_NODE_TYPES57.TSNonNullExpression || parent.type === AST_NODE_TYPES57.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === AST_NODE_TYPES56.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES56.Identifier) {
+      if (parent.type === AST_NODE_TYPES57.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES57.Identifier) {
         return parent;
       }
       return null;
@@ -14552,7 +14746,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_TYPES56.BlockStatement || parent.type === AST_NODE_TYPES56.Program) {
+        if (parent.type === AST_NODE_TYPES57.BlockStatement || parent.type === AST_NODE_TYPES57.Program) {
           return current;
         }
         current = parent;
@@ -14561,12 +14755,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES56.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES56.Identifier ? callee.property.name : null;
+      return callee.type === AST_NODE_TYPES57.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES57.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === AST_NODE_TYPES56.LogicalExpression || current.type === AST_NODE_TYPES56.ConditionalExpression) {
+        if (current.type === AST_NODE_TYPES57.LogicalExpression || current.type === AST_NODE_TYPES57.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -14576,7 +14770,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_TYPES56.AwaitExpression) return true;
+        if (current.type === AST_NODE_TYPES57.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -14589,7 +14783,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_TYPES56.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES56.ExpressionStatement) {
+      if (validationStatement.type !== AST_NODE_TYPES57.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES57.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -14601,16 +14795,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === AST_NODE_TYPES56.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === AST_NODE_TYPES57.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== AST_NODE_TYPES56.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== AST_NODE_TYPES57.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === AST_NODE_TYPES56.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === AST_NODE_TYPES57.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES56.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES56.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES57.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES57.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -14621,23 +14815,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === AST_NODE_TYPES56.ReturnStatement || node.type === AST_NODE_TYPES56.ThrowStatement) {
+      if (node.type === AST_NODE_TYPES57.ReturnStatement || node.type === AST_NODE_TYPES57.ThrowStatement) {
         return true;
       }
-      if (node.type !== AST_NODE_TYPES56.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== AST_NODE_TYPES57.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_TYPES56.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES56.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== AST_NODE_TYPES57.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES57.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === AST_NODE_TYPES56.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === AST_NODE_TYPES57.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === AST_NODE_TYPES56.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === AST_NODE_TYPES57.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -14657,7 +14851,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_TYPES56.Identifier
+        (identifier) => identifier.type === AST_NODE_TYPES57.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -14683,7 +14877,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_TYPES56.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES56.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES56.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES56.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES57.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES57.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES57.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES57.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -14768,7 +14962,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils17 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES58, ASTUtils as ASTUtils18 } from "@typescript-eslint/utils";
 var stepdownDocumentation = {
   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.",
@@ -14785,7 +14979,7 @@ var stepdownDocumentation = {
   ]
 };
 function isFunction(node) {
-  return node.type === AST_NODE_TYPES57.ArrowFunctionExpression || node.type === AST_NODE_TYPES57.FunctionDeclaration || node.type === AST_NODE_TYPES57.FunctionExpression;
+  return node.type === AST_NODE_TYPES58.ArrowFunctionExpression || node.type === AST_NODE_TYPES58.FunctionDeclaration || node.type === AST_NODE_TYPES58.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -14880,8 +15074,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_TYPES57.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === AST_NODE_TYPES57.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === AST_NODE_TYPES58.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === AST_NODE_TYPES58.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -14905,7 +15099,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_TYPES57.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES58.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -14920,38 +15114,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== AST_NODE_TYPES57.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === AST_NODE_TYPES57.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== AST_NODE_TYPES58.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === AST_NODE_TYPES58.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === AST_NODE_TYPES57.VariableDeclaration) {
+    if (statement.declaration?.type === AST_NODE_TYPES58.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === AST_NODE_TYPES57.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === AST_NODE_TYPES58.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES57.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES58.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === AST_NODE_TYPES57.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES57.Identifier) names.add(statement.declaration.name);
-    if (statement.type === AST_NODE_TYPES57.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES57.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === AST_NODE_TYPES58.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES58.Identifier) names.add(statement.declaration.name);
+    if (statement.type === AST_NODE_TYPES58.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES58.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_TYPES57.ExportNamedDeclaration || statement.type === AST_NODE_TYPES57.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === AST_NODE_TYPES57.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === AST_NODE_TYPES58.ExportNamedDeclaration || statement.type === AST_NODE_TYPES58.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === AST_NODE_TYPES58.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== AST_NODE_TYPES57.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== AST_NODE_TYPES58.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === AST_NODE_TYPES57.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === AST_NODE_TYPES58.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -14964,21 +15158,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === AST_NODE_TYPES57.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === AST_NODE_TYPES57.Identifier ? node.key.name : null;
+  if (node.key.type === AST_NODE_TYPES58.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === AST_NODE_TYPES58.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils17.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES58.Identifier ? ASTUtils18.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== AST_NODE_TYPES57.ThisExpression && !isClassReference) return null;
-  if (node.property.type === AST_NODE_TYPES57.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES57.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES57.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== AST_NODE_TYPES58.ThisExpression && !isClassReference) return null;
+  if (node.property.type === AST_NODE_TYPES58.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES58.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES58.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === AST_NODE_TYPES57.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES57.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES57.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === AST_NODE_TYPES58.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES58.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES58.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -14994,7 +15188,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES57.MethodDefinition
+    (member) => member.type === AST_NODE_TYPES58.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -15002,8 +15196,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== AST_NODE_TYPES57.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === AST_NODE_TYPES57.Identifier ? member.key.name : null;
+    if (member.type !== AST_NODE_TYPES58.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === AST_NODE_TYPES58.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -15012,7 +15206,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES57.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES58.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -15021,11 +15215,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils17.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils18.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === AST_NODE_TYPES57.ClassExpression && node.parent.type === AST_NODE_TYPES57.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES57.Identifier) {
-    const outer = ASTUtils17.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === AST_NODE_TYPES58.ClassExpression && node.parent.type === AST_NODE_TYPES58.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES58.Identifier) {
+    const outer = ASTUtils18.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -15041,27 +15235,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === AST_NODE_TYPES57.TSAsExpression || current?.type === AST_NODE_TYPES57.TSSatisfiesExpression || current?.type === AST_NODE_TYPES57.TSNonNullExpression) current = current.expression;
-      return current?.type === AST_NODE_TYPES57.ThisExpression;
+      while (current?.type === AST_NODE_TYPES58.TSAsExpression || current?.type === AST_NODE_TYPES58.TSSatisfiesExpression || current?.type === AST_NODE_TYPES58.TSNonNullExpression) current = current.expression;
+      return current?.type === AST_NODE_TYPES58.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== AST_NODE_TYPES57.VariableDeclarator && current.type !== AST_NODE_TYPES57.AssignmentPattern) return;
-      if (current.type === AST_NODE_TYPES57.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES57.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === AST_NODE_TYPES57.VariableDeclarator ? current.id : current.left;
-      const value = current.type === AST_NODE_TYPES57.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== AST_NODE_TYPES58.VariableDeclarator && current.type !== AST_NODE_TYPES58.AssignmentPattern) return;
+      if (current.type === AST_NODE_TYPES58.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES58.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === AST_NODE_TYPES58.VariableDeclarator ? current.id : current.left;
+      const value = current.type === AST_NODE_TYPES58.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === AST_NODE_TYPES57.ObjectPattern) {
+      if (binding.type === AST_NODE_TYPES58.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === AST_NODE_TYPES57.RestElement) {
+          if (property.type === AST_NODE_TYPES58.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === AST_NODE_TYPES57.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === AST_NODE_TYPES58.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== AST_NODE_TYPES57.Identifier) return;
-      const variable = ASTUtils17.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== AST_NODE_TYPES58.Identifier) return;
+      const variable = ASTUtils18.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -15074,16 +15268,16 @@ function classScope(context, node, computedReferenceNames) {
       walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === AST_NODE_TYPES57.VariableDeclarator && current.id.type === AST_NODE_TYPES57.ObjectPattern && thisValue(current.init)) {
+      if (current.type === AST_NODE_TYPES58.VariableDeclarator && current.id.type === AST_NODE_TYPES58.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === AST_NODE_TYPES57.RestElement) {
+          if (property.type === AST_NODE_TYPES58.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === AST_NODE_TYPES57.Property && property.key.type === AST_NODE_TYPES57.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === AST_NODE_TYPES58.Property && property.key.type === AST_NODE_TYPES58.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== AST_NODE_TYPES57.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES58.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -15091,12 +15285,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils17.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES58.Identifier ? ASTUtils18.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_TYPES57.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES58.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -15116,9 +15310,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === AST_NODE_TYPES57.MethodDefinition || member.type === AST_NODE_TYPES57.TSAbstractMethodDefinition) continue;
+    if (member.type === AST_NODE_TYPES58.MethodDefinition || member.type === AST_NODE_TYPES58.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== AST_NODE_TYPES57.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES58.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -15128,14 +15322,14 @@ function classScope(context, node, computedReferenceNames) {
   const accessibility = new Map(
     scopeDefinitions.map((definition) => {
       const method = definition.node;
-      const accessibility2 = method.key.type === AST_NODE_TYPES57.PrivateIdentifier ? "private" : method.accessibility ?? "public";
+      const accessibility2 = method.key.type === AST_NODE_TYPES58.PrivateIdentifier ? "private" : method.accessibility ?? "public";
       return [definition.name, accessibility2];
     })
   );
   const methodByName = new Map(scopeDefinitions.map((definition) => [definition.name, definition.node]));
   for (const [caller, callees] of calls) {
     const callerMethod = methodByName.get(caller);
-    if (accessibility.get(caller) === "private" && callerMethod?.type === AST_NODE_TYPES57.MethodDefinition && callerMethod.decorators.length === 0) continue;
+    if (accessibility.get(caller) === "private" && callerMethod?.type === AST_NODE_TYPES58.MethodDefinition && callerMethod.decorators.length === 0) continue;
     for (const callee of callees) pinned.add(callee);
   }
   const memberIndexes = new Map(node.body.body.map((member, index) => [member, index]));
@@ -15152,12 +15346,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case AST_NODE_TYPES57.StaticBlock:
+    case AST_NODE_TYPES58.StaticBlock:
       return true;
-    case AST_NODE_TYPES57.PropertyDefinition:
-    case AST_NODE_TYPES57.AccessorProperty:
+    case AST_NODE_TYPES58.PropertyDefinition:
+    case AST_NODE_TYPES58.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case AST_NODE_TYPES57.MethodDefinition:
+    case AST_NODE_TYPES58.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -15189,7 +15383,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === AST_NODE_TYPES57.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES57.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === AST_NODE_TYPES58.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES58.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -15198,8 +15392,8 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES58 } from "@typescript-eslint/utils";
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|py|[cm]?[jt]s)$/iu;
+import { AST_NODE_TYPES as AST_NODE_TYPES59 } from "@typescript-eslint/utils";
+var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
 var TEXT_TRANSFORMS = /* @__PURE__ */ new Set([
@@ -15267,20 +15461,20 @@ var sourceCoupledTestDocumentation = {
   ]
 };
 function staticMemberName7(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES58.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES58.Literal && typeof node.property.value === "string") return node.property.value;
+  if (!node.computed && node.property.type === AST_NODE_TYPES59.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES59.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap5(node) {
-  if (node.type === AST_NODE_TYPES58.AwaitExpression) return unwrap5(node.argument);
-  if (node.type === AST_NODE_TYPES58.ChainExpression) return unwrap5(node.expression);
-  if (node.type === AST_NODE_TYPES58.TSAsExpression || node.type === AST_NODE_TYPES58.TSNonNullExpression || node.type === AST_NODE_TYPES58.TSTypeAssertion) return unwrap5(node.expression);
+  if (node.type === AST_NODE_TYPES59.AwaitExpression) return unwrap5(node.argument);
+  if (node.type === AST_NODE_TYPES59.ChainExpression) return unwrap5(node.expression);
+  if (node.type === AST_NODE_TYPES59.TSAsExpression || node.type === AST_NODE_TYPES59.TSNonNullExpression || node.type === AST_NODE_TYPES59.TSTypeAssertion) return unwrap5(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap5(node);
-  if (current.type === AST_NODE_TYPES58.Literal && typeof current.value === "string") return current.value;
-  if (current.type === AST_NODE_TYPES58.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === AST_NODE_TYPES59.Literal && typeof current.value === "string") return current.value;
+  if (current.type === AST_NODE_TYPES59.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
   return null;
 }
 function importSource(node) {
@@ -15288,7 +15482,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap5(node);
-  if (current.type !== AST_NODE_TYPES58.CallExpression || current.callee.type !== AST_NODE_TYPES58.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES58.SpreadElement) return null;
+  if (current.type !== AST_NODE_TYPES59.CallExpression || current.callee.type !== AST_NODE_TYPES59.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES59.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -15328,38 +15522,38 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap5(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === AST_NODE_TYPES58.Identifier) return visible("paths", current.name);
-        if (current.type === AST_NODE_TYPES58.BinaryExpression && current.operator === "+") {
+        if (current.type === AST_NODE_TYPES59.Identifier) return visible("paths", current.name);
+        if (current.type === AST_NODE_TYPES59.BinaryExpression && current.operator === "+") {
           return sourcePath(current.left) || sourcePath(current.right);
         }
-        if (current.type === AST_NODE_TYPES58.TemplateLiteral) return current.expressions.some(sourcePath);
-        if (current.type === AST_NODE_TYPES58.CallExpression || current.type === AST_NODE_TYPES58.NewExpression) {
-          return current.arguments.some((argument) => argument.type !== AST_NODE_TYPES58.SpreadElement && sourcePath(argument));
+        if (current.type === AST_NODE_TYPES59.TemplateLiteral) return current.expressions.some(sourcePath);
+        if (current.type === AST_NODE_TYPES59.CallExpression || current.type === AST_NODE_TYPES59.NewExpression) {
+          return current.arguments.some((argument) => argument.type !== AST_NODE_TYPES59.SpreadElement && sourcePath(argument));
         }
-        if (current.type === AST_NODE_TYPES58.MemberExpression) return sourcePath(current.object);
+        if (current.type === AST_NODE_TYPES59.MemberExpression) return sourcePath(current.object);
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap5(node);
-        if (current.type !== AST_NODE_TYPES58.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== AST_NODE_TYPES59.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap5(current.callee);
-        if (callee.type === AST_NODE_TYPES58.Identifier) {
+        if (callee.type === AST_NODE_TYPES59.Identifier) {
           return visible("fsReaders", callee.name) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== AST_NODE_TYPES58.MemberExpression) return false;
+        if (callee.type !== AST_NODE_TYPES59.MemberExpression) return false;
         const name2 = staticMemberName7(callee);
         const object = unwrap5(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES58.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES59.Identifier && visible("fsObjects", object.name) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap5(node);
-        if (current.type === AST_NODE_TYPES58.Identifier) return visibleRawOrigins(current.name);
+        if (current.type === AST_NODE_TYPES59.Identifier) return visibleRawOrigins(current.name);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === AST_NODE_TYPES58.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES58.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== AST_NODE_TYPES58.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES59.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES59.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type !== AST_NODE_TYPES59.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap5(current.callee);
-        if (callee.type !== AST_NODE_TYPES58.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES59.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
@@ -15367,32 +15561,39 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap5(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === AST_NODE_TYPES58.BinaryExpression || current.type === AST_NODE_TYPES58.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES58.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== AST_NODE_TYPES58.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES59.BinaryExpression || current.type === AST_NODE_TYPES59.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES59.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== AST_NODE_TYPES59.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap5(current.callee);
-        if (callee.type !== AST_NODE_TYPES58.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES59.MemberExpression) return /* @__PURE__ */ new Set();
         const name2 = staticMemberName7(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(callee.object);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES58.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES59.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap5(node.callee);
-        if (callee.type === AST_NODE_TYPES58.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES58.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === AST_NODE_TYPES59.Identifier && callee.name === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES59.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== AST_NODE_TYPES58.MemberExpression) return /* @__PURE__ */ new Set();
+        if (callee.type !== AST_NODE_TYPES59.MemberExpression) return /* @__PURE__ */ new Set();
         const matcher = staticMemberName7(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap5(callee.object);
-        while (receiver.type === AST_NODE_TYPES58.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap5(receiver.object);
-        if (receiver.type === AST_NODE_TYPES58.CallExpression && receiver.callee.type === AST_NODE_TYPES58.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === AST_NODE_TYPES59.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap5(receiver.object);
+        if (receiver.type === AST_NODE_TYPES59.CallExpression && receiver.callee.type === AST_NODE_TYPES59.Identifier && receiver.callee.name === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES58.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES59.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== AST_NODE_TYPES58.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES58.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== AST_NODE_TYPES59.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES59.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+      };
+      const rawRegexExtractionOrigins = (node) => {
+        const callee = unwrap5(node.callee);
+        if (callee.type !== AST_NODE_TYPES59.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        const argument = node.arguments[0];
+        if (argument?.type !== AST_NODE_TYPES59.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
+        return rawOrigins(callee.object);
       };
       const declare = (name2, state) => {
         const scope = currentScope();
@@ -15412,15 +15613,15 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap5(node);
-        return current.type === AST_NODE_TYPES58.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES58.SpreadElement && sourcePath(element));
+        return current.type === AST_NODE_TYPES59.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES59.SpreadElement && sourcePath(element));
       };
       const declaredNames2 = (node) => {
         const current = unwrap5(node);
-        if (current.type === AST_NODE_TYPES58.Identifier) return [current.name];
-        if (current.type === AST_NODE_TYPES58.AssignmentPattern) return declaredNames2(current.left);
-        if (current.type === AST_NODE_TYPES58.RestElement) return declaredNames2(current.argument);
-        if (current.type === AST_NODE_TYPES58.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
-        if (current.type === AST_NODE_TYPES58.ObjectPattern) return current.properties.flatMap((property) => property.type === AST_NODE_TYPES58.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
+        if (current.type === AST_NODE_TYPES59.Identifier) return [current.name];
+        if (current.type === AST_NODE_TYPES59.AssignmentPattern) return declaredNames2(current.left);
+        if (current.type === AST_NODE_TYPES59.RestElement) return declaredNames2(current.argument);
+        if (current.type === AST_NODE_TYPES59.ArrayPattern) return current.elements.flatMap((element) => element === null ? [] : declaredNames2(element));
+        if (current.type === AST_NODE_TYPES59.ObjectPattern) return current.properties.flatMap((property) => property.type === AST_NODE_TYPES59.RestElement ? declaredNames2(property.argument) : declaredNames2(property.value));
         return [];
       };
       const enterFunction = (node) => {
@@ -15435,8 +15636,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_TYPES58.ImportSpecifier) {
-              const imported = specifier.imported.type === AST_NODE_TYPES58.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === AST_NODE_TYPES59.ImportSpecifier) {
+              const imported = specifier.imported.type === AST_NODE_TYPES59.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local.name, { fsReader: true });
             } else {
               declare(specifier.local.name, { fsObject: true });
@@ -15448,32 +15649,35 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         VariableDeclarator(node) {
           if (node.init === null) return;
           const required = requireSource(node.init);
-          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES58.Identifier) {
+          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES59.Identifier) {
             declare(node.id.name, { fsObject: true });
             return;
           }
-          if (node.id.type === AST_NODE_TYPES58.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === AST_NODE_TYPES59.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== AST_NODE_TYPES58.Property || property.value.type !== AST_NODE_TYPES58.Identifier) continue;
-              const key = property.key.type === AST_NODE_TYPES58.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES58.Literal ? String(property.key.value) : "";
+              if (property.type !== AST_NODE_TYPES59.Property || property.value.type !== AST_NODE_TYPES59.Identifier) continue;
+              const key = property.key.type === AST_NODE_TYPES59.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES59.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value.name, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== AST_NODE_TYPES58.Identifier) return;
+          if (node.id.type !== AST_NODE_TYPES59.Identifier) return;
           declare(node.id.name, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === AST_NODE_TYPES58.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
+          if (node.left.type === AST_NODE_TYPES59.Identifier) declare(node.left.name, { path: sourcePath(node.right), rawOrigins: rawOrigins(node.right) });
         },
         ForOfStatement(node) {
           const right = unwrap5(node.right);
-          const collection = right.type === AST_NODE_TYPES58.Identifier && visible("collections", right.name);
-          const left = node.left.type === AST_NODE_TYPES58.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === AST_NODE_TYPES58.Identifier) declare(left.name, { path: true });
+          const collection = right.type === AST_NODE_TYPES59.Identifier && visible("collections", right.name);
+          const left = node.left.type === AST_NODE_TYPES59.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === AST_NODE_TYPES59.Identifier) declare(left.name, { path: true });
         },
         CallExpression(node) {
-          const origins = rawAssertionOrigins(node);
+          const origins = /* @__PURE__ */ new Set([
+            ...rawAssertionOrigins(node),
+            ...rawRegexExtractionOrigins(node)
+          ]);
           if (origins.size === 0 || [...origins].every((origin) => reportedOrigins.has(origin))) return;
           for (const origin of origins) reportedOrigins.add(origin);
           context.report({ node, messageId: "rawSourceOracle" });
@@ -15528,8 +15732,8 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 
 // src/rules/zod-naming-convention.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES59,
-  ASTUtils as ASTUtils18
+  AST_NODE_TYPES as AST_NODE_TYPES60,
+  ASTUtils as ASTUtils19
 } from "@typescript-eslint/utils";
 var zodNamingConventionDocumentation = {
   summary: "Enforce a consistent Zod schema naming convention \u2014 a `Z` prefix (`ZUser`) or a `Schema` suffix (`userSchema`); both are accepted by default.",
@@ -15571,18 +15775,18 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "prettifyError",
   "treeifyError"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES59.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES60.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES59.Identifier) {
+    if (current.type === AST_NODE_TYPES60.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES59.MemberExpression) {
+    if (current.type === AST_NODE_TYPES60.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES59.CallExpression) {
+    if (current.type === AST_NODE_TYPES60.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -15622,7 +15826,7 @@ var zod_naming_convention_default = createRule({
     const acceptsSchemaWord = convention !== "prefix";
     const zodBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils18.findVariable(
+      return ASTUtils19.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -15644,7 +15848,7 @@ var zod_naming_convention_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES59.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES59.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES59.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES59.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES60.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES60.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES60.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES60.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -15652,13 +15856,13 @@ var zod_naming_convention_default = createRule({
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== AST_NODE_TYPES59.CallExpression) return;
+        if (init.type !== AST_NODE_TYPES60.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== AST_NODE_TYPES59.MemberExpression) return;
+        if (callee.type !== AST_NODE_TYPES60.MemberExpression) return;
         if (!isZodChain(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== AST_NODE_TYPES59.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES60.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -15796,6 +16000,7 @@ var rules = {
   "no-unsafe-mock-casting": no_unsafe_mock_casting_default,
   "no-zod-native-enum": no_zod_native_enum_default,
   "test-loops-over-literal-cases": test_loops_over_literal_cases_default,
+  "test-phase-label-comment": test_phase_label_comment_default,
   "prefer-constant-time-secret-compare": prefer_constant_time_secret_compare_default,
   "prefer-discriminated-union": prefer_discriminated_union_default,
   "prefer-input-group-search": prefer_input_group_search_default,
@@ -15824,7 +16029,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.8.2"
+  version: "15.10.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",
@@ -15835,7 +16040,8 @@ var advisoryRules = [
   "no-bare-return-from-test-catch",
   "iac-source-coupled-test",
   "repeated-static-call-cases",
-  "source-coupled-test"
+  "source-coupled-test",
+  "test-phase-label-comment"
 ];
 var recommendedRules = {
   "@sarj/iac-source-coupled-test": "warn",
@@ -15899,6 +16105,7 @@ var recommendedRules = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "warn",
+  "@sarj/test-phase-label-comment": "warn",
   "@sarj/zod-naming-convention": "error"
 };
 var strictRules = {
@@ -15967,6 +16174,7 @@ var strictRules = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "warn",
+  "@sarj/test-phase-label-comment": "warn",
   "@sarj/zod-naming-convention": "error"
 };
 var plugin = {