@sarj/eslint-plugin 11.1.0 → 12.0.0

package/dist/index.cjs

@@ -869,6 +869,7 @@ var BANNER_RUN_RE = /={4,}|-{4,}|#{4,}|\*{4,}|~{4,}|[\u2500-\u257f]{4,}/;
 var REGION_MARKER_RE = /^#?(?:end)?region\b(.*)$/i;
 var REGION_TITLE_RE = /^[\s:\-\u2013\u2014]*\w[\w \-/&+]*$/;
 var REGION_TITLE_MAX_WORDS = 5;
+var REGION_PROSE_VERB_RE = /^(?:is|are|was|were|comes?|defaults?|derives?|inherits?|depends?|uses?|maps?|resolves?)\b/i;
 function stripCommentMarker(line) {
   return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
 }
@@ -930,7 +931,9 @@ var CALL_RE = /^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
 var ASSERTION_CODE_RE = /^(?:await\s+)?(?:expect(?:TypeOf)?|assert(?:\.\w+)?)\s*\(/;
 var HTTP_CONTRACT_RE = /\b(?:GET|HEAD|OPTIONS|PATCH|POST|PUT|DELETE)\s+(?:https?:\/\/|\/|\{[A-Za-z_$])/;
 var PROSE_ASSIGNMENT_RE = /^[A-Za-z_$][\w.$[\]]*\s*=\s*[A-Za-z][A-Za-z '-]{2,}\s+\((?:how|what|when|where|which|who|why)\b[^)]*\)[.!]?$/i;
-var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
+var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|\b[A-Za-z_$][\w$]*\s+x\d+\b|…|\.\.\./;
+var CALL_LABEL_RE = /^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\([^;{}]*\)$/;
+var MULTIPLIER_PSEUDOCODE_RE = /\b[A-Za-z_$][\w$]*\s+x\d+\b/;
 function isBanner(text) {
   const t = text.trim();
   if (!t) return false;
@@ -942,6 +945,7 @@ function isRegionMarker(text) {
   if (match === null) return false;
   const title = (match[1] ?? "").trim();
   if (title.length === 0) return true;
+  if (REGION_PROSE_VERB_RE.test(title)) return false;
   if (!REGION_TITLE_RE.test(title)) return false;
   return title.split(/\s+/).length <= REGION_TITLE_MAX_WORDS;
 }
@@ -957,6 +961,15 @@ function looksLikeCode(text, allowCall = true) {
 function hasPseudocode(text) {
   return PSEUDOCODE_RE.test(text);
 }
+function testCallMatrixStems(comments) {
+  const stems = /* @__PURE__ */ new Set();
+  for (const comment of comments) {
+    const body2 = stripCommentMarker(comment.value);
+    const stem3 = CALL_LABEL_RE.exec(body2)?.[1];
+    if (stem3 !== void 0 && MULTIPLIER_PSEUDOCODE_RE.test(body2)) stems.add(stem3);
+  }
+  return stems;
+}
 function isEnumeratedProseItem(text) {
   const t = text.trim();
   return ENUMERATED_ITEM_RE.test(t) && t.split(/\s+/).length >= ENUMERATED_ITEM_MIN_WORDS;
@@ -1245,6 +1258,7 @@ var no_comment_cruft_default = createRule({
     return {
       Program() {
         const comments = sourceCode.getAllComments();
+        const callMatrixStems = isTestFile(context.filename) ? testCallMatrixStems(comments) : /* @__PURE__ */ new Set();
         const walls = findCommentWalls(comments);
         const wallByLeader = new Map(walls.map((wall) => [wall.leader, wall]));
         const wallMembers = new Set(walls.flatMap((wall) => [...wall.members]));
@@ -1282,6 +1296,8 @@ var no_comment_cruft_default = createRule({
             continue;
           }
           const firstText = texts[0];
+          const firstTextStem = firstText === void 0 ? void 0 : CALL_LABEL_RE.exec(firstText)?.[1];
+          if (firstTextStem !== void 0 && texts.length === 1 && callMatrixStems.has(firstTextStem)) continue;
           if (firstText !== void 0 && /^(?:todo|fixme)\b/i.test(firstText)) {
             if (!runCitesAReference(comments, i)) {
               context.report({
@@ -1486,13 +1502,17 @@ function calleeRootName(call) {
 var isAssertionCall = (node) => node.type === import_utils8.AST_NODE_TYPES.CallExpression && ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
 var isTypeAssertionCall = (node) => node.type === import_utils8.AST_NODE_TYPES.CallExpression && TYPE_ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
 var containsAssertion = (node) => subtreeMatches(node, isAssertionCall);
+var containsRuntimeAssertion = (node) => subtreeMatches(
+  node,
+  (current) => isAssertionCall(current) && !isTypeAssertionCall(current)
+);
 var containsSkipCall = (node) => subtreeMatches(
   node,
   (current) => current.type === import_utils8.AST_NODE_TYPES.CallExpression && current.callee.type === import_utils8.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils8.AST_NODE_TYPES.Identifier && current.callee.property.name === "skip"
 );
 var containsEscape = (node) => subtreeMatches(
   node,
-  (current) => current.type === import_utils8.AST_NODE_TYPES.ReturnStatement || current.type === import_utils8.AST_NODE_TYPES.ContinueStatement || current.type === import_utils8.AST_NODE_TYPES.BreakStatement,
+  (current) => current.type === import_utils8.AST_NODE_TYPES.ReturnStatement || current.type === import_utils8.AST_NODE_TYPES.ContinueStatement || current.type === import_utils8.AST_NODE_TYPES.BreakStatement || current.type === import_utils8.AST_NODE_TYPES.ThrowStatement,
   false
 );
 function branchStatements(branch) {
@@ -1523,7 +1543,7 @@ function isPinnedNarrowingGuard(node) {
   }
   let matched = false;
   subtreeMatches(previous, (current) => {
-    if (current.type !== import_utils8.AST_NODE_TYPES.CallExpression || current.callee.type !== import_utils8.AST_NODE_TYPES.Identifier || current.callee.name !== "expect") {
+    if (current.type !== import_utils8.AST_NODE_TYPES.CallExpression || !ASSERTION_ROOTS.has(calleeRootName(current) ?? "")) {
       return false;
     }
     const subject = current.arguments[0];
@@ -1579,6 +1599,30 @@ function isInertNormalization(node) {
 function isExemptIfStatement(node) {
   return isPinnedNarrowingGuard(node) || isThrowingGuard(node) || isTypeLevelNarrowing(node) || isInertNormalization(node);
 }
+function skipsAssertionOrTest(node) {
+  const branches = [node.consequent, node.alternate].filter(
+    (branch) => branch !== null
+  );
+  if (branches.some(
+    (branch) => containsEscape(branch) || containsSkipCall(branch)
+  )) {
+    return true;
+  }
+  const asserted = branches.map(containsRuntimeAssertion);
+  return asserted.some(Boolean) && (node.alternate === null || !asserted.every(Boolean));
+}
+function switchSkipsAssertion(node) {
+  const asserted = node.cases.map(
+    (caseNode) => caseNode.consequent.some(containsRuntimeAssertion)
+  );
+  if (!asserted.some(Boolean)) return false;
+  return node.cases.every((caseNode) => caseNode.test !== null) || !asserted.every(Boolean);
+}
+function conditionalSkipsAssertion(node) {
+  const consequent = containsRuntimeAssertion(node.consequent);
+  const alternate = containsRuntimeAssertion(node.alternate);
+  return consequent !== alternate;
+}
 function isShortCircuitedAssertion(node) {
   return node.operator !== "??" && node.parent.type === import_utils8.AST_NODE_TYPES.ExpressionStatement && containsAssertion(node.right);
 }
@@ -1587,11 +1631,11 @@ var no_conditional_in_test_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow conditional logic (if, switch, ternary) in test bodies, which can hide missing assertions or test multiple code paths."
+      description: "Disallow test conditionals that can skip a runtime assertion or exit the test before one runs."
     },
     schema: [],
     messages: {
-      noConditionalInTest: "Avoid using conditional logic in tests. It can obscure intent and hide unexecuted assertions. Split the test instead."
+      noConditionalInTest: "This conditional can skip a runtime assertion or exit the test before it runs. Make the assertion unconditional or split the test."
     }
   },
   defaultOptions: [],
@@ -1608,16 +1652,16 @@ var no_conditional_in_test_default = createRule({
     };
     return {
       IfStatement(node) {
-        if (isExemptIfStatement(node)) {
+        if (isExemptIfStatement(node) || !skipsAssertionOrTest(node)) {
           return;
         }
         report(node);
       },
       SwitchStatement(node) {
-        report(node);
+        if (switchSkipsAssertion(node)) report(node);
       },
       ConditionalExpression(node) {
-        report(node);
+        if (conditionalSkipsAssertion(node)) report(node);
       },
       LogicalExpression(node) {
         if (!isShortCircuitedAssertion(node)) {
@@ -2211,6 +2255,20 @@ var PURE_METHODS = /* @__PURE__ */ new Set([
   "startsWith",
   "endsWith"
 ]);
+var SYNC_CALLBACK_METHODS = /* @__PURE__ */ new Set([
+  "every",
+  "filter",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "flatMap",
+  "forEach",
+  "map",
+  "reduce",
+  "reduceRight",
+  "some",
+  "sort"
+]);
 var PURE_NAMESPACES = /* @__PURE__ */ new Set([
   "Object",
   "Array",
@@ -2260,7 +2318,17 @@ function isPureCall(node) {
   if (callee.object.type === import_utils13.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
     return !IMPURE_NAMESPACE_METHODS.has(`${callee.object.name}.${property.name}`);
   }
-  return PURE_METHODS.has(property.name);
+  return PURE_METHODS.has(property.name) && (!SYNC_CALLBACK_METHODS.has(property.name) || !synchronousCallbackCanThrow(node));
+}
+function synchronousCallbackCanThrow(node) {
+  return node.arguments.some((argument) => {
+    if (argument.type !== import_utils13.AST_NODE_TYPES.ArrowFunctionExpression && argument.type !== import_utils13.AST_NODE_TYPES.FunctionExpression) return false;
+    if (argument.async) return false;
+    return subtreeMatches2(
+      argument.body,
+      (current) => current.type === import_utils13.AST_NODE_TYPES.ThrowStatement || current.type === import_utils13.AST_NODE_TYPES.CallExpression && current.callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.object.type === import_utils13.AST_NODE_TYPES.Identifier && current.callee.object.name === "JSON" && current.callee.property.type === import_utils13.AST_NODE_TYPES.Identifier && current.callee.property.name === "parse"
+    );
+  });
 }
 function isPureNew(node) {
   return node.callee.type === import_utils13.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
@@ -3147,11 +3215,233 @@ var no_json_stringify_error_default = createRule({
   }
 });
 
+// src/rules/no-impossible-zod-literal-bounds.ts
+var import_utils18 = require("@typescript-eslint/utils");
+
+// src/rules/_zod.ts
+var ZOD_PREFIX_RE = /^Z[A-Z]/;
+var ZOD_SUFFIX_RE = /Schema$/;
+var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
+function isZodModule(source) {
+  return /(^|[/@-])zod([/-]|$)/.test(source);
+}
+
+// src/rules/no-impossible-zod-literal-bounds.ts
+var KINDS = /* @__PURE__ */ new Set(["array", "number", "string"]);
+var NUMBER_METHODS = /* @__PURE__ */ new Set([
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "max",
+  "min"
+]);
+var LENGTH_METHODS = /* @__PURE__ */ new Set(["length", "max", "min"]);
+var RESHAPING_METHODS = /* @__PURE__ */ new Set([
+  "pipe",
+  "preprocess",
+  "transform"
+]);
+function importedName(specifier) {
+  return specifier.imported.type === import_utils18.AST_NODE_TYPES.Identifier ? specifier.imported.name : typeof specifier.imported.value === "string" ? specifier.imported.value : null;
+}
+function memberName(node) {
+  if (!node.computed && node.property.type === import_utils18.AST_NODE_TYPES.Identifier) {
+    return node.property.name;
+  }
+  if (node.computed && node.property.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.property.value === "string") {
+    return node.property.value;
+  }
+  return null;
+}
+function finiteNumber(node) {
+  if (node?.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "number") {
+    return Number.isFinite(node.value) ? node.value : null;
+  }
+  if (node?.type === import_utils18.AST_NODE_TYPES.UnaryExpression && (node.operator === "-" || node.operator === "+") && node.argument.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.argument.value === "number") {
+    const value = node.operator === "-" ? -node.argument.value : node.argument.value;
+    return Number.isFinite(value) ? value : null;
+  }
+  return null;
+}
+function strongerLower(current, candidate) {
+  if (current === null || candidate.value > current.value || candidate.value === current.value && candidate.exclusive && !current.exclusive) {
+    return candidate;
+  }
+  return current;
+}
+function strongerUpper(current, candidate) {
+  if (current === null || candidate.value < current.value || candidate.value === current.value && candidate.exclusive && !current.exclusive) {
+    return candidate;
+  }
+  return current;
+}
+function isEmpty(lower, upper) {
+  if (lower === null || upper === null) return false;
+  return lower.value > upper.value || lower.value === upper.value && (lower.exclusive || upper.exclusive);
+}
+function isOutermostCall(node) {
+  const parent = node.parent;
+  return !(parent?.type === import_utils18.AST_NODE_TYPES.MemberExpression && parent.object === node && parent.parent?.type === import_utils18.AST_NODE_TYPES.CallExpression && parent.parent.callee === parent);
+}
+var no_impossible_zod_literal_bounds_default = createRule({
+  name: "no-impossible-zod-literal-bounds",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow same-chain literal Zod bounds whose accepted set is mathematically empty."
+    },
+    schema: [],
+    messages: {
+      impossibleBounds: "This Zod {{kind}} schema accepts no values: {{lower}} conflicts with {{upper}}."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
+      return {};
+    }
+    const namespaces = /* @__PURE__ */ new Set();
+    const constructors = /* @__PURE__ */ new Map();
+    const preprocessors = /* @__PURE__ */ new Set();
+    const importBindings = /* @__PURE__ */ new Map();
+    function resolvesToTrackedImport(node) {
+      const binding = importBindings.get(node.name);
+      if (binding === void 0) return false;
+      let scope = sourceCode.getScope(node);
+      while (scope !== null) {
+        const variable = scope.variables.find((candidate) => candidate.name === node.name);
+        if (variable !== void 0) {
+          return variable.defs.some((definition) => definition.name === binding);
+        }
+        scope = scope.upper;
+      }
+      return false;
+    }
+    function baseKind(node) {
+      const callee = node.callee;
+      if (callee.type === import_utils18.AST_NODE_TYPES.Identifier) {
+        return resolvesToTrackedImport(callee) ? constructors.get(callee.name) ?? null : null;
+      }
+      if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils18.AST_NODE_TYPES.Identifier || !namespaces.has(callee.object.name) || !resolvesToTrackedImport(callee.object)) {
+        return null;
+      }
+      const name = memberName(callee);
+      return name !== null && KINDS.has(name) ? name : null;
+    }
+    function readChain(node) {
+      const calls = [];
+      let current = node;
+      while (true) {
+        const kind = baseKind(current);
+        if (kind !== null) return { calls, kind };
+        const callee = current.callee;
+        if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils18.AST_NODE_TYPES.CallExpression) {
+          return null;
+        }
+        const method = memberName(callee);
+        if (method === null) return null;
+        calls.push({ method, node: current });
+        current = callee.object;
+      }
+    }
+    function isInsideReshapingCall(node) {
+      let child = node;
+      let parent = child.parent;
+      while (parent !== void 0 && parent.type !== import_utils18.AST_NODE_TYPES.Program) {
+        if (parent.type === import_utils18.AST_NODE_TYPES.CallExpression) {
+          const callee = parent.callee;
+          if (callee.type === import_utils18.AST_NODE_TYPES.MemberExpression && RESHAPING_METHODS.has(memberName(callee) ?? "") && (callee.object.type === import_utils18.AST_NODE_TYPES.CallExpression || callee.object.type === import_utils18.AST_NODE_TYPES.Identifier && namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object))) {
+            return true;
+          }
+          if (callee.type === import_utils18.AST_NODE_TYPES.Identifier && preprocessors.has(callee.name) && resolvesToTrackedImport(callee)) {
+            return true;
+          }
+        }
+        child = parent;
+        parent = child.parent;
+      }
+      return false;
+    }
+    function contradiction(chain) {
+      const allowed = chain.kind === "number" ? NUMBER_METHODS : LENGTH_METHODS;
+      let lower = null;
+      let upper = null;
+      for (const { method, node } of chain.calls) {
+        if (!allowed.has(method)) return null;
+        const value = finiteNumber(node.arguments[0]);
+        if (value === null) return null;
+        if (chain.kind !== "number" && (!Number.isInteger(value) || value < 0)) {
+          return null;
+        }
+        const label = `${method}(${String(value)})`;
+        if (method === "length") {
+          lower = strongerLower(lower, { exclusive: false, label, value });
+          upper = strongerUpper(upper, { exclusive: false, label, value });
+        } else if (method === "gt" || method === "gte" || method === "min") {
+          lower = strongerLower(lower, {
+            exclusive: method === "gt",
+            label,
+            value
+          });
+        } else {
+          upper = strongerUpper(upper, {
+            exclusive: method === "lt",
+            label,
+            value
+          });
+        }
+      }
+      return isEmpty(lower, upper) && lower !== null && upper !== null ? { lower, upper } : null;
+    }
+    return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils18.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils18.AST_NODE_TYPES.ImportDefaultSpecifier) {
+            namespaces.add(specifier.local.name);
+            importBindings.set(specifier.local.name, specifier.local);
+            continue;
+          }
+          const imported = importedName(specifier);
+          if (imported === "z") {
+            namespaces.add(specifier.local.name);
+            importBindings.set(specifier.local.name, specifier.local);
+          } else if (imported !== null && KINDS.has(imported)) {
+            constructors.set(specifier.local.name, imported);
+            importBindings.set(specifier.local.name, specifier.local);
+          } else if (imported === "preprocess") {
+            preprocessors.add(specifier.local.name);
+            importBindings.set(specifier.local.name, specifier.local);
+          }
+        }
+      },
+      CallExpression(node) {
+        if (!isOutermostCall(node) || isInsideReshapingCall(node)) return;
+        const chain = readChain(node);
+        if (chain === null) return;
+        const conflict = contradiction(chain);
+        if (conflict === null) return;
+        context.report({
+          node,
+          messageId: "impossibleBounds",
+          data: {
+            kind: chain.kind,
+            lower: conflict.lower.label,
+            upper: conflict.upper.label
+          }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/no-log-only-catch.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 
 // src/rules/_logging.ts
-var import_utils18 = require("@typescript-eslint/utils");
+var import_utils19 = require("@typescript-eslint/utils");
 var LOG_METHODS = /* @__PURE__ */ new Set([
   "debug",
   "info",
@@ -3255,29 +3545,29 @@ function createLogMatcher(options = {}) {
 // src/rules/no-log-only-catch.ts
 var BENCHMARK_DIR_RE = /(?:^|[\\/])benchmarks?[\\/]/;
 var SINGLE_STATEMENT_HOSTS = /* @__PURE__ */ new Set([
-  import_utils19.AST_NODE_TYPES.DoWhileStatement,
-  import_utils19.AST_NODE_TYPES.ForInStatement,
-  import_utils19.AST_NODE_TYPES.ForOfStatement,
-  import_utils19.AST_NODE_TYPES.ForStatement,
-  import_utils19.AST_NODE_TYPES.IfStatement,
-  import_utils19.AST_NODE_TYPES.WhileStatement
+  import_utils20.AST_NODE_TYPES.DoWhileStatement,
+  import_utils20.AST_NODE_TYPES.ForInStatement,
+  import_utils20.AST_NODE_TYPES.ForOfStatement,
+  import_utils20.AST_NODE_TYPES.ForStatement,
+  import_utils20.AST_NODE_TYPES.IfStatement,
+  import_utils20.AST_NODE_TYPES.WhileStatement
 ]);
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils19.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils19.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils19.AST_NODE_TYPES.FunctionExpression
+  import_utils20.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils20.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils20.AST_NODE_TYPES.FunctionExpression
 ]);
 function statementSlot(node) {
   const parent = node.parent;
   if (parent === void 0) return null;
   let list;
   switch (parent.type) {
-    case import_utils19.AST_NODE_TYPES.BlockStatement:
-    case import_utils19.AST_NODE_TYPES.Program:
-    case import_utils19.AST_NODE_TYPES.StaticBlock:
+    case import_utils20.AST_NODE_TYPES.BlockStatement:
+    case import_utils20.AST_NODE_TYPES.Program:
+    case import_utils20.AST_NODE_TYPES.StaticBlock:
       list = parent.body;
       break;
-    case import_utils19.AST_NODE_TYPES.SwitchCase:
+    case import_utils20.AST_NODE_TYPES.SwitchCase:
       list = parent.consequent;
       break;
     default:
@@ -3289,7 +3579,7 @@ function statementSlot(node) {
 function fallbackFollowsTry(tryStatement) {
   const body2 = tryStatement.block.body;
   const last = body2.at(-1);
-  return last?.type === import_utils19.AST_NODE_TYPES.ReturnStatement && hasFollowingStatement(tryStatement);
+  return last?.type === import_utils20.AST_NODE_TYPES.ReturnStatement && hasFollowingStatement(tryStatement);
 }
 function hasFollowingStatement(node) {
   for (let current = node; current !== void 0 && !FUNCTION_TYPES3.has(current.type); current = current.parent) {
@@ -3302,14 +3592,14 @@ function seededFallbackHandled(tryStatement, scope) {
   const slot = statementSlot(tryStatement);
   if (slot === null || slot.index === 0) return false;
   const previous = slot.list[slot.index - 1];
-  if (previous?.type !== import_utils19.AST_NODE_TYPES.VariableDeclaration || previous.kind === "const") {
+  if (previous?.type !== import_utils20.AST_NODE_TYPES.VariableDeclaration || previous.kind === "const") {
     return false;
   }
   const declarator = previous.declarations[0];
   if (previous.declarations.length !== 1 || declarator === void 0) return false;
-  if (declarator.id.type !== import_utils19.AST_NODE_TYPES.Identifier) return false;
+  if (declarator.id.type !== import_utils20.AST_NODE_TYPES.Identifier) return false;
   if (declarator.init == null || !isSeedValue(declarator.init)) return false;
-  const variable = import_utils19.ASTUtils.findVariable(scope, declarator.id.name);
+  const variable = import_utils20.ASTUtils.findVariable(scope, declarator.id.name);
   if (variable === null) return false;
   const [tryStart, tryEnd] = tryStatement.block.range;
   let writtenInTry = false;
@@ -3322,17 +3612,17 @@ function seededFallbackHandled(tryStatement, scope) {
   return writtenInTry && readAfter;
 }
 function isSeedValue(node) {
-  const inner = node.type === import_utils19.AST_NODE_TYPES.TSAsExpression ? node.expression : node;
+  const inner = node.type === import_utils20.AST_NODE_TYPES.TSAsExpression ? node.expression : node;
   switch (inner.type) {
-    case import_utils19.AST_NODE_TYPES.Literal:
+    case import_utils20.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils19.AST_NODE_TYPES.Identifier:
+    case import_utils20.AST_NODE_TYPES.Identifier:
       return inner.name === "undefined";
-    case import_utils19.AST_NODE_TYPES.UnaryExpression:
-      return inner.argument.type === import_utils19.AST_NODE_TYPES.Literal;
-    case import_utils19.AST_NODE_TYPES.ArrayExpression:
+    case import_utils20.AST_NODE_TYPES.UnaryExpression:
+      return inner.argument.type === import_utils20.AST_NODE_TYPES.Literal;
+    case import_utils20.AST_NODE_TYPES.ArrayExpression:
       return inner.elements.length === 0;
-    case import_utils19.AST_NODE_TYPES.ObjectExpression:
+    case import_utils20.AST_NODE_TYPES.ObjectExpression:
       return inner.properties.length === 0;
     default:
       return false;
@@ -3376,7 +3666,7 @@ var no_log_only_catch_default = createRule({
       const tryStatement = node.parent;
       if (hasCommentDirectlyAbove(tryStatement) || hasCommentDirectlyAbove(node)) return true;
       const block = tryStatement.parent;
-      if (block?.type !== import_utils19.AST_NODE_TYPES.BlockStatement || block.body.length !== 1 || block.parent === void 0 || !SINGLE_STATEMENT_HOSTS.has(block.parent.type)) {
+      if (block?.type !== import_utils20.AST_NODE_TYPES.BlockStatement || block.body.length !== 1 || block.parent === void 0 || !SINGLE_STATEMENT_HOSTS.has(block.parent.type)) {
         return false;
       }
       return hasCommentDirectlyAbove(block.parent);
@@ -3413,10 +3703,10 @@ var no_log_only_catch_default = createRule({
 });
 
 // src/rules/no-long-comment.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 
 // src/rules/_prose-budget.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 var DIRECTIVE_RE2 = /^(?:!|eslint\b|eslint-|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|@vite|webpack|@jsx|@jest-environment|@vitest-environment|#__|todo\b|fixme\b|hack\b)/i;
 var LICENSE_RE2 = /\b(?:copyright|spdx-license-identifier|licensed under)\b/i;
 var TYPED_TAG_RE = /@(arg|argument|param|return|returns|yield|yields)\b/i;
@@ -3485,15 +3775,15 @@ function proseGroups(filename, sourceCode, includeValueTags = false) {
   return groups;
 }
 function annotatedParameter(parameter) {
-  if (parameter.type === import_utils20.AST_NODE_TYPES.TSParameterProperty) return annotatedParameter(parameter.parameter);
-  const target = parameter.type === import_utils20.AST_NODE_TYPES.AssignmentPattern ? parameter.left : parameter;
+  if (parameter.type === import_utils21.AST_NODE_TYPES.TSParameterProperty) return annotatedParameter(parameter.parameter);
+  const target = parameter.type === import_utils21.AST_NODE_TYPES.AssignmentPattern ? parameter.left : parameter;
   return "typeAnnotation" in target && target.typeAnnotation != null;
 }
 function documentsTypedFunction(sourceCode, comment) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
   if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return false;
   let node = sourceCode.getNodeByRangeIndex(token.range[0]);
-  while (node != null && node.type !== import_utils20.AST_NODE_TYPES.Program) {
+  while (node != null && node.type !== import_utils21.AST_NODE_TYPES.Program) {
     if (typedFunction(node)) return true;
     node = node.parent ?? null;
   }
@@ -3501,19 +3791,19 @@ function documentsTypedFunction(sourceCode, comment) {
 }
 function typedFunction(node) {
   switch (node.type) {
-    case import_utils20.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils20.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils21.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils21.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration != null && typedFunction(node.declaration);
-    case import_utils20.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils20.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils21.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils21.AST_NODE_TYPES.TSDeclareFunction:
       return node.returnType != null && node.params.every(annotatedParameter);
-    case import_utils20.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils21.AST_NODE_TYPES.VariableDeclaration: {
       const init = node.declarations[0]?.init;
-      return init != null && (init.type === import_utils20.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils20.AST_NODE_TYPES.FunctionExpression) && init.returnType != null && init.params.every(annotatedParameter);
+      return init != null && (init.type === import_utils21.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils21.AST_NODE_TYPES.FunctionExpression) && init.returnType != null && init.params.every(annotatedParameter);
     }
-    case import_utils20.AST_NODE_TYPES.MethodDefinition:
+    case import_utils21.AST_NODE_TYPES.MethodDefinition:
       return node.value.returnType != null && node.value.params.every(annotatedParameter);
-    case import_utils20.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils21.AST_NODE_TYPES.TSMethodSignature:
       return node.returnType != null && node.params.every(annotatedParameter);
     default:
       return false;
@@ -3522,17 +3812,22 @@ function typedFunction(node) {
 
 // src/rules/no-long-comment.ts
 var EXCESSIVE_SENTENCE_COUNT = 8;
+var EXCESSIVE_WORD_COUNT = 120;
+var PROSE_WORD_RE = /[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu;
 var VERSIONED_DEPENDENCY_TREE_RE = /(?:^|\/)lib\/[^/]*-?v?\d+\.\d+(?:\.\d+)?[^/]*\//iu;
 function documentsTypeOrMember(sourceCode, comment) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
   if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return false;
   let node = sourceCode.getNodeByRangeIndex(token.range[0]);
-  while (node != null && node.type !== import_utils21.AST_NODE_TYPES.Program) {
-    if (node.type === import_utils21.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils21.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils21.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils21.AST_NODE_TYPES.MethodDefinition || node.type === import_utils21.AST_NODE_TYPES.TSMethodSignature || node.type === import_utils21.AST_NODE_TYPES.TSPropertySignature) return true;
+  while (node != null && node.type !== import_utils22.AST_NODE_TYPES.Program) {
+    if (node.type === import_utils22.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils22.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils22.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils22.AST_NODE_TYPES.MethodDefinition || node.type === import_utils22.AST_NODE_TYPES.TSMethodSignature || node.type === import_utils22.AST_NODE_TYPES.TSPropertySignature) return true;
     node = node.parent;
   }
   return false;
 }
+function wordUnits(text) {
+  return text.match(PROSE_WORD_RE)?.length ?? 0;
+}
 var no_long_comment_default = createRule({
   name: "no-long-comment",
   meta: {
@@ -3550,7 +3845,7 @@ var no_long_comment_default = createRule({
     return {
       Program() {
         for (const group of proseGroups(context.filename, context.sourceCode)) {
-          if (group.comment.type !== "Block" || !group.comment.value.startsWith("*") || group.hasTypedTags || hasDocumentationStructure(group.text) || hasTechnicalAnchor(group.text) || documentsTypedFunction(context.sourceCode, group.comment) || documentsTypeOrMember(context.sourceCode, group.comment) || sentenceUnits(group.text) < EXCESSIVE_SENTENCE_COUNT) continue;
+          if (group.comment.type !== "Block" || !group.comment.value.startsWith("*") || group.hasTypedTags || hasDocumentationStructure(group.text) || hasTechnicalAnchor(group.text) || documentsTypedFunction(context.sourceCode, group.comment) || documentsTypeOrMember(context.sourceCode, group.comment) || sentenceUnits(group.text) < EXCESSIVE_SENTENCE_COUNT && wordUnits(group.text) < EXCESSIVE_WORD_COUNT) continue;
           context.report({ node: group.comment, messageId: "tooLong" });
         }
       }
@@ -3559,7 +3854,7 @@ var no_long_comment_default = createRule({
 });
 
 // src/rules/no-generic-single-export-module.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 var GENERIC_STEMS = /* @__PURE__ */ new Set([
   "base",
   "common",
@@ -3594,34 +3889,34 @@ function fileParts(filename) {
 }
 function declaredNames(declaration) {
   if (declaration.declare === true) return [];
-  if (declaration.type === import_utils22.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.TSEnumDeclaration) {
-    if (declaration.type === import_utils22.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) return [];
+  if (declaration.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.TSEnumDeclaration) {
+    if (declaration.type === import_utils23.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) return [];
     return declaration.id === null ? [] : [declaration.id.name];
   }
-  if (declaration.type === import_utils22.AST_NODE_TYPES.TSModuleDeclaration && declaration.id.type === import_utils22.AST_NODE_TYPES.Identifier) {
+  if (declaration.type === import_utils23.AST_NODE_TYPES.TSModuleDeclaration && declaration.id.type === import_utils23.AST_NODE_TYPES.Identifier) {
     return [declaration.id.name];
   }
-  if (declaration.type !== import_utils22.AST_NODE_TYPES.VariableDeclaration) return [];
+  if (declaration.type !== import_utils23.AST_NODE_TYPES.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils22.AST_NODE_TYPES.Identifier ? [item.id.name] : []
+    (item) => item.id.type === import_utils23.AST_NODE_TYPES.Identifier ? [item.id.name] : []
   );
 }
 function typeOnlyBindings(program) {
   const names = /* @__PURE__ */ new Set();
   const runtimeNames = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils22.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils22.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils22.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils23.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils23.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils23.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       names.add(declaration.id.name);
       continue;
     }
-    if (declaration?.type === import_utils22.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) {
+    if (declaration?.type === import_utils23.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) {
       names.add(declaration.id.name);
       continue;
     }
-    if (statement.type === import_utils22.AST_NODE_TYPES.ImportDeclaration) {
+    if (statement.type === import_utils23.AST_NODE_TYPES.ImportDeclaration) {
       for (const specifier of statement.specifiers) {
-        if (statement.importKind === "type" || specifier.type === import_utils22.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") {
+        if (statement.importKind === "type" || specifier.type === import_utils23.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") {
           names.add(specifier.local.name);
         } else {
           runtimeNames.add(specifier.local.name);
@@ -3629,15 +3924,15 @@ function typeOnlyBindings(program) {
       }
       continue;
     }
-    if (declaration?.type === import_utils22.AST_NODE_TYPES.TSDeclareFunction && declaration.id !== null) {
+    if (declaration?.type === import_utils23.AST_NODE_TYPES.TSDeclareFunction && declaration.id !== null) {
       names.add(declaration.id.name);
       continue;
     }
     if (declaration !== null && declaration.declare === true) {
-      if ((declaration.type === import_utils22.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.TSEnumDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === import_utils22.AST_NODE_TYPES.Identifier) names.add(declaration.id.name);
-      if (declaration.type === import_utils22.AST_NODE_TYPES.VariableDeclaration) {
+      if ((declaration.type === import_utils23.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.TSEnumDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === import_utils23.AST_NODE_TYPES.Identifier) names.add(declaration.id.name);
+      if (declaration.type === import_utils23.AST_NODE_TYPES.VariableDeclaration) {
         for (const item of declaration.declarations) {
-          if (item.id.type === import_utils22.AST_NODE_TYPES.Identifier) names.add(item.id.name);
+          if (item.id.type === import_utils23.AST_NODE_TYPES.Identifier) names.add(item.id.name);
         }
       }
       continue;
@@ -3655,21 +3950,21 @@ function runtimeExports(program) {
   const typeBindings = typeOnlyBindings(program);
   let ambiguous = false;
   for (const statement of program.body) {
-    if (statement.type === import_utils22.AST_NODE_TYPES.ExportAllDeclaration) {
+    if (statement.type === import_utils23.AST_NODE_TYPES.ExportAllDeclaration) {
       if (statement.exportKind !== "type") ambiguous = true;
       continue;
     }
-    if (statement.type === import_utils22.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (statement.type === import_utils23.AST_NODE_TYPES.ExportDefaultDeclaration) {
       const declaration = statement.declaration;
-      if (declaration.type === import_utils22.AST_NODE_TYPES.Identifier) {
+      if (declaration.type === import_utils23.AST_NODE_TYPES.Identifier) {
         if (!typeBindings.has(declaration.name)) {
           exports2.push({ key: "default", name: declaration.name, node: statement });
         }
-      } else if ((declaration.type === import_utils22.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils22.AST_NODE_TYPES.ClassDeclaration) && declaration.id !== null && declaration.declare !== true) exports2.push({ key: "default", name: declaration.id.name, node: declaration });
-      else if (declaration.type !== import_utils22.AST_NODE_TYPES.TSInterfaceDeclaration && declaration.type !== import_utils22.AST_NODE_TYPES.TSTypeAliasDeclaration) ambiguous = true;
+      } else if ((declaration.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils23.AST_NODE_TYPES.ClassDeclaration) && declaration.id !== null && declaration.declare !== true) exports2.push({ key: "default", name: declaration.id.name, node: declaration });
+      else if (declaration.type !== import_utils23.AST_NODE_TYPES.TSInterfaceDeclaration && declaration.type !== import_utils23.AST_NODE_TYPES.TSTypeAliasDeclaration) ambiguous = true;
       continue;
     }
-    if (statement.type !== import_utils22.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type") continue;
+    if (statement.type !== import_utils23.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type") continue;
     if (statement.source !== null) {
       if (statement.specifiers.some((specifier) => specifier.exportKind !== "type")) ambiguous = true;
       continue;
@@ -3680,7 +3975,7 @@ function runtimeExports(program) {
     }
     for (const specifier of statement.specifiers) {
       if (specifier.exportKind === "type" || typeBindings.has(specifier.local.name)) continue;
-      const exported = specifier.exported.type === import_utils22.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+      const exported = specifier.exported.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
       const local = specifier.local.name;
       exports2.push({ key: exported, name: exported === "default" ? local : exported, node: specifier });
     }
@@ -3692,15 +3987,15 @@ function publicTypeExportCount(program) {
   const names = /* @__PURE__ */ new Set();
   const typeBindings = typeOnlyBindings(program);
   for (const statement of program.body) {
-    if (statement.type !== import_utils22.AST_NODE_TYPES.ExportNamedDeclaration) continue;
+    if (statement.type !== import_utils23.AST_NODE_TYPES.ExportNamedDeclaration) continue;
     const declaration = statement.declaration;
-    if (declaration?.type === import_utils22.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils22.AST_NODE_TYPES.TSTypeAliasDeclaration) names.add(declaration.id.name);
+    if (declaration?.type === import_utils23.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils23.AST_NODE_TYPES.TSTypeAliasDeclaration) names.add(declaration.id.name);
     for (const specifier of statement.specifiers) {
-      const local = specifier.local.type === import_utils22.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
+      const local = specifier.local.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
       if (statement.exportKind !== "type" && specifier.exportKind !== "type" && !typeBindings.has(local)) {
         continue;
       }
-      names.add(specifier.exported.type === import_utils22.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value);
+      names.add(specifier.exported.type === import_utils23.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value);
     }
   }
   return names.size;
@@ -3709,7 +4004,7 @@ function kebabCase(name) {
   return name.replaceAll(/oauth/giu, "Oauth").replaceAll(/graphql/giu, "Graphql").replaceAll(/grpc/giu, "Grpc").replaceAll(/([a-z\d])([A-Z])/gu, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/gu, "$1-$2").replaceAll(/[_\s]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/^-|-$/gu, "").toLowerCase();
 }
 function isGlobalIdentifier(context, node) {
-  const variable = import_utils22.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = import_utils23.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isConventionalFrameworkUtility(filename, exported) {
@@ -3717,8 +4012,8 @@ function isConventionalFrameworkUtility(filename, exported) {
   return exported === "cn" && /(?:^|\/)lib\/utils\.[cm]?[jt]sx?$/u.test(normalized);
 }
 function memberPropertyName(node) {
-  if (!node.computed && node.property.type === import_utils22.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils22.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (!node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 var no_generic_single_export_module_default = createRule({
   name: "no-generic-single-export-module",
@@ -3739,11 +4034,11 @@ var no_generic_single_export_module_default = createRule({
     return {
       CallExpression(node) {
         const first = node.arguments[0];
-        if (first?.type === import_utils22.AST_NODE_TYPES.Identifier && first.name === "exports" && isGlobalIdentifier(context, first) && node.callee.type === import_utils22.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils22.AST_NODE_TYPES.Identifier && node.callee.object.name === "Object" && isGlobalIdentifier(context, node.callee.object) && memberPropertyName(node.callee) !== null && CJS_OBJECT_EXPORT_METHODS.has(memberPropertyName(node.callee))) hasCommonJsExport = true;
+        if (first?.type === import_utils23.AST_NODE_TYPES.Identifier && first.name === "exports" && isGlobalIdentifier(context, first) && node.callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils23.AST_NODE_TYPES.Identifier && node.callee.object.name === "Object" && isGlobalIdentifier(context, node.callee.object) && memberPropertyName(node.callee) !== null && CJS_OBJECT_EXPORT_METHODS.has(memberPropertyName(node.callee))) hasCommonJsExport = true;
       },
       MemberExpression(node) {
-        if (node.object.type === import_utils22.AST_NODE_TYPES.Identifier && node.object.name === "exports" && isGlobalIdentifier(context, node.object)) hasCommonJsExport = true;
-        if (node.object.type === import_utils22.AST_NODE_TYPES.Identifier && node.object.name === "module" && isGlobalIdentifier(context, node.object) && memberPropertyName(node) === "exports") hasCommonJsExport = true;
+        if (node.object.type === import_utils23.AST_NODE_TYPES.Identifier && node.object.name === "exports" && isGlobalIdentifier(context, node.object)) hasCommonJsExport = true;
+        if (node.object.type === import_utils23.AST_NODE_TYPES.Identifier && node.object.name === "module" && isGlobalIdentifier(context, node.object) && memberPropertyName(node) === "exports") hasCommonJsExport = true;
       },
       "Program:exit"(program) {
         if (hasCommonJsExport) return;
@@ -3773,7 +4068,7 @@ var no_generic_single_export_module_default = createRule({
 });
 
 // src/rules/no-offset-pagination.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
 var OFFSET_GATE = /offset/i;
 var no_offset_pagination_default = createRule({
@@ -3803,25 +4098,32 @@ var no_offset_pagination_default = createRule({
 });
 
 // src/rules/no-positional-tuple-return.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var MIN_ELEMENTS = 2;
 var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited", "Readonly"]);
+function staticMemberName2(key) {
+  if (key.type === import_utils25.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils25.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
+}
 function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
-  if (node.type === import_utils24.AST_NODE_TYPES.TSTupleType) {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSTupleType) {
     return node;
   }
-  if (node.type === import_utils24.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils25.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params.at(0);
     return argument === void 0 ? null : tupleReturnType(argument, aliases, resolving);
   }
-  if (node.type === import_utils24.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && !resolving.has(node.typeName.name)) {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils25.AST_NODE_TYPES.Identifier && !resolving.has(node.typeName.name)) {
     const target = aliases.get(node.typeName.name);
     if (target !== void 0) return tupleReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
   }
-  if (node.type === import_utils24.AST_NODE_TYPES.TSTypeOperator && node.operator === "readonly") {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSTypeOperator && node.operator === "readonly") {
     return node.typeAnnotation === void 0 ? null : tupleReturnType(node.typeAnnotation, aliases, resolving);
   }
-  if (node.type === import_utils24.AST_NODE_TYPES.TSUnionType || node.type === import_utils24.AST_NODE_TYPES.TSIntersectionType) {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSUnionType || node.type === import_utils25.AST_NODE_TYPES.TSIntersectionType) {
     for (const member of node.types) {
       const tuple = tupleReturnType(member, aliases, resolving);
       if (tuple !== null) return tuple;
@@ -3830,21 +4132,21 @@ function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
   return null;
 }
 function functionName(node) {
-  if (node.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration) {
     if (node.id !== null) return node.id.name;
-    return node.parent?.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null;
+    return node.parent?.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null;
   }
   let wrapped = node;
-  while ((wrapped.parent?.type === import_utils24.AST_NODE_TYPES.TSAsExpression || wrapped.parent?.type === import_utils24.AST_NODE_TYPES.TSSatisfiesExpression || wrapped.parent?.type === import_utils24.AST_NODE_TYPES.TSNonNullExpression) && wrapped.parent.expression === wrapped) {
+  while ((wrapped.parent?.type === import_utils25.AST_NODE_TYPES.TSAsExpression || wrapped.parent?.type === import_utils25.AST_NODE_TYPES.TSSatisfiesExpression || wrapped.parent?.type === import_utils25.AST_NODE_TYPES.TSNonNullExpression) && wrapped.parent.expression === wrapped) {
     wrapped = wrapped.parent;
   }
   const parent = wrapped.parent;
-  if (parent?.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) return "default";
-  if (parent?.type === import_utils24.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils24.AST_NODE_TYPES.Identifier) {
+  if (parent?.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration) return "default";
+  if (parent?.type === import_utils25.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils25.AST_NODE_TYPES.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === import_utils24.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils24.AST_NODE_TYPES.TSAbstractMethodDefinition || parent?.type === import_utils24.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils24.AST_NODE_TYPES.Property) && parent.key.type === import_utils24.AST_NODE_TYPES.Identifier) {
-    if ((parent.type === import_utils24.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils24.AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === import_utils24.AST_NODE_TYPES.PropertyDefinition) && (parent.accessibility === "private" || parent.accessibility === "protected")) return null;
+  if ((parent?.type === import_utils25.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils25.AST_NODE_TYPES.TSAbstractMethodDefinition || parent?.type === import_utils25.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils25.AST_NODE_TYPES.Property) && parent.key.type === import_utils25.AST_NODE_TYPES.Identifier) {
+    if ((parent.type === import_utils25.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils25.AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === import_utils25.AST_NODE_TYPES.PropertyDefinition) && (parent.accessibility === "private" || parent.accessibility === "protected")) return null;
     return parent.key.name;
   }
   return null;
@@ -3853,7 +4155,7 @@ 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 === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (parent?.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -3861,39 +4163,39 @@ function isInlineExported(node) {
 }
 function moduleScopeBindingName(node) {
   let current = node;
-  while (current.parent != null && current.parent.type !== import_utils24.AST_NODE_TYPES.Program) {
+  while (current.parent != null && current.parent.type !== import_utils25.AST_NODE_TYPES.Program) {
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils24.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils25.AST_NODE_TYPES.Program) {
     return null;
   }
   let topLevel = current;
-  if (current.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration || current.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) {
+  if (current.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration || current.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration) {
     topLevel = current.declaration;
   }
   if (topLevel === null) return null;
-  if (topLevel.type === import_utils24.AST_NODE_TYPES.FunctionDeclaration) {
+  if (topLevel.type === import_utils25.AST_NODE_TYPES.FunctionDeclaration) {
     if (topLevel !== node) return null;
-    return topLevel.id?.name ?? (current.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null);
+    return topLevel.id?.name ?? (current.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null);
   }
-  if ((topLevel.type === import_utils24.AST_NODE_TYPES.ArrowFunctionExpression || topLevel.type === import_utils24.AST_NODE_TYPES.FunctionExpression) && topLevel === node && current.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) {
+  if ((topLevel.type === import_utils25.AST_NODE_TYPES.ArrowFunctionExpression || topLevel.type === import_utils25.AST_NODE_TYPES.FunctionExpression) && topLevel === node && current.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration) {
     return "default";
   }
-  if (topLevel.type === import_utils24.AST_NODE_TYPES.ClassDeclaration) {
+  if (topLevel.type === import_utils25.AST_NODE_TYPES.ClassDeclaration) {
     let owner = node.parent;
     while (owner != null && owner.parent !== topLevel.body) owner = owner.parent;
-    return (owner?.type === import_utils24.AST_NODE_TYPES.MethodDefinition || owner?.type === import_utils24.AST_NODE_TYPES.TSAbstractMethodDefinition || owner?.type === import_utils24.AST_NODE_TYPES.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null) : null;
+    return (owner?.type === import_utils25.AST_NODE_TYPES.MethodDefinition || owner?.type === import_utils25.AST_NODE_TYPES.TSAbstractMethodDefinition || owner?.type === import_utils25.AST_NODE_TYPES.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration ? "default" : null) : null;
   }
-  if (topLevel.type === import_utils24.AST_NODE_TYPES.VariableDeclaration) {
+  if (topLevel.type === import_utils25.AST_NODE_TYPES.VariableDeclaration) {
     for (const declarator of topLevel.declarations) {
       let initializer = declarator.init;
-      while (initializer?.type === import_utils24.AST_NODE_TYPES.TSAsExpression || initializer?.type === import_utils24.AST_NODE_TYPES.TSSatisfiesExpression || initializer?.type === import_utils24.AST_NODE_TYPES.TSNonNullExpression) initializer = initializer.expression;
-      if (declarator.id.type === import_utils24.AST_NODE_TYPES.Identifier && initializer === node) return declarator.id.name;
-      if (declarator.id.type === import_utils24.AST_NODE_TYPES.Identifier && (initializer?.type === import_utils24.AST_NODE_TYPES.ClassExpression || initializer?.type === import_utils24.AST_NODE_TYPES.ObjectExpression)) {
+      while (initializer?.type === import_utils25.AST_NODE_TYPES.TSAsExpression || initializer?.type === import_utils25.AST_NODE_TYPES.TSSatisfiesExpression || initializer?.type === import_utils25.AST_NODE_TYPES.TSNonNullExpression) initializer = initializer.expression;
+      if (declarator.id.type === import_utils25.AST_NODE_TYPES.Identifier && initializer === node) return declarator.id.name;
+      if (declarator.id.type === import_utils25.AST_NODE_TYPES.Identifier && (initializer?.type === import_utils25.AST_NODE_TYPES.ClassExpression || initializer?.type === import_utils25.AST_NODE_TYPES.ObjectExpression)) {
         let owner = node.parent;
-        const container = initializer.type === import_utils24.AST_NODE_TYPES.ClassExpression ? initializer.body : initializer;
+        const container = initializer.type === import_utils25.AST_NODE_TYPES.ClassExpression ? initializer.body : initializer;
         while (owner != null && owner.parent !== container) owner = owner.parent;
-        if ((owner?.type === import_utils24.AST_NODE_TYPES.MethodDefinition || owner?.type === import_utils24.AST_NODE_TYPES.PropertyDefinition || owner?.type === import_utils24.AST_NODE_TYPES.Property) && owner.value === node) return declarator.id.name;
+        if ((owner?.type === import_utils25.AST_NODE_TYPES.MethodDefinition || owner?.type === import_utils25.AST_NODE_TYPES.PropertyDefinition || owner?.type === import_utils25.AST_NODE_TYPES.Property) && owner.value === node) return declarator.id.name;
       }
     }
   }
@@ -3902,19 +4204,19 @@ function moduleScopeBindingName(node) {
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
-        if (specifier.exportKind !== "type" && specifier.local.type === import_utils24.AST_NODE_TYPES.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === import_utils25.AST_NODE_TYPES.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils24.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils25.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === import_utils24.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils24.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils25.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils25.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -3923,28 +4225,28 @@ function specifierExportedNames(program) {
 function exportedTypeNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils24.AST_NODE_TYPES.ExportNamedDeclaration || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration || statement.declaration?.type === import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration) names.add(statement.declaration.id.name);
+    if (statement.type !== import_utils25.AST_NODE_TYPES.ExportNamedDeclaration || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils25.AST_NODE_TYPES.TSInterfaceDeclaration || statement.declaration?.type === import_utils25.AST_NODE_TYPES.TSTypeAliasDeclaration) names.add(statement.declaration.id.name);
     for (const specifier of statement.specifiers) names.add(specifier.local.name);
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration && (statement.declaration.type === import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration || statement.declaration.type === import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration)) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration && (statement.declaration.type === import_utils25.AST_NODE_TYPES.TSInterfaceDeclaration || statement.declaration.type === import_utils25.AST_NODE_TYPES.TSTypeAliasDeclaration)) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function typeAliases(program) {
   const aliases = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils25.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       aliases.set(declaration.id.name, declaration.typeAnnotation);
     }
   }
   return aliases;
 }
 function callableReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
-  if (node.type === import_utils24.AST_NODE_TYPES.TSFunctionType) return node.returnType?.typeAnnotation ?? null;
-  if (node.type === import_utils24.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils24.AST_NODE_TYPES.Identifier && !resolving.has(node.typeName.name)) {
+  if (node.type === import_utils25.AST_NODE_TYPES.TSFunctionType) return node.returnType?.typeAnnotation ?? null;
+  if (node.type === import_utils25.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils25.AST_NODE_TYPES.Identifier && !resolving.has(node.typeName.name)) {
     const target = aliases.get(node.typeName.name);
     if (target !== void 0) {
       return callableReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
@@ -3956,8 +4258,8 @@ function publiclyReachableTypeNames(program, exported) {
   const names = new Set(exported);
   const interfaces = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils25.AST_NODE_TYPES.TSInterfaceDeclaration) {
       interfaces.set(declaration.id.name, declaration.extends);
     }
   }
@@ -3965,7 +4267,7 @@ function publiclyReachableTypeNames(program, exported) {
     let changed = false;
     for (const name of [...names]) {
       for (const heritage of interfaces.get(name) ?? []) {
-        if (heritage.expression.type === import_utils24.AST_NODE_TYPES.Identifier && !names.has(heritage.expression.name)) {
+        if (heritage.expression.type === import_utils25.AST_NODE_TYPES.Identifier && !names.has(heritage.expression.name)) {
           names.add(heritage.expression.name);
           changed = true;
         }
@@ -3977,37 +4279,37 @@ function publiclyReachableTypeNames(program, exported) {
 }
 function owningInterface(node) {
   for (let current = node.parent; current !== void 0; current = current.parent) {
-    if (current.type === import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration) return current;
-    if (current.type === import_utils24.AST_NODE_TYPES.Program) return null;
+    if (current.type === import_utils25.AST_NODE_TYPES.TSInterfaceDeclaration) return current;
+    if (current.type === import_utils25.AST_NODE_TYPES.Program) return null;
   }
   return null;
 }
 function owningTypeAlias(node) {
   for (let current = node.parent; current !== void 0; current = current.parent) {
-    if (current.type === import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration) return current;
-    if (current.type === import_utils24.AST_NODE_TYPES.Program) return null;
+    if (current.type === import_utils25.AST_NODE_TYPES.TSTypeAliasDeclaration) return current;
+    if (current.type === import_utils25.AST_NODE_TYPES.Program) return null;
   }
   return null;
 }
 function owningClass(node) {
   for (let current = node.parent; current !== void 0; current = current.parent) {
-    if (current.type === import_utils24.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils24.AST_NODE_TYPES.ClassExpression) {
+    if (current.type === import_utils25.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils25.AST_NODE_TYPES.ClassExpression) {
       return current;
     }
-    if (current.type === import_utils24.AST_NODE_TYPES.Program) return null;
+    if (current.type === import_utils25.AST_NODE_TYPES.Program) return null;
   }
   return null;
 }
 function isExportedClass(node, specifierExports) {
-  if (node.parent.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration) return true;
-  if (node.type === import_utils24.AST_NODE_TYPES.ClassDeclaration) {
-    return node.id !== null && node.parent.type === import_utils24.AST_NODE_TYPES.Program && specifierExports.has(node.id.name);
+  if (node.parent.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration) return true;
+  if (node.type === import_utils25.AST_NODE_TYPES.ClassDeclaration) {
+    return node.id !== null && node.parent.type === import_utils25.AST_NODE_TYPES.Program && specifierExports.has(node.id.name);
   }
-  if (node.parent.type === import_utils24.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils24.AST_NODE_TYPES.Identifier) return specifierExports.has(node.parent.id.name) || isInlineExported(node);
+  if (node.parent.type === import_utils25.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils25.AST_NODE_TYPES.Identifier) return specifierExports.has(node.parent.id.name) || isInlineExported(node);
   return false;
 }
 function isExportedInterface(node, exports2) {
-  return node.parent.type === import_utils24.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration || node.parent.type === import_utils24.AST_NODE_TYPES.Program && exports2.has(node.id.name);
+  return node.parent.type === import_utils25.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration || node.parent.type === import_utils25.AST_NODE_TYPES.Program && exports2.has(node.id.name);
 }
 function isExported(node, specifierExports) {
   if (isInlineExported(node)) {
@@ -4069,7 +4371,7 @@ var no_positional_tuple_return_default = createRule({
       ArrowFunctionExpression: check,
       TSEmptyBodyFunctionExpression: check,
       TSDeclareFunction(node) {
-        if (node.id === null || node.returnType === void 0 || node.parent.type !== import_utils24.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.type !== import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
+        if (node.id === null || node.returnType === void 0 || node.parent.type !== import_utils25.AST_NODE_TYPES.ExportNamedDeclaration && node.parent.type !== import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
         report(node.returnType.typeAnnotation, node.id.name);
       },
       TSCallSignatureDeclaration(node) {
@@ -4080,8 +4382,9 @@ var no_positional_tuple_return_default = createRule({
       TSMethodSignature(node) {
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || node.key.type !== import_utils24.AST_NODE_TYPES.Identifier) return;
-        report(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${node.key.name}`);
+        const memberName2 = staticMemberName2(node.key);
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.returnType === void 0 || memberName2 === null) return;
+        report(node.returnType.typeAnnotation, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName2}`);
       },
       TSTypeAliasDeclaration(node) {
         if (!typeExports.has(node.id.name)) return;
@@ -4092,10 +4395,11 @@ var no_positional_tuple_return_default = createRule({
         const owner = owningInterface(node);
         const alias = owningTypeAlias(node);
         const annotation = node.typeAnnotation?.typeAnnotation;
-        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || node.key.type !== import_utils24.AST_NODE_TYPES.Identifier || annotation === void 0) return;
+        const memberName2 = staticMemberName2(node.key);
+        if ((owner === null || !isExportedInterface(owner, typeExports)) && (alias === null || !typeExports.has(alias.id.name)) || memberName2 === null || annotation === void 0) return;
         const returnType = callableReturnType(annotation, aliases);
         if (returnType !== null) {
-          report(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${node.key.name}`);
+          report(returnType, `${owner?.id.name ?? alias?.id.name ?? "type"}.${memberName2}`);
         }
       },
       PropertyDefinition(node) {
@@ -4105,7 +4409,7 @@ var no_positional_tuple_return_default = createRule({
         if (owner === null || !isExportedClass(owner, specifierExports) || annotation === void 0) return;
         const returnType = callableReturnType(annotation, aliases);
         if (returnType !== null) {
-          const name = node.key.type === import_utils24.AST_NODE_TYPES.Identifier ? node.key.name : "property";
+          const name = node.key.type === import_utils25.AST_NODE_TYPES.Identifier ? node.key.name : "property";
           report(returnType, name);
         }
       }
@@ -4114,7 +4418,7 @@ var no_positional_tuple_return_default = createRule({
 });
 
 // src/rules/no-raw-env.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 var CONFIG_FILE_RE = /(^|[\\/])[\w.-]+\.config\.[cm]?[jt]sx?$/;
 var ENV_BOUNDARY_FILE_RE = /(^|[\\/])(?:env|client-env|server-env|client-settings|server-settings)\.[cm]?[jt]sx?$/;
 var ENV_VALIDATION_MARKER_RE = /\bcreateEnv\s*\(|\bz\.object\s*\(|\.(?:safeParse|parse)\s*\(/;
@@ -4191,7 +4495,7 @@ var no_raw_env_default = createRule({
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
@@ -4224,7 +4528,7 @@ function isGlobalFetchCall(node) {
 }
 function isConstructedArgumentHandoff(node) {
   const [first] = node.arguments;
-  return node.arguments.length === 1 && first !== void 0 && first.type === import_utils26.AST_NODE_TYPES.NewExpression;
+  return node.arguments.length === 1 && first !== void 0 && first.type === import_utils27.AST_NODE_TYPES.NewExpression;
 }
 function isPresignedUrlTransfer(node) {
   const first = node.arguments[0];
@@ -4302,9 +4606,9 @@ var no_raw_fetch_outside_clients_default = createRule({
 });
 
 // src/rules/no-restricted-library-load.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 function literalModule(node) {
-  return node?.type === import_utils27.AST_NODE_TYPES.Literal && typeof node.value === "string" ? node.value : null;
+  return node?.type === import_utils28.AST_NODE_TYPES.Literal && typeof node.value === "string" ? node.value : null;
 }
 function matchesModule(source, module2) {
   return source === module2 || source.startsWith(`${module2}/`);
@@ -4363,7 +4667,7 @@ var no_restricted_library_load_default = createRule({
       });
     }
     function isUnshadowedRequire(node) {
-      const variable = import_utils27.ASTUtils.findVariable(
+      const variable = import_utils28.ASTUtils.findVariable(
         context.sourceCode.getScope(node),
         node.name
       );
@@ -4376,9 +4680,9 @@ var no_restricted_library_load_default = createRule({
       },
       CallExpression(node) {
         let requireIdentifier = null;
-        if (node.callee.type === import_utils27.AST_NODE_TYPES.Identifier && node.callee.name === "require") {
+        if (node.callee.type === import_utils28.AST_NODE_TYPES.Identifier && node.callee.name === "require") {
           requireIdentifier = node.callee;
-        } else if (node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils27.AST_NODE_TYPES.Identifier && node.callee.object.name === "require" && node.callee.property.type === import_utils27.AST_NODE_TYPES.Identifier && node.callee.property.name === "resolve") {
+        } else if (node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils28.AST_NODE_TYPES.Identifier && node.callee.object.name === "require" && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier && node.callee.property.name === "resolve") {
           requireIdentifier = node.callee.object;
         }
         if (requireIdentifier === null || !isUnshadowedRequire(requireIdentifier)) return;
@@ -4386,7 +4690,7 @@ var no_restricted_library_load_default = createRule({
         if (source !== null) report(node.arguments[0], source);
       },
       TSImportEqualsDeclaration(node) {
-        if (node.moduleReference.type !== import_utils27.AST_NODE_TYPES.TSExternalModuleReference) return;
+        if (node.moduleReference.type !== import_utils28.AST_NODE_TYPES.TSExternalModuleReference) return;
         const source = literalModule(node.moduleReference.expression);
         if (source !== null) report(node.moduleReference.expression, source);
       }
@@ -4395,16 +4699,16 @@ var no_restricted_library_load_default = createRule({
 });
 
 // src/rules/no-repeated-string-literal.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 var MIN_LENGTH = 40;
 var MIN_DISTINCT_SCOPES = 2;
 var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  import_utils28.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils28.AST_NODE_TYPES.FunctionExpression,
-  import_utils28.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils29.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils29.AST_NODE_TYPES.FunctionExpression,
+  import_utils29.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -4426,8 +4730,8 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  const isRequireSource = parent.type === import_utils28.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils28.AST_NODE_TYPES.Identifier && parent.callee.name === "require";
-  return parent.type === import_utils28.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils28.AST_NODE_TYPES.ImportExpression || parent.type === import_utils28.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils28.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils28.AST_NODE_TYPES.TSImportType || parent.type === import_utils28.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils28.AST_NODE_TYPES.TSLiteralType || isRequireSource;
+  const isRequireSource = parent.type === import_utils29.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils29.AST_NODE_TYPES.Identifier && parent.callee.name === "require";
+  return parent.type === import_utils29.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils29.AST_NODE_TYPES.ImportExpression || parent.type === import_utils29.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils29.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils29.AST_NODE_TYPES.TSImportType || parent.type === import_utils29.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils29.AST_NODE_TYPES.TSLiteralType || isRequireSource;
 }
 var no_repeated_string_literal_default = createRule({
   name: "no-repeated-string-literal",
@@ -4467,7 +4771,7 @@ var no_repeated_string_literal_default = createRule({
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === import_utils28.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.parent.type === import_utils29.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -4501,7 +4805,7 @@ var no_repeated_string_literal_default = createRule({
 });
 
 // src/rules/no-restated-comment.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
 var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
@@ -4554,7 +4858,7 @@ var no_restated_comment_default = createRule({
     function labelsASiblingRun(comment) {
       const token = sourceCode.getTokenAfter(comment, { includeComments: false });
       if (token === null) return false;
-      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils29.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils30.AST_NODE_TYPES.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -4614,7 +4918,7 @@ var no_restated_comment_default = createRule({
 });
 
 // src/rules/no-restated-jsdoc.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 var MODELLED_TAGS = /* @__PURE__ */ new Set([
   "arg",
   "argument",
@@ -4668,30 +4972,30 @@ function declarationNames(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
-    case import_utils30.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils30.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils31.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils31.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case import_utils30.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils30.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils31.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils31.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case import_utils30.AST_NODE_TYPES.ClassDeclaration:
-    case import_utils30.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils30.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils30.AST_NODE_TYPES.TSEnumDeclaration:
+    case import_utils31.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils31.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils31.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils31.AST_NODE_TYPES.TSEnumDeclaration:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case import_utils30.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils31.AST_NODE_TYPES.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== import_utils30.AST_NODE_TYPES.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== import_utils31.AST_NODE_TYPES.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === import_utils30.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils30.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === import_utils31.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils31.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case import_utils30.AST_NODE_TYPES.MethodDefinition:
-    case import_utils30.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils30.AST_NODE_TYPES.TSMethodSignature:
-    case import_utils30.AST_NODE_TYPES.TSPropertySignature: {
-      if (node.key.type !== import_utils30.AST_NODE_TYPES.Identifier) return null;
-      const params = node.type === import_utils30.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils30.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
+    case import_utils31.AST_NODE_TYPES.MethodDefinition:
+    case import_utils31.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils31.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils31.AST_NODE_TYPES.TSPropertySignature: {
+      if (node.key.type !== import_utils31.AST_NODE_TYPES.Identifier) return null;
+      const params = node.type === import_utils31.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils31.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -4701,9 +5005,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === import_utils30.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
-    if (target.type === import_utils30.AST_NODE_TYPES.Identifier) names.push(target.name);
-    else if (target.type === import_utils30.AST_NODE_TYPES.TSParameterProperty) continue;
+    const target = param.type === import_utils31.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+    if (target.type === import_utils31.AST_NODE_TYPES.Identifier) names.push(target.name);
+    else if (target.type === import_utils31.AST_NODE_TYPES.TSParameterProperty) continue;
   }
   return names;
 }
@@ -4745,7 +5049,7 @@ var no_restated_jsdoc_default = createRule({
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
           let declaration = null;
-          while (node != null && node.type !== import_utils30.AST_NODE_TYPES.Program) {
+          while (node != null && node.type !== import_utils31.AST_NODE_TYPES.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -4800,7 +5104,7 @@ var no_restated_jsdoc_default = createRule({
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils31 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 
 // src/rules/_secret-names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -5094,11 +5398,11 @@ var no_secret_in_log_default = createRule({
       return true;
     }
     function reportSecretProperty(prop) {
-      const keyName2 = propertyKeyName2(prop);
-      if (keyName2 === null || !isSecretKeyword(keyName2) || !isRawSecretValue(prop)) {
+      const keyName = propertyKeyName2(prop);
+      if (keyName === null || !isSecretKeyword(keyName) || !isRawSecretValue(prop)) {
         return false;
       }
-      context.report({ node: prop, messageId: "noSecretInLog", data: { name: keyName2 } });
+      context.report({ node: prop, messageId: "noSecretInLog", data: { name: keyName } });
       return true;
     }
     function reportRawBlob(node, value) {
@@ -5137,7 +5441,7 @@ var no_secret_in_log_default = createRule({
 });
 
 // src/rules/no-select-star.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 var QUERY_SHAPE = /\bSELECT\b[\s\S]*?\bFROM\b/i;
 var SELECT_KEYWORD = /\bSELECT\b/gi;
 var FROM_KEYWORD = /^FROM\b/i;
@@ -5204,10 +5508,10 @@ var no_select_star_default = createRule({
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 function unwrapSentinelExpression(arg) {
   let current = arg;
-  while (current?.type === import_utils33.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils33.AST_NODE_TYPES.TSTypeAssertion || current?.type === import_utils33.AST_NODE_TYPES.TSSatisfiesExpression) {
+  while (current?.type === import_utils34.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils34.AST_NODE_TYPES.TSTypeAssertion || current?.type === import_utils34.AST_NODE_TYPES.TSSatisfiesExpression) {
     current = current.expression;
   }
   return current;
@@ -5217,7 +5521,7 @@ function sentinelKind(arg) {
   if (value === null) {
     return null;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils34.AST_NODE_TYPES.Literal) {
     if (value.value === null) {
       return "nullish";
     }
@@ -5229,13 +5533,13 @@ function sentinelKind(arg) {
     }
     return null;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.Identifier && value.name === "undefined") {
+  if (value.type === import_utils34.AST_NODE_TYPES.Identifier && value.name === "undefined") {
     return "nullish";
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils34.AST_NODE_TYPES.ArrayExpression) {
     return "array";
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils34.AST_NODE_TYPES.ObjectExpression) {
     return "object";
   }
   return null;
@@ -5245,25 +5549,25 @@ function isSentinelArgument(arg) {
   if (value === null) {
     return false;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.Literal && value.value === null) {
+  if (value.type === import_utils34.AST_NODE_TYPES.Literal && value.value === null) {
     return true;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.Literal && value.value === false) {
+  if (value.type === import_utils34.AST_NODE_TYPES.Literal && value.value === false) {
     return true;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.Identifier && value.name === "undefined") {
+  if (value.type === import_utils34.AST_NODE_TYPES.Identifier && value.name === "undefined") {
     return true;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.ArrayExpression && value.elements.length === 0) {
+  if (value.type === import_utils34.AST_NODE_TYPES.ArrayExpression && value.elements.length === 0) {
     return true;
   }
-  if (value.type === import_utils33.AST_NODE_TYPES.ObjectExpression && value.properties.length === 0) {
+  if (value.type === import_utils34.AST_NODE_TYPES.ObjectExpression && value.properties.length === 0) {
     return true;
   }
   return false;
 }
 function isFunctionNode(node) {
-  return node.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils33.AST_NODE_TYPES.FunctionExpression || node.type === import_utils33.AST_NODE_TYPES.ArrowFunctionExpression;
+  return node.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils34.AST_NODE_TYPES.FunctionExpression || node.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression;
 }
 function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
@@ -5303,24 +5607,24 @@ function walkWithinScope(node, visit) {
 function containsThrow(node) {
   return walkWithinScope(
     node,
-    (current) => current.type === import_utils33.AST_NODE_TYPES.ThrowStatement
+    (current) => current.type === import_utils34.AST_NODE_TYPES.ThrowStatement
   );
 }
 function bindsName(param, name) {
   switch (param.type) {
-    case import_utils33.AST_NODE_TYPES.Identifier:
+    case import_utils34.AST_NODE_TYPES.Identifier:
       return param.name === name;
-    case import_utils33.AST_NODE_TYPES.AssignmentPattern:
+    case import_utils34.AST_NODE_TYPES.AssignmentPattern:
       return bindsName(param.left, name);
-    case import_utils33.AST_NODE_TYPES.RestElement:
+    case import_utils34.AST_NODE_TYPES.RestElement:
       return bindsName(param.argument, name);
-    case import_utils33.AST_NODE_TYPES.ArrayPattern:
+    case import_utils34.AST_NODE_TYPES.ArrayPattern:
       return param.elements.some(
         (element) => element !== null && bindsName(element, name)
       );
-    case import_utils33.AST_NODE_TYPES.ObjectPattern:
+    case import_utils34.AST_NODE_TYPES.ObjectPattern:
       return param.properties.some(
-        (property) => property.type === import_utils33.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
+        (property) => property.type === import_utils34.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
       );
     default:
       return false;
@@ -5335,7 +5639,7 @@ function subtreeReadsName(node, name) {
     if (found) {
       return;
     }
-    if (current.type === import_utils33.AST_NODE_TYPES.Identifier && current.name === name) {
+    if (current.type === import_utils34.AST_NODE_TYPES.Identifier && current.name === name) {
       found = true;
       return;
     }
@@ -5346,10 +5650,10 @@ function subtreeReadsName(node, name) {
       if (key === "parent") {
         continue;
       }
-      if (key === "key" && current.type === import_utils33.AST_NODE_TYPES.Property && !current.computed) {
+      if (key === "key" && current.type === import_utils34.AST_NODE_TYPES.Property && !current.computed) {
         continue;
       }
-      if (key === "property" && current.type === import_utils33.AST_NODE_TYPES.MemberExpression && !current.computed) {
+      if (key === "property" && current.type === import_utils34.AST_NODE_TYPES.MemberExpression && !current.computed) {
         continue;
       }
       const value = current[key];
@@ -5374,10 +5678,10 @@ function argsIncludeBinding(args, caughtName) {
   return args.some((arg) => subtreeReadsName(arg, caughtName));
 }
 function isParseShapedNode(node) {
-  if (node.type === import_utils33.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils33.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils33.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils34.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils34.AST_NODE_TYPES.Identifier) {
     return node.callee.property.name === "parse";
   }
-  if (node.type === import_utils33.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils33.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils34.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils34.AST_NODE_TYPES.Identifier) {
     return SAFE_PARSE_CONSTRUCTORS.has(node.callee.name);
   }
   return false;
@@ -5388,7 +5692,7 @@ var SAFE_PARSE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "URLPattern"
 ]);
 function isBodyDecodeNode(node) {
-  return node.type === import_utils33.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils33.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils33.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
+  return node.type === import_utils34.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils34.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
 }
 var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "json",
@@ -5396,7 +5700,7 @@ var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "arrayBuffer"
 ]);
 function returnsMatching(stmt, predicate) {
-  return stmt.type === import_utils33.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
+  return stmt.type === import_utils34.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
 }
 function isNamedBooleanPredicate(catchNode, kind) {
   if (kind !== "boolean") {
@@ -5409,11 +5713,11 @@ function enclosingFunctionName(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
     if (isFunctionNode(current)) {
-      if ("id" in current && isNode3(current.id) && current.id.type === import_utils33.AST_NODE_TYPES.Identifier) {
+      if ("id" in current && isNode3(current.id) && current.id.type === import_utils34.AST_NODE_TYPES.Identifier) {
         return current.id.name;
       }
       const parent = current.parent;
-      if (parent?.type === import_utils33.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils33.AST_NODE_TYPES.Identifier) {
+      if (parent?.type === import_utils34.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils34.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
       return null;
@@ -5429,10 +5733,10 @@ function isDeclaredBooleanPredicate(catchNode, kind) {
     return false;
   }
   let declared = enclosingReturnTypeNode(catchNode);
-  if (declared?.type === import_utils33.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils33.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
+  if (declared?.type === import_utils34.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils34.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
     declared = declared.typeArguments?.params[0] ?? null;
   }
-  return declared?.type === import_utils33.AST_NODE_TYPES.TSBooleanKeyword;
+  return declared?.type === import_utils34.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function enclosingReturnTypeNode(node) {
   let current = node.parent;
@@ -5459,9 +5763,9 @@ function isIntentionalStackCapture(catchNode, caughtName) {
   if (caughtName === null) return false;
   const tryBody = tryBlockOf(catchNode).body;
   const only = tryBody.length === 1 ? tryBody[0] : void 0;
-  if (only?.type !== import_utils33.AST_NODE_TYPES.ThrowStatement) return false;
+  if (only?.type !== import_utils34.AST_NODE_TYPES.ThrowStatement) return false;
   const thrown = unwrapSentinelExpression(only.argument);
-  const constructsError = (thrown?.type === import_utils33.AST_NODE_TYPES.CallExpression || thrown?.type === import_utils33.AST_NODE_TYPES.NewExpression) && thrown.callee.type === import_utils33.AST_NODE_TYPES.Identifier && thrown.callee.name === "Error";
+  const constructsError = (thrown?.type === import_utils34.AST_NODE_TYPES.CallExpression || thrown?.type === import_utils34.AST_NODE_TYPES.NewExpression) && thrown.callee.type === import_utils34.AST_NODE_TYPES.Identifier && thrown.callee.name === "Error";
   if (!constructsError) return false;
   return catchNode.body.body.slice(0, -1).some((statement) => subtreeReadsName(statement, caughtName));
 }
@@ -5474,7 +5778,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
     return false;
   }
   return walkWithinScope(functionBody, (current) => {
-    if (current.type !== import_utils33.AST_NODE_TYPES.ReturnStatement) {
+    if (current.type !== import_utils34.AST_NODE_TYPES.ReturnStatement) {
       return false;
     }
     if (isWithin(current, catchNode.body)) {
@@ -5486,7 +5790,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
 function enclosingFunctionBody(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === import_utils33.AST_NODE_TYPES.BlockStatement) {
+    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === import_utils34.AST_NODE_TYPES.BlockStatement) {
       return current.body;
     }
     current = current.parent;
@@ -5503,13 +5807,13 @@ function returnedSentinelKinds(arg) {
     kinds.add(direct);
     return kinds;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.ConditionalExpression) {
+  if (arg.type === import_utils34.AST_NODE_TYPES.ConditionalExpression) {
     for (const branch of [arg.consequent, arg.alternate]) {
       for (const nested of returnedSentinelKinds(branch)) {
         kinds.add(nested);
       }
     }
-  } else if (arg.type === import_utils33.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
+  } else if (arg.type === import_utils34.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
     for (const nested of returnedSentinelKinds(arg.right)) {
       kinds.add(nested);
     }
@@ -5552,7 +5856,7 @@ var no_sentinel_return_on_catch_default = createRule({
     const matcher = createLogMatcher(loggingOptions);
     function logsOrReportsError(catchBody, caughtName) {
       return walkWithinScope(catchBody, (current) => {
-        if (current.type !== import_utils33.AST_NODE_TYPES.CallExpression) {
+        if (current.type !== import_utils34.AST_NODE_TYPES.CallExpression) {
           return false;
         }
         if (matcher.isLoggingCall(current)) {
@@ -5569,7 +5873,7 @@ var no_sentinel_return_on_catch_default = createRule({
           return;
         }
         const last = body2[body2.length - 1];
-        if (last === void 0 || last.type !== import_utils33.AST_NODE_TYPES.ReturnStatement) {
+        if (last === void 0 || last.type !== import_utils34.AST_NODE_TYPES.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -5578,7 +5882,7 @@ var no_sentinel_return_on_catch_default = createRule({
         if (containsThrow(node.body)) {
           return;
         }
-        const caughtName = node.param?.type === import_utils33.AST_NODE_TYPES.Identifier ? node.param.name : null;
+        const caughtName = node.param?.type === import_utils34.AST_NODE_TYPES.Identifier ? node.param.name : null;
         if (logsOrReportsError(node.body, caughtName)) {
           return;
         }
@@ -5608,9 +5912,9 @@ var no_sentinel_return_on_catch_default = createRule({
 });
 
 // src/rules/no-silent-promise-catch.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 function isBodyParseCall(node) {
-  return node.type === import_utils34.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils34.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+  return node.type === import_utils35.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils35.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils35.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -5625,11 +5929,11 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
-  return node.type === import_utils34.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils34.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils34.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
+  return node.type === import_utils35.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils35.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils35.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
 function isSilentHandler(handler) {
   const body2 = handler.body;
-  if (body2.type !== import_utils34.AST_NODE_TYPES.BlockStatement) {
+  if (body2.type !== import_utils35.AST_NODE_TYPES.BlockStatement) {
     return isSilentExpression(body2);
   }
   if (body2.body.length === 0) {
@@ -5637,7 +5941,7 @@ function isSilentHandler(handler) {
   }
   if (body2.body.length === 1) {
     const only = body2.body[0];
-    if (only !== void 0 && only.type === import_utils34.AST_NODE_TYPES.ReturnStatement) {
+    if (only !== void 0 && only.type === import_utils35.AST_NODE_TYPES.ReturnStatement) {
       return only.argument === null || isSilentExpression(only.argument);
     }
   }
@@ -5645,17 +5949,17 @@ function isSilentHandler(handler) {
 }
 function isSilentExpression(node) {
   switch (node.type) {
-    case import_utils34.AST_NODE_TYPES.Literal:
+    case import_utils35.AST_NODE_TYPES.Literal:
       return !("regex" in node);
-    case import_utils34.AST_NODE_TYPES.Identifier:
+    case import_utils35.AST_NODE_TYPES.Identifier:
       return node.name === "undefined";
-    case import_utils34.AST_NODE_TYPES.UnaryExpression:
-      return node.operator === "void" && node.argument.type === import_utils34.AST_NODE_TYPES.Literal;
-    case import_utils34.AST_NODE_TYPES.ObjectExpression:
+    case import_utils35.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils35.AST_NODE_TYPES.Literal;
+    case import_utils35.AST_NODE_TYPES.ObjectExpression:
       return node.properties.length === 0;
-    case import_utils34.AST_NODE_TYPES.ArrayExpression:
+    case import_utils35.AST_NODE_TYPES.ArrayExpression:
       return node.elements.length === 0;
-    case import_utils34.AST_NODE_TYPES.TSAsExpression:
+    case import_utils35.AST_NODE_TYPES.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
@@ -5684,7 +5988,7 @@ var no_silent_promise_catch_default = createRule({
         return true;
       }
       let statement = call;
-      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils34.AST_NODE_TYPES.VariableDeclaration) {
+      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils35.AST_NODE_TYPES.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -5696,7 +6000,7 @@ var no_silent_promise_catch_default = createRule({
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils34.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils34.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type !== import_utils35.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils35.AST_NODE_TYPES.Identifier) {
           return;
         }
         const method = node.callee.property.name;
@@ -5708,7 +6012,7 @@ var no_silent_promise_catch_default = createRule({
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === import_utils34.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
+        if (node.parent.type === import_utils35.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
           return;
         }
         const expectedArguments = method === "catch" ? 1 : 2;
@@ -5716,7 +6020,7 @@ var no_silent_promise_catch_default = createRule({
           return;
         }
         const handler = node.arguments[handlerIndex];
-        if (handler === void 0 || handler.type !== import_utils34.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils34.AST_NODE_TYPES.FunctionExpression) {
+        if (handler === void 0 || handler.type !== import_utils35.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils35.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -5731,7 +6035,7 @@ var no_silent_promise_catch_default = createRule({
 });
 
 // src/rules/no-sleep-in-test-body.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils36 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS3 = /* @__PURE__ */ new Set([
   "it",
@@ -5740,34 +6044,34 @@ var TEST_CALLERS3 = /* @__PURE__ */ new Set([
   "afterEach"
 ]);
 var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
-  import_utils35.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils35.AST_NODE_TYPES.FunctionExpression,
-  import_utils35.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils36.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils36.AST_NODE_TYPES.FunctionExpression,
+  import_utils36.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === import_utils35.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === import_utils36.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === import_utils35.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils35.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  return node.type === import_utils36.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils36.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== import_utils35.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== import_utils36.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== import_utils35.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils35.AST_NODE_TYPES.FunctionExpression) {
+  if (executor?.type !== import_utils36.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils36.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
   const body2 = executor.body;
-  if (body2.type !== import_utils35.AST_NODE_TYPES.BlockStatement) {
+  if (body2.type !== import_utils36.AST_NODE_TYPES.BlockStatement) {
     return isTimedSetTimeout(body2);
   }
   return body2.body.some(
-    (stmt) => stmt.type === import_utils35.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+    (stmt) => stmt.type === import_utils36.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === import_utils35.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === import_utils36.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
 }
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -5775,7 +6079,7 @@ function nearestEnclosingFunction2(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils35.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils36.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -5784,23 +6088,23 @@ function nearestEnclosingFunction2(node) {
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils35.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils36.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName2(call.callee);
   return name !== null && TEST_CALLERS3.has(name);
 }
 function testCallerName2(callee) {
-  if (callee.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils36.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils35.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils36.AST_NODE_TYPES.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === import_utils35.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils36.AST_NODE_TYPES.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === import_utils35.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils36.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
@@ -5845,7 +6149,7 @@ var no_sleep_in_test_body_default = createRule({
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -5864,7 +6168,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils36.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils36.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils37.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -5932,7 +6236,7 @@ var no_storage_in_stateless_modules_default = createRule({
 });
 
 // src/rules/no-string-concat-in-loop.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -6083,7 +6387,7 @@ var no_string_concat_in_loop_default = createRule({
 });
 
 // src/rules/no-tautological-expect.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
   "toBeDefined",
@@ -6097,17 +6401,17 @@ var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
 function isLiteral(node) {
   switch (node.type) {
-    case import_utils38.AST_NODE_TYPES.Literal:
+    case import_utils39.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils38.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils38.AST_NODE_TYPES.UnaryExpression:
+    case import_utils39.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
-    case import_utils38.AST_NODE_TYPES.ArrayExpression:
+    case import_utils39.AST_NODE_TYPES.ArrayExpression:
       return node.elements.every((element) => element !== null && isLiteral(element));
-    case import_utils38.AST_NODE_TYPES.ObjectExpression:
+    case import_utils39.AST_NODE_TYPES.ObjectExpression:
       return node.properties.every(
-        (property) => property.type === import_utils38.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+        (property) => property.type === import_utils39.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
       );
     default:
       return false;
@@ -6115,7 +6419,7 @@ function isLiteral(node) {
 }
 function expectOperand(callee) {
   const receiver = callee.object;
-  if (receiver.type !== import_utils38.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils38.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== import_utils39.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils39.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
     return null;
   }
   return receiver.arguments[0] ?? null;
@@ -6145,10 +6449,10 @@ var no_tautological_expect_default = createRule({
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== import_utils38.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        if (callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression || callee.computed) {
           return;
         }
-        if (callee.property.type !== import_utils38.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils39.AST_NODE_TYPES.Identifier) {
           return;
         }
         const matcher = callee.property.name;
@@ -6207,7 +6511,7 @@ var no_typed_doc_sections_default = createRule({
 });
 
 // src/rules/no-trailing-value-narration.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils40 = require("@typescript-eslint/utils");
 var NUMBER_RE = /(?<![\w.])(\d+(?:\.\d+)?)(?![\w.])/g;
 var WORD_RE3 = /[A-Za-z]+(?:'[a-z]+)?|\d+(?:\.\d+)?/g;
 var UNIT_WORDS = /* @__PURE__ */ new Set([
@@ -6342,10 +6646,10 @@ var no_trailing_value_narration_default = createRule({
 });
 
 // src/rules/no-declaration-comment-wall.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 
 // src/rules/_comment-wall.ts
-var import_utils40 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 var WALL_DEFAULTS = {
   // Below three rows "a wall" is not a fair description of what the reader sees.
   minCommentedMembers: 3,
@@ -6446,10 +6750,10 @@ function isWall(members, commented, restated, options) {
   return commented >= options.minCommentedMembers && commented / members >= options.minCommentedRatio && restated / commented >= options.minRestatedRatio;
 }
 var OPAQUE_VALUE_TYPES = /* @__PURE__ */ new Set([
-  import_utils40.AST_NODE_TYPES.FunctionExpression,
-  import_utils40.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils40.AST_NODE_TYPES.ObjectExpression,
-  import_utils40.AST_NODE_TYPES.ArrayExpression
+  import_utils41.AST_NODE_TYPES.FunctionExpression,
+  import_utils41.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils41.AST_NODE_TYPES.ObjectExpression,
+  import_utils41.AST_NODE_TYPES.ArrayExpression
 ]);
 function declarationRange(member) {
   const body2 = bodyOf(member);
@@ -6459,10 +6763,10 @@ function declarationRange(member) {
   };
 }
 function bodyOf(member) {
-  if (member.type === import_utils40.AST_NODE_TYPES.MethodDefinition || member.type === import_utils40.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+  if (member.type === import_utils41.AST_NODE_TYPES.MethodDefinition || member.type === import_utils41.AST_NODE_TYPES.TSAbstractMethodDefinition) {
     return member.value.body ?? void 0;
   }
-  if (member.type === import_utils40.AST_NODE_TYPES.Property || member.type === import_utils40.AST_NODE_TYPES.PropertyDefinition) {
+  if (member.type === import_utils41.AST_NODE_TYPES.Property || member.type === import_utils41.AST_NODE_TYPES.PropertyDefinition) {
     const value = member.value;
     if (value !== null && OPAQUE_VALUE_TYPES.has(value.type)) return value;
   }
@@ -6472,12 +6776,12 @@ function bodyOf(member) {
 // src/rules/no-declaration-comment-wall.ts
 function named(node) {
   switch (node.type) {
-    case import_utils41.AST_NODE_TYPES.TSEnumMember:
+    case import_utils42.AST_NODE_TYPES.TSEnumMember:
       return { node, key: node.id };
-    case import_utils41.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils41.AST_NODE_TYPES.TSAbstractPropertyDefinition:
-    case import_utils41.AST_NODE_TYPES.MethodDefinition:
-    case import_utils41.AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case import_utils42.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils42.AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case import_utils42.AST_NODE_TYPES.MethodDefinition:
+    case import_utils42.AST_NODE_TYPES.TSAbstractMethodDefinition:
       return node.computed ? void 0 : { node, key: node.key };
     default:
       return void 0;
@@ -6577,7 +6881,7 @@ var no_declaration_comment_wall_default = createRule({
 });
 
 // src/rules/no-union-in-comment.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var MAX_LITERAL_LENGTH = 28;
 var LITERAL = String.raw`(?:'[^'\n]*'|"[^"\n]*"|\`[^\`\n]*\`)`;
 var LEAD_IN_RE2 = /^(?:one of|either|values?|allowed(?: values)?|options?|possible(?: values)?)\s*[:=-]?\s*/i;
@@ -6596,14 +6900,14 @@ var STRING_BUILDERS = /* @__PURE__ */ new Set([
 function isBareString(node) {
   if (node === void 0) return false;
   switch (node.type) {
-    case import_utils42.AST_NODE_TYPES.TSStringKeyword:
+    case import_utils43.AST_NODE_TYPES.TSStringKeyword:
       return true;
     // `string[]` holds members of the same closed set, one element at a time.
-    case import_utils42.AST_NODE_TYPES.TSArrayType:
+    case import_utils43.AST_NODE_TYPES.TSArrayType:
       return isBareString(node.elementType);
     // `string | null` is still an unconstrained string, and so is `string | "a"`
     // — the checker collapses that one to `string`.
-    case import_utils42.AST_NODE_TYPES.TSUnionType:
+    case import_utils43.AST_NODE_TYPES.TSUnionType:
       return node.types.some((member) => isBareString(member));
     default:
       return false;
@@ -6611,20 +6915,20 @@ function isBareString(node) {
 }
 function targetOf(node) {
   switch (node.type) {
-    case import_utils42.AST_NODE_TYPES.TSPropertySignature:
-    case import_utils42.AST_NODE_TYPES.PropertyDefinition: {
+    case import_utils43.AST_NODE_TYPES.TSPropertySignature:
+    case import_utils43.AST_NODE_TYPES.PropertyDefinition: {
       const name = node.computed ? null : nameOf(node.key);
       if (name === null || !isBareString(node.typeAnnotation?.typeAnnotation)) return null;
       return { node, name };
     }
-    case import_utils42.AST_NODE_TYPES.Property: {
+    case import_utils43.AST_NODE_TYPES.Property: {
       const name = node.computed || node.shorthand ? null : nameOf(node.key);
       const callee = rootCallee(node.value);
       if (name === null || callee === null || !STRING_BUILDERS.has(callee)) return null;
       return { node, name };
     }
-    case import_utils42.AST_NODE_TYPES.VariableDeclarator: {
-      if (node.id.type !== import_utils42.AST_NODE_TYPES.Identifier) return null;
+    case import_utils43.AST_NODE_TYPES.VariableDeclarator: {
+      if (node.id.type !== import_utils43.AST_NODE_TYPES.Identifier) return null;
       if (!isBareString(node.id.typeAnnotation?.typeAnnotation)) return null;
       return { node, name: node.id.name };
     }
@@ -6636,13 +6940,13 @@ function rootCallee(node) {
   let current = node;
   for (let hops = 0; current != null && hops < 12; hops += 1) {
     switch (current.type) {
-      case import_utils42.AST_NODE_TYPES.CallExpression:
+      case import_utils43.AST_NODE_TYPES.CallExpression:
         current = current.callee;
         break;
-      case import_utils42.AST_NODE_TYPES.MemberExpression:
+      case import_utils43.AST_NODE_TYPES.MemberExpression:
         current = current.object;
         break;
-      case import_utils42.AST_NODE_TYPES.Identifier:
+      case import_utils43.AST_NODE_TYPES.Identifier:
         return current.name;
       default:
         return null;
@@ -6651,8 +6955,8 @@ function rootCallee(node) {
   return null;
 }
 function nameOf(key) {
-  if (key.type === import_utils42.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils42.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils43.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils43.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function unionLiterals(body2) {
@@ -6696,7 +7000,7 @@ var no_union_in_comment_default = createRule({
         if (after === null || after.loc.start.line !== comment.loc.end.line + 1) return null;
         anchor = sourceCode.getNodeByRangeIndex(after.range[0]);
       }
-      for (let node = anchor; node != null && node.type !== import_utils42.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = anchor; node != null && node.type !== import_utils43.AST_NODE_TYPES.Program; node = node.parent) {
         const target = targetOf(node);
         if (target !== null) return target;
       }
@@ -6725,9 +7029,9 @@ var no_union_in_comment_default = createRule({
 });
 
 // src/rules/no-type-member-comment-wall.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 function isNamedMember(node) {
-  return (node.type === import_utils43.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils43.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
+  return (node.type === import_utils44.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils44.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
 }
 var no_type_member_comment_wall_default = createRule({
   name: "no-type-member-comment-wall",
@@ -6774,7 +7078,7 @@ var no_type_member_comment_wall_default = createRule({
       return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
     }
     function check(node) {
-      const members = node.type === import_utils43.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
+      const members = node.type === import_utils44.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
       const named2 = members.filter(isNamedMember);
       if (named2.length === 0) return;
       const documented = named2.map((member) => ({ member, comment: documentingComment(member) }));
@@ -6814,7 +7118,7 @@ var no_type_member_comment_wall_default = createRule({
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -6840,13 +7144,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === import_utils44.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils45.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils44.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils45.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils44.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils45.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -6861,16 +7165,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils44.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils44.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils45.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils45.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils44.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils44.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils45.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -6910,13 +7214,13 @@ var no_unnecessary_use_client_default = createRule({
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils44.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils44.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -6926,7 +7230,7 @@ var no_unnecessary_use_client_default = createRule({
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils44.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils45.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -6939,7 +7243,7 @@ var no_unnecessary_use_client_default = createRule({
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils44.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils45.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -7006,23 +7310,19 @@ var no_unnecessary_use_client_default = createRule({
 });
 
 // src/rules/no-unsafe-mock-casting.ts
-var import_utils45 = require("@typescript-eslint/utils");
 var import_utils46 = require("@typescript-eslint/utils");
-function isMockTypeReference(node) {
-  if (node.type !== import_utils46.AST_NODE_TYPES.TSTypeReference) {
-    return false;
-  }
-  const typeName = node.typeName;
-  if (typeName.type === import_utils46.AST_NODE_TYPES.Identifier) {
-    const name = typeName.name;
-    return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
-  }
-  if (typeName.type === import_utils46.AST_NODE_TYPES.TSQualifiedName) {
-    const rightName = typeName.right.name;
-    return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
-  }
-  return false;
-}
+var MOCK_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "Mock",
+  "MockInstance",
+  "SpyInstance"
+]);
+var MOCK_MODULES = /* @__PURE__ */ new Set([
+  "vitest",
+  "@vitest/spy",
+  "jest",
+  "jest-mock",
+  "@jest/globals"
+]);
 var no_unsafe_mock_casting_default = createRule({
   name: "no-unsafe-mock-casting",
   meta: {
@@ -7040,12 +7340,49 @@ var no_unsafe_mock_casting_default = createRule({
     if (isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
+    const directBindings = /* @__PURE__ */ new Set();
+    const namespaceBindings = /* @__PURE__ */ new Set();
+    function resolve(identifier) {
+      return import_utils46.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function record(identifier, destination) {
+      const binding = resolve(identifier);
+      if (binding !== null) destination.add(binding);
+    }
+    function isMockTypeReference(node) {
+      if (node.type !== import_utils46.AST_NODE_TYPES.TSTypeReference) return false;
+      const typeName = node.typeName;
+      if (typeName.type === import_utils46.AST_NODE_TYPES.Identifier) {
+        const binding = resolve(typeName);
+        return binding !== null && directBindings.has(binding);
+      }
+      if (typeName.type === import_utils46.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === import_utils46.AST_NODE_TYPES.Identifier && MOCK_TYPE_NAMES.has(typeName.right.name)) {
+        const binding = resolve(typeName.left);
+        return binding !== null && namespaceBindings.has(binding);
+      }
+      return false;
+    }
     function checkAssertion(node) {
       if (isMockTypeReference(node.typeAnnotation)) {
         context.report({ node, messageId: "unsafeMockCast" });
       }
     }
     return {
+      ImportDeclaration(node) {
+        if (!MOCK_MODULES.has(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils46.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            record(specifier.local, namespaceBindings);
+          } else if (specifier.type === import_utils46.AST_NODE_TYPES.ImportSpecifier && MOCK_TYPE_NAMES.has(
+            specifier.imported.type === import_utils46.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value
+          )) {
+            record(specifier.local, directBindings);
+          }
+        }
+      },
       TSAsExpression: checkAssertion,
       TSTypeAssertion: checkAssertion
     };
@@ -7067,7 +7404,7 @@ function isIgnoredFile(filename, sourceText) {
   }
   return /@generated\b/.test(sourceText.slice(0, 1024));
 }
-function isZodModule(source) {
+function isZodModule2(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap2(node) {
@@ -7152,9 +7489,10 @@ var no_zod_native_enum_default = createRule({
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
+    const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils47.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils47.AST_NODE_TYPES.Identifier && zodNamespaces.has(callee.object.name) && callee.property.type === import_utils47.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
       if (callee.type === import_utils47.AST_NODE_TYPES.Identifier) {
@@ -7188,10 +7526,13 @@ var no_zod_native_enum_default = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (!isZodModule(node.source.value)) {
+        if (!isZodModule2(node.source.value)) {
           return;
         }
         for (const spec of node.specifiers) {
+          if (spec.type === import_utils47.AST_NODE_TYPES.ImportNamespaceSpecifier || spec.type === import_utils47.AST_NODE_TYPES.ImportDefaultSpecifier || spec.type === import_utils47.AST_NODE_TYPES.ImportSpecifier && (spec.imported.type === import_utils47.AST_NODE_TYPES.Identifier ? spec.imported.name === "z" : spec.imported.value === "z")) {
+            zodNamespaces.add(spec.local.name);
+          }
           if (spec.type === import_utils47.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils47.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
@@ -7210,10 +7551,12 @@ var no_zod_native_enum_default = createRule({
         if (!isZodMemberCall(node, "enum")) {
           return;
         }
-        const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils47.AST_NODE_TYPES.Identifier) {
+        const argument = node.arguments[0];
+        if (argument === void 0 || argument.type === import_utils47.AST_NODE_TYPES.SpreadElement) {
           return;
         }
+        const arg = unwrap2(argument);
+        if (arg.type !== import_utils47.AST_NODE_TYPES.Identifier) return;
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
         if (isEnum) {
           context.report({
@@ -7252,7 +7595,7 @@ function rootIdentifier3(callee) {
   if (callee.type === import_utils48.AST_NODE_TYPES.TaggedTemplateExpression) return rootIdentifier3(callee.tag);
   return null;
 }
-function staticMemberName2(member) {
+function staticMemberName3(member) {
   if (!member.computed && member.property.type === import_utils48.AST_NODE_TYPES.Identifier) return member.property.name;
   if (member.computed && member.property.type === import_utils48.AST_NODE_TYPES.Literal && typeof member.property.value === "string") {
     return member.property.value;
@@ -7267,7 +7610,7 @@ function isTestBody3(node, isFrameworkTest) {
 function isTestCaller(callee) {
   if (callee.type === import_utils48.AST_NODE_TYPES.Identifier) return TEST_CALLERS4.has(callee.name);
   if (callee.type !== import_utils48.AST_NODE_TYPES.MemberExpression) return false;
-  const member = staticMemberName2(callee);
+  const member = staticMemberName3(callee);
   return member !== null && TEST_MODIFIERS2.has(member) && isTestCaller(callee.object);
 }
 function nearestEnclosingFunction3(node) {
@@ -7348,7 +7691,7 @@ function opensSubtest(node, callbackParameters) {
     return false;
   }
   const callee = node.callee;
-  return callee.type === import_utils48.AST_NODE_TYPES.MemberExpression && staticMemberName2(callee) === "test" && callee.object.type === import_utils48.AST_NODE_TYPES.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
+  return callee.type === import_utils48.AST_NODE_TYPES.MemberExpression && staticMemberName3(callee) === "test" && callee.object.type === import_utils48.AST_NODE_TYPES.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
     (argument) => argument.type !== import_utils48.AST_NODE_TYPES.SpreadElement && FUNCTION_TYPES6.has(argument.type)
   );
 }
@@ -7648,9 +7991,9 @@ var import_utils52 = require("@typescript-eslint/utils");
 var INPUT_MODULE = /(?:^|\/)components\/ui\/input$/u;
 var INPUT_GROUP_MODULE = /(?:^|\/)components\/ui\/input-group$/u;
 var MAX_JSX_DISTANCE = 2;
-function localNamedImports(node, importedName) {
+function localNamedImports(node, importedName2) {
   return node.specifiers.filter(
-    (specifier) => specifier.type === import_utils52.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils52.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName
+    (specifier) => specifier.type === import_utils52.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils52.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName2
   ).map((specifier) => specifier.local.name);
 }
 function elementName(node) {
@@ -8380,16 +8723,6 @@ var prefer_module_level_constant_default = createRule({
 
 // src/rules/prefer-module-level-schema.ts
 var import_utils56 = require("@typescript-eslint/utils");
-
-// src/rules/_zod.ts
-var ZOD_PREFIX_RE = /^Z[A-Z]/;
-var ZOD_SUFFIX_RE = /Schema$/;
-var ZOD_SCHEMA_NAME_RE = /Schema$|^Z[A-Z]/;
-function isZodModule2(source) {
-  return /(^|[/@-])zod([/-]|$)/.test(source);
-}
-
-// src/rules/prefer-module-level-schema.ts
 var DEFAULT_FACTORIES = [
   "discriminatedUnion",
   "intersection",
@@ -8554,6 +8887,11 @@ var prefer_module_level_schema_default = createRule({
             type: "boolean",
             description: "Skip test files, where a fixture schema belongs next to its assertion."
           },
+          memoCallees: {
+            type: "array",
+            items: { type: "string" },
+            description: "Wrappers that construct their callback at most once. Defaults to lazy, memo, once, and useMemo."
+          },
           minProperties: {
             type: "number",
             minimum: 0,
@@ -8571,6 +8909,7 @@ var prefer_module_level_schema_default = createRule({
   create(context, [options]) {
     const factories = new Set(options?.factories ?? DEFAULT_FACTORIES);
     const ignoreTestFiles = options?.ignoreTestFiles ?? true;
+    const memoCallees = new Set(options?.memoCallees ?? MEMO_CALLEES);
     const minProperties = options?.minProperties ?? DEFAULT_MIN_PROPERTIES;
     const sourceCode = context.sourceCode;
     const filename = context.filename;
@@ -8590,7 +8929,7 @@ var prefer_module_level_schema_default = createRule({
         if (current !== node && isZodCall(current) && current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === import_utils56.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils56.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === import_utils56.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils56.AST_NODE_TYPES.Identifier && memoCallees.has(current.callee.name) || current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && memoCallees.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -8640,6 +8979,9 @@ var prefer_module_level_schema_default = createRule({
           if (definition.type === "ImportBinding") {
             continue;
           }
+          if (definition.node.type === import_utils56.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils56.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const") {
+            return false;
+          }
           const [defStart, defEnd] = definition.node.range;
           if (defStart >= schemaStart && defEnd <= schemaEnd) {
             continue;
@@ -8666,7 +9008,7 @@ var prefer_module_level_schema_default = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (!isZodModule2(node.source.value)) {
+        if (!isZodModule(node.source.value)) {
           return;
         }
         for (const specifier of node.specifiers) {
@@ -8874,7 +9216,7 @@ function sameAccess(node, access) {
   return node.type === import_utils58.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils58.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils58.AST_NODE_TYPES.Identifier && node.property.name === access.property;
 }
 function isNullGuard(node, access) {
-  if (node.type === import_utils58.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && sameAccess(node.argument, access)) return true;
+  if (node.type === import_utils58.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
   if (node.type !== import_utils58.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
@@ -8890,7 +9232,11 @@ function isEmptyGuard(node, access) {
   return memberLengthOf(node.left, access) && zero(node.right) || memberLengthOf(node.right, access) && zero(node.left);
 }
 function memberLengthOf(node, access) {
-  return node.type === import_utils58.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils58.AST_NODE_TYPES.Identifier && node.property.name === "length" && sameAccess(node.object, access);
+  const target = node.type === import_utils58.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+  return target.type === import_utils58.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils58.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+}
+function optionalMemberLengthOf(node, access) {
+  return node.type === import_utils58.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils58.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
   if (fn.body.type !== import_utils58.AST_NODE_TYPES.BlockStatement) return false;
@@ -8898,6 +9244,7 @@ function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
   if (first?.type !== import_utils58.AST_NODE_TYPES.IfStatement) return false;
   const terminating = first.consequent.type === import_utils58.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils58.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils58.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils58.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils58.AST_NODE_TYPES.ThrowStatement);
   if (!terminating) return false;
+  if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
   return contains(first.test, visitorKeys, (node) => isNullGuard(node, access)) && contains(first.test, visitorKeys, (node) => isEmptyGuard(node, access));
 }
 function contains(node, visitorKeys, predicate) {
@@ -9977,13 +10324,13 @@ function getPropertyNode(objNode, propName2) {
   if (!objNode || objNode.type !== "ObjectExpression") return null;
   for (const prop of objNode.properties) {
     if (prop.type !== "Property") continue;
-    let keyName2 = null;
+    let keyName = null;
     if (prop.key.type === "Identifier" && !prop.computed) {
-      keyName2 = prop.key.name;
+      keyName = prop.key.name;
     } else if (prop.key.type === "Literal" && typeof prop.key.value === "string") {
-      keyName2 = prop.key.value;
+      keyName = prop.key.value;
     }
-    if (keyName2 === propName2) {
+    if (keyName === propName2) {
       if (prop.value.type === "AssignmentPattern" || prop.value.type === "ArrayPattern" || prop.value.type === "ObjectPattern") {
         return null;
       }
@@ -10061,370 +10408,8 @@ var prefer_server_actions_default = createRule({
   }
 });
 
-// src/rules/prefer-string-literal-union.ts
+// src/rules/prefer-whole-object-assertion.ts
 var import_utils62 = require("@typescript-eslint/utils");
-var ts2 = __toESM(require("typescript"), 1);
-var CHOICE_TOKENS = /* @__PURE__ */ new Set([
-  "status",
-  "state",
-  "kind",
-  "role",
-  "priority",
-  "severity",
-  "direction",
-  "tier",
-  "stage",
-  "type",
-  "mode",
-  "level"
-]);
-var LOWER_TOKEN_RE = /^[a-z][a-z0-9_-]{0,30}$/;
-var MIN_CLUSTER_SIZE = 2;
-var BOOLEANISH = /* @__PURE__ */ new Set(["true", "false"]);
-function isEnumToken(lit) {
-  return LOWER_TOKEN_RE.test(lit) && lit.length >= 2 && !BOOLEANISH.has(lit);
-}
-var IGNORE_PATTERNS3 = [
-  /[\\/]generated[\\/]/,
-  /\.gen\.tsx?$/,
-  /\.generated\.tsx?$/,
-  /\.d\.ts$/
-];
-function isIgnoredFile3(filename, sourceText) {
-  if (IGNORE_PATTERNS3.some((re) => re.test(filename))) {
-    return true;
-  }
-  return /@generated\b/.test(sourceText.slice(0, 1024));
-}
-function isChoiceLikeName(name) {
-  return CHOICE_TOKENS.has(lastWord(name));
-}
-function lastWord(name) {
-  const words = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[_\s]+/).filter((w) => w.length > 0);
-  const last = words[words.length - 1] ?? name;
-  return last.toLowerCase();
-}
-function keyName(key) {
-  if (key.type === import_utils62.AST_NODE_TYPES.Identifier) {
-    return key.name;
-  }
-  if (key.type === import_utils62.AST_NODE_TYPES.Literal && typeof key.value === "string") {
-    return key.value;
-  }
-  return null;
-}
-function isStringLiteralMember(t) {
-  return t.type === import_utils62.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils62.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
-}
-function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils62.AST_NODE_TYPES.TSUnionType) {
-    return false;
-  }
-  return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
-}
-function typeHasRawString(type) {
-  const parts = type.isUnion() ? type.types : [type];
-  return parts.some((t) => (t.flags & ts2.TypeFlags.String) !== 0);
-}
-function isExternalSourceFile(sf) {
-  if (sf === void 0) {
-    return false;
-  }
-  return sf.isDeclarationFile || sf.fileName.includes("/node_modules/");
-}
-function symbolIsExternallyDeclared(sym) {
-  return sym?.declarations?.some((d) => isExternalSourceFile(d.getSourceFile())) ?? false;
-}
-function bindingSourceExpression(decl) {
-  let node = decl.parent;
-  while (!ts2.isForOfStatement(node) && !(ts2.isVariableDeclaration(node) && node.initializer !== void 0)) {
-    if (node.parent === void 0) {
-      return void 0;
-    }
-    node = node.parent;
-  }
-  return ts2.isForOfStatement(node) ? node.expression : node.initializer;
-}
-function refKey(node) {
-  if (node.type === import_utils62.AST_NODE_TYPES.Identifier) {
-    return node.name;
-  }
-  if (node.type === import_utils62.AST_NODE_TYPES.MemberExpression && !node.computed) {
-    const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils62.AST_NODE_TYPES.Identifier) {
-      return null;
-    }
-    return `${inner}.${node.property.name}`;
-  }
-  return null;
-}
-function strLiteral(node) {
-  if (node.type === import_utils62.AST_NODE_TYPES.Literal && typeof node.value === "string") {
-    return node.value;
-  }
-  return null;
-}
-var prefer_string_literal_union_default = createRule({
-  name: "prefer-string-literal-union",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Flag raw `string` choice fields and string-literal comparison clusters; prefer a string-literal union type."
-    },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          ignoreFields: {
-            type: "array",
-            items: { type: "string" }
-          }
-        }
-      }
-    ],
-    messages: {
-      bareChoiceField: '`{{name}}: string` looks like a choice field \u2014 prefer a string-literal union type (e.g. `type X = "a" | "b"`). Enums are banned by `no-enum`; use a union.',
-      comparisonCluster: '`{{key}}` is compared against a closed set of string literals \u2014 define a string-literal union type (e.g. `type X = "a" | "b"`).'
-    }
-  },
-  defaultOptions: [{}],
-  create(context, [optionsArg]) {
-    const filename = context.filename;
-    const sourceText = context.sourceCode.getText();
-    if (isIgnoredFile3(filename, sourceText)) {
-      return {};
-    }
-    const ignoredFields = new Set(
-      (optionsArg?.ignoreFields ?? []).map((name) => name.toLowerCase())
-    );
-    let services;
-    try {
-      services = import_utils62.ESLintUtils.getParserServices(context);
-    } catch {
-      services = null;
-    }
-    const scopeStack = [];
-    const validClusters = [];
-    const bareChoiceProps = [];
-    const containersWithUnion = /* @__PURE__ */ new Set();
-    function operandIsRawString(node) {
-      if (services === null) {
-        return false;
-      }
-      return typeHasRawString(services.getTypeAtLocation(node));
-    }
-    function parameterRoot(node) {
-      if (services === null) return false;
-      const checker = services.program.getTypeChecker();
-      let current = services.esTreeNodeToTSNodeMap.get(node);
-      while (ts2.isPropertyAccessExpression(current)) current = current.expression;
-      if (!ts2.isIdentifier(current)) return false;
-      let declaration = checker.getSymbolAtLocation(current)?.valueDeclaration;
-      while (declaration !== void 0 && (ts2.isBindingElement(declaration) || ts2.isObjectBindingPattern(declaration) || ts2.isArrayBindingPattern(declaration))) {
-        declaration = declaration.parent;
-      }
-      return declaration !== void 0 && ts2.isParameter(declaration);
-    }
-    function originIsExternal(node, depth) {
-      if (node === void 0 || services === null || depth > 6) {
-        return false;
-      }
-      const checker = services.program.getTypeChecker();
-      if (ts2.isParenthesizedExpression(node) || ts2.isNonNullExpression(node) || ts2.isAsExpression(node)) {
-        return originIsExternal(node.expression, depth + 1);
-      }
-      if (ts2.isPropertyAccessExpression(node)) {
-        return symbolIsExternallyDeclared(checker.getSymbolAtLocation(node.name));
-      }
-      if (ts2.isCallExpression(node)) {
-        return originIsExternal(node.expression, depth + 1);
-      }
-      if (ts2.isIdentifier(node)) {
-        const decl = checker.getSymbolAtLocation(node)?.valueDeclaration;
-        if (decl === void 0) {
-          return false;
-        }
-        if (ts2.isVariableDeclaration(decl) && decl.initializer !== void 0) {
-          return originIsExternal(decl.initializer, depth + 1);
-        }
-        if (ts2.isBindingElement(decl)) {
-          return originIsExternal(bindingSourceExpression(decl), depth + 1);
-        }
-      }
-      return false;
-    }
-    function operandIsFlaggable(node) {
-      return operandIsRawString(node) && parameterRoot(node) && !originIsExternal(services?.esTreeNodeToTSNodeMap.get(node), 0);
-    }
-    function declaredReturnLiterals(fn) {
-      const annotation = fn.returnType?.typeAnnotation;
-      if (annotation === void 0 || services === null) {
-        return null;
-      }
-      const tsNode = services.esTreeNodeToTSNodeMap.get(annotation);
-      if (!ts2.isTypeNode(tsNode)) {
-        return null;
-      }
-      const checker = services.program.getTypeChecker();
-      const declared = checker.getTypeFromTypeNode(tsNode);
-      const type = checker.getAwaitedType(declared) ?? declared;
-      const literals = /* @__PURE__ */ new Set();
-      for (const part of type.isUnion() ? type.types : [type]) {
-        if (part.isStringLiteral()) {
-          literals.add(part.value);
-        }
-      }
-      return literals.size >= MIN_CLUSTER_SIZE ? literals : null;
-    }
-    function pushScope(node) {
-      scopeStack.push({ clusters: /* @__PURE__ */ new Map(), fn: node });
-    }
-    function popScope() {
-      const scope = scopeStack.pop();
-      if (scope === void 0) {
-        return;
-      }
-      const candidates = [...scope.clusters.values()].filter(
-        (entry) => entry.allTokens && entry.literals.size >= MIN_CLUSTER_SIZE
-      );
-      if (candidates.length === 0) {
-        return;
-      }
-      const returnLiterals = scope.fn === null ? null : declaredReturnLiterals(scope.fn);
-      for (const entry of candidates) {
-        if (returnLiterals !== null && [...entry.literals].every((lit) => returnLiterals.has(lit))) {
-          continue;
-        }
-        validClusters.push(entry.node);
-      }
-    }
-    function accumulate(key, literals, node) {
-      const scope = scopeStack[scopeStack.length - 1];
-      if (scope === void 0) {
-        return;
-      }
-      const allTokens = literals.every((lit) => isEnumToken(lit));
-      const existing = scope.clusters.get(key);
-      if (existing === void 0) {
-        scope.clusters.set(key, {
-          node,
-          literals: new Set(literals),
-          allTokens
-        });
-        return;
-      }
-      for (const lit of literals) {
-        existing.literals.add(lit);
-      }
-      existing.allTokens = existing.allTokens && allTokens;
-    }
-    function collectProperty(key, typeNode, container, node) {
-      if (isStringLiteralUnion(typeNode)) {
-        containersWithUnion.add(container);
-        return;
-      }
-      if (typeNode?.type !== import_utils62.AST_NODE_TYPES.TSStringKeyword) {
-        return;
-      }
-      const name = keyName(key);
-      if (name === null || !isChoiceLikeName(name) || ignoredFields.has(name.toLowerCase())) {
-        return;
-      }
-      bareChoiceProps.push({ name, container, node });
-    }
-    return {
-      FunctionDeclaration: pushScope,
-      "FunctionDeclaration:exit": popScope,
-      FunctionExpression: pushScope,
-      "FunctionExpression:exit": popScope,
-      ArrowFunctionExpression: pushScope,
-      "ArrowFunctionExpression:exit": popScope,
-      BinaryExpression(node) {
-        if (node.operator !== "===" && node.operator !== "!==" && node.operator !== "==" && node.operator !== "!=") {
-          return;
-        }
-        const leftKey = refKey(node.left);
-        const rightLit = strLiteral(node.right);
-        const rightKey = refKey(node.right);
-        const leftLit = strLiteral(node.left);
-        if (leftKey !== null && rightLit !== null) {
-          if (operandIsFlaggable(node.left)) {
-            accumulate(leftKey, [rightLit], node);
-          }
-        } else if (rightKey !== null && leftLit !== null) {
-          if (operandIsFlaggable(node.right)) {
-            accumulate(rightKey, [leftLit], node);
-          }
-        }
-      },
-      SwitchStatement(node) {
-        const key = refKey(node.discriminant);
-        if (key === null || !operandIsFlaggable(node.discriminant)) {
-          return;
-        }
-        const literals = [];
-        for (const c of node.cases) {
-          if (c.test !== null) {
-            const lit = strLiteral(c.test);
-            if (lit !== null) {
-              literals.push(lit);
-            }
-          }
-        }
-        if (literals.length > 0) {
-          accumulate(key, literals, node);
-        }
-      },
-      TSPropertySignature(node) {
-        collectProperty(
-          node.key,
-          node.typeAnnotation?.typeAnnotation,
-          node.parent,
-          node
-        );
-      },
-      PropertyDefinition(node) {
-        collectProperty(
-          node.key,
-          node.typeAnnotation?.typeAnnotation,
-          node.parent,
-          node
-        );
-      },
-      "Program:exit"() {
-        for (const clusterNode of validClusters) {
-          context.report({
-            node: clusterNode,
-            messageId: "comparisonCluster",
-            data: { key: refKeyText(clusterNode) }
-          });
-        }
-        for (const prop of bareChoiceProps) {
-          if (containersWithUnion.has(prop.container)) {
-            context.report({
-              node: prop.node,
-              messageId: "bareChoiceField",
-              data: { name: prop.name }
-            });
-          }
-        }
-      }
-    };
-    function refKeyText(node) {
-      if (node.type === import_utils62.AST_NODE_TYPES.BinaryExpression) {
-        return refKey(node.left) ?? refKey(node.right) ?? "value";
-      }
-      if (node.type === import_utils62.AST_NODE_TYPES.SwitchStatement) {
-        return refKey(node.discriminant) ?? "value";
-      }
-      return "value";
-    }
-  }
-});
-
-// src/rules/prefer-whole-object-assertion.ts
-var import_utils63 = require("@typescript-eslint/utils");
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ARRAY_MATCHERS = /* @__PURE__ */ new Set(["toEqual", "toStrictEqual"]);
 var COLLECTION_PROPERTIES = /* @__PURE__ */ new Set(["length", "size"]);
@@ -10433,11 +10418,11 @@ var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
 var MIN_RUN_LENGTH = 2;
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils63.AST_NODE_TYPES.Literal:
+    case import_utils62.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils63.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils62.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils63.AST_NODE_TYPES.UnaryExpression:
+    case import_utils62.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -10445,15 +10430,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils63.AST_NODE_TYPES.Identifier:
-    case import_utils63.AST_NODE_TYPES.ThisExpression:
+    case import_utils62.AST_NODE_TYPES.Identifier:
+    case import_utils62.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils63.AST_NODE_TYPES.MemberExpression:
+    case import_utils62.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils63.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils62.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -10461,7 +10446,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils63.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils62.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -10487,24 +10472,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils63.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils62.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils63.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils62.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils63.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils63.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils62.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils62.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils63.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils63.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils62.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils62.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== import_utils63.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils62.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -10518,7 +10503,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         key = { kind: "index", index };
       } else {
-        if (actual.property.type !== import_utils63.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
+        if (actual.property.type !== import_utils62.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
           return null;
         }
         key = { kind: "property", name: actual.property.name };
@@ -10530,7 +10515,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils63.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils62.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -10644,99 +10629,8 @@ var prefer_whole_object_assertion_default = createRule({
   }
 });
 
-// src/rules/prefer-zod-enum.ts
-var import_utils64 = require("@typescript-eslint/utils");
-var prefer_zod_enum_default = createRule({
-  name: "prefer-zod-enum",
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer z.enum([...]) over z.union([z.literal(...), ...]) for string choices"
-    },
-    fixable: "code",
-    schema: [],
-    messages: {
-      preferEnum: "Use `z.enum([...])` instead of a union of string-literal schemas."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const zodNamespaces = /* @__PURE__ */ new Set();
-    function enumValues(node) {
-      const callee = node.callee;
-      if (callee.type !== import_utils64.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils64.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils64.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
-        return null;
-      }
-      const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils64.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
-        return null;
-      }
-      const values = [];
-      let canFix = true;
-      for (const element of argument.elements) {
-        if (element?.type === import_utils64.AST_NODE_TYPES.SpreadElement) {
-          canFix = false;
-          continue;
-        }
-        if (element === null || element.type !== import_utils64.AST_NODE_TYPES.CallExpression || element.callee.type !== import_utils64.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils64.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils64.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
-          return null;
-        }
-        const value = element.arguments[0];
-        if (element.arguments.length !== 1 || value === void 0 || value.type !== import_utils64.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
-          canFix = false;
-          continue;
-        }
-        values.push(value);
-      }
-      return canFix ? values : void 0;
-    }
-    function buildFix(node, values) {
-      const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils64.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
-        return void 0;
-      }
-      const callee = node.callee;
-      if (callee.type !== import_utils64.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils64.AST_NODE_TYPES.Identifier) {
-        return void 0;
-      }
-      return (fixer) => [
-        fixer.replaceText(callee.property, "enum"),
-        fixer.replaceText(
-          argument,
-          `[${values.map((value) => sourceCode.getText(value)).join(", ")}]`
-        )
-      ];
-    }
-    return {
-      ImportDeclaration(node) {
-        if (!isZodModule2(node.source.value)) {
-          return;
-        }
-        for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils64.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils64.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils64.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils64.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
-            zodNamespaces.add(specifier.local.name);
-          }
-        }
-      },
-      CallExpression(node) {
-        const values = enumValues(node);
-        if (values === null) {
-          return;
-        }
-        const fix = values === void 0 ? void 0 : buildFix(node, values);
-        context.report({
-          node,
-          messageId: "preferEnum",
-          ...fix === void 0 ? {} : { fix }
-        });
-      }
-    };
-  }
-});
-
 // src/rules/prefer-zod-infer.ts
-var import_utils65 = require("@typescript-eslint/utils");
+var import_utils63 = require("@typescript-eslint/utils");
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -10758,7 +10652,8 @@ var RESHAPING_MODIFIERS = /* @__PURE__ */ new Set([
   "pipe",
   "preprocess",
   "brand",
-  "overwrite"
+  "overwrite",
+  "readonly"
 ]);
 var MODULE_LEVEL_RESHAPERS = /* @__PURE__ */ new Set([
   "transform",
@@ -10773,44 +10668,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils65.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils65.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils65.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils65.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils65.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils65.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils65.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils65.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils65.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils65.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils65.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils65.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils65.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils65.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils65.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils65.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils65.AST_NODE_TYPES.TSArrayType, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils65.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils65.AST_NODE_TYPES.TSTypeLiteral, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils65.AST_NODE_TYPES.TSTypeLiteral, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils65.AST_NODE_TYPES.TSTypeLiteral, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils65.AST_NODE_TYPES.TSTypeReference, import_utils65.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils65.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils65.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils65.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils65.AST_NODE_TYPES.TSUnionType, import_utils65.AST_NODE_TYPES.TSTypeReference, import_utils65.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils65.AST_NODE_TYPES.TSUnionType, import_utils65.AST_NODE_TYPES.TSTypeReference, import_utils65.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils65.AST_NODE_TYPES.TSUnionType, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils65.AST_NODE_TYPES.TSUnionType, import_utils65.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils65.AST_NODE_TYPES.TSIntersectionType, import_utils65.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils63.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils63.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils63.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils63.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils63.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils63.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils63.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils63.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils63.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils63.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils63.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils63.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils63.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils63.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils63.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils63.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils63.AST_NODE_TYPES.TSArrayType, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils63.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils63.AST_NODE_TYPES.TSTypeLiteral, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils63.AST_NODE_TYPES.TSTypeLiteral, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils63.AST_NODE_TYPES.TSTypeLiteral, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils63.AST_NODE_TYPES.TSTypeReference, import_utils63.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils63.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils63.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils63.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils63.AST_NODE_TYPES.TSUnionType, import_utils63.AST_NODE_TYPES.TSTypeReference, import_utils63.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils63.AST_NODE_TYPES.TSUnionType, import_utils63.AST_NODE_TYPES.TSTypeReference, import_utils63.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils63.AST_NODE_TYPES.TSUnionType, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils63.AST_NODE_TYPES.TSUnionType, import_utils63.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils63.AST_NODE_TYPES.TSIntersectionType, import_utils63.AST_NODE_TYPES.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -10819,20 +10714,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils65.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils63.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils65.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils63.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils65.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils63.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils65.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils63.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -10854,6 +10749,9 @@ function leafAgrees(leaf, annotation) {
   if (core === null) {
     return null;
   }
+  if (leaf === "date") {
+    return core.type === import_utils63.AST_NODE_TYPES.TSTypeReference && core.typeName.type === import_utils63.AST_NODE_TYPES.Identifier && core.typeName.name === "Date";
+  }
   return expected.includes(core.type);
 }
 var prefer_zod_infer_default = createRule({
@@ -10897,14 +10795,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils65.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils63.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils65.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils65.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils63.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils63.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils65.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils63.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -10913,19 +10811,19 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName2(call) {
       const callee = call.callee;
-      return callee.type === import_utils65.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils65.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils63.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils63.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === import_utils65.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils63.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils65.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils65.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils63.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils63.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils65.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils63.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -10956,16 +10854,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils65.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils63.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils65.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils63.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils65.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils65.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils63.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils63.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -10976,11 +10874,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils65.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils63.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils65.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils65.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils63.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils63.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -10988,14 +10886,15 @@ var prefer_zod_infer_default = createRule({
         result.set(name, {
           optional: member.optional === true,
           nullable: annotation !== null && unwrapNullish(annotation).nullable,
+          readonly: member.readonly === true,
           annotation
         });
       }
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils65.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils65.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils63.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils63.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -11003,11 +10902,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils65.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils63.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils65.AST_NODE_TYPES.TSUnionType || node.type === import_utils65.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils63.AST_NODE_TYPES.TSUnionType || node.type === import_utils63.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -11035,6 +10934,9 @@ var prefer_zod_infer_default = createRule({
         if (field.nullable !== member.nullable) {
           return false;
         }
+        if (member.readonly) {
+          return false;
+        }
         const agrees = leafAgrees(field.leaf, member.annotation);
         if (agrees === false) {
           return false;
@@ -11047,17 +10949,17 @@ var prefer_zod_infer_default = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (!isZodModule2(node.source.value)) {
+        if (!isZodModule(node.source.value)) {
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils65.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils65.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils65.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils65.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils63.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils63.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils63.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils63.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils65.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils63.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -11067,14 +10969,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils65.AST_NODE_TYPES.Identifier && node.property.type === import_utils65.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils63.AST_NODE_TYPES.Identifier && node.property.type === import_utils63.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils65.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils65.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils65.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils63.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils63.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils63.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -11092,7 +10994,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils65.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils63.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -11137,10 +11039,14 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils66 = require("@typescript-eslint/utils");
+var import_utils64 = require("@typescript-eslint/utils");
+var import_typescript = __toESM(require("typescript"), 1);
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils66.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils66.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils64.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils64.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils64.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    return false;
+  }
+  if (statement.type === import_utils64.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -11156,11 +11062,40 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils66.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils64.AST_NODE_TYPES.BlockStatement && !only.body.some(isRuntimeHandlingStatement)) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
 };
+function isExhaustiveFiniteSwitch(node, services) {
+  const checker = services.program.getTypeChecker();
+  const discriminant = services.esTreeNodeToTSNodeMap.get(node.discriminant);
+  const discriminantType = checker.getTypeAtLocation(discriminant);
+  const constituents = discriminantType.isUnion() ? discriminantType.types : [discriminantType];
+  if (constituents.length === 0) return false;
+  const expected = /* @__PURE__ */ new Set();
+  for (const constituent of constituents) {
+    const key = finiteTypeKey(constituent, checker);
+    if (key === null) return false;
+    expected.add(key);
+  }
+  const handled = /* @__PURE__ */ new Set();
+  for (const caseNode of node.cases) {
+    if (caseNode.test === null) continue;
+    const test = services.esTreeNodeToTSNodeMap.get(caseNode.test);
+    const testType = checker.getTypeAtLocation(test);
+    const alternatives = testType.isUnion() ? testType.types : [testType];
+    for (const alternative of alternatives) {
+      const key = finiteTypeKey(alternative, checker);
+      if (key !== null) handled.add(key);
+    }
+  }
+  return [...expected].every((key) => handled.has(key));
+}
+function finiteTypeKey(type, checker) {
+  const finiteFlags = import_typescript.default.TypeFlags.StringLiteral | import_typescript.default.TypeFlags.NumberLiteral | import_typescript.default.TypeFlags.BooleanLiteral | import_typescript.default.TypeFlags.EnumLiteral | import_typescript.default.TypeFlags.UniqueESSymbol | import_typescript.default.TypeFlags.Null | import_typescript.default.TypeFlags.Undefined;
+  return (type.flags & finiteFlags) !== 0 ? checker.typeToString(type) : null;
+}
 var require_assert_never_default = createRule({
   name: "require-assert-never",
   meta: {
@@ -11175,6 +11110,12 @@ var require_assert_never_default = createRule({
   },
   defaultOptions: [],
   create(context) {
+    let services;
+    try {
+      services = import_utils64.ESLintUtils.getParserServices(context);
+    } catch {
+      return {};
+    }
     return {
       SwitchStatement(node) {
         const defaultIndex = node.cases.findIndex(
@@ -11186,6 +11127,7 @@ var require_assert_never_default = createRule({
         if (defaultCase.consequent.some(isRuntimeHandlingStatement)) return;
         if (isFallthroughDefault(node, defaultIndex)) return;
         if (isCommentOnlyNoopDefault(defaultCase, context.sourceCode)) return;
+        if (!isExhaustiveFiniteSwitch(node, services)) return;
         context.report({
           node: defaultCase,
           messageId: "missingAssertNever"
@@ -11196,7 +11138,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils67 = require("@typescript-eslint/utils");
+var import_utils65 = require("@typescript-eslint/utils");
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -11212,14 +11154,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils67.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils65.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils67.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils65.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils67.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils67.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils65.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils65.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -11229,7 +11171,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isInlineUrl(node, resolvesToGlobal) {
-  return node.type === import_utils67.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils67.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils67.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
+  return node.type === import_utils65.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils65.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils65.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils65.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -11266,14 +11208,14 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils67.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils65.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils67.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils65.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils67.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils67.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils67.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils65.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils65.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils65.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -11293,7 +11235,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils68 = require("@typescript-eslint/utils");
+var import_utils66 = require("@typescript-eslint/utils");
 var CONFIGISH_TYPE_RE = /(?:Options|Opts|Config|Configuration|Settings|Params|Props|Args|Env|Environment|Callbacks|Flags)$/;
 var CONFIGISH_NAME_RE = /^(?:options|opts|config|configuration|settings|params|props|args|env|environment|callbacks|flags|logger|log|clock)$/i;
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
@@ -11306,46 +11248,46 @@ var FLUENT_RESULT_TYPE_RE = /(?:Builder|Base|Query|Without)(?:\W|$)/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
 var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
-var staticMemberName3 = (member) => {
-  if (member.property.type === import_utils68.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
-  if (!member.computed && member.property.type === import_utils68.AST_NODE_TYPES.Identifier) return member.property.name;
-  return member.computed && member.property.type === import_utils68.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
+var staticMemberName4 = (member) => {
+  if (member.property.type === import_utils66.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
+  if (!member.computed && member.property.type === import_utils66.AST_NODE_TYPES.Identifier) return member.property.name;
+  return member.computed && member.property.type === import_utils66.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
 };
 var detachedValueExports = (program) => {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
+    if (statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration === null && statement.source === null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
         if (specifier.exportKind !== "type") names.add(specifier.local.name);
       }
-    } else if (statement.type === import_utils68.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils68.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils66.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils66.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
-    } else if (statement.type === import_utils68.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils68.AST_NODE_TYPES.Identifier) {
+    } else if (statement.type === import_utils66.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils66.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
   return names;
 };
-var isExportedClass2 = (node, detached) => node.parent.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils68.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
+var isExportedClass2 = (node, detached) => node.parent.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils66.AST_NODE_TYPES.ExportDefaultDeclaration || node.id !== null && detached.has(node.id.name);
 var readTypeReference = (annotation) => {
-  if (annotation?.type === import_utils68.AST_NODE_TYPES.TSUnionType) {
+  if (annotation?.type === import_utils66.AST_NODE_TYPES.TSUnionType) {
     const members = annotation.types.filter(
-      (member) => member.type !== import_utils68.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils68.AST_NODE_TYPES.TSNullKeyword
+      (member) => member.type !== import_utils66.AST_NODE_TYPES.TSUndefinedKeyword && member.type !== import_utils66.AST_NODE_TYPES.TSNullKeyword
     );
     annotation = members.length === 1 ? members[0] : void 0;
   }
-  if (annotation === void 0 || annotation.type !== import_utils68.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils66.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils68.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils68.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils66.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils66.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
-var qualifiedName = (name) => name.type === import_utils68.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils68.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var qualifiedName = (name) => name.type === import_utils66.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils66.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils68.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils68.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils66.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils66.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -11356,18 +11298,18 @@ var fileTypeIndex = (program) => {
   const objects = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils68.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils66.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils68.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils66.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils68.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils68.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils66.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils66.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils68.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils66.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -11395,10 +11337,10 @@ var readConstructor = (ctor, declared, typeParameters) => {
     while (pending.length > 0) {
       const current = pending.pop();
       if (current === void 0) break;
-      if (current.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils68.AST_NODE_TYPES.FunctionExpression || current.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils68.AST_NODE_TYPES.ClassExpression || current.type === import_utils68.AST_NODE_TYPES.ClassDeclaration) continue;
-      const expression = current.type === import_utils68.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils68.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils68.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils68.AST_NODE_TYPES.ThisExpression ? staticMemberName3(expression.left) : null;
-      if (expression?.type !== import_utils68.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils68.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils68.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      if (current.type === import_utils66.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils66.AST_NODE_TYPES.FunctionExpression || current.type === import_utils66.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils66.AST_NODE_TYPES.ClassExpression || current.type === import_utils66.AST_NODE_TYPES.ClassDeclaration) continue;
+      const expression = current.type === import_utils66.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
+      const storedField = expression?.type === import_utils66.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils66.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils66.AST_NODE_TYPES.ThisExpression ? staticMemberName4(expression.left) : null;
+      if (expression?.type !== import_utils66.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils66.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils66.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -11411,14 +11353,14 @@ var readConstructor = (ctor, declared, typeParameters) => {
         continue;
       }
       let source = expression.right;
-      while (source.type === import_utils68.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils68.AST_NODE_TYPES.TSAsExpression || source.type === import_utils68.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils68.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
-      if (source.type === import_utils68.AST_NODE_TYPES.NewExpression) {
+      while (source.type === import_utils66.AST_NODE_TYPES.TSNonNullExpression || source.type === import_utils66.AST_NODE_TYPES.TSAsExpression || source.type === import_utils66.AST_NODE_TYPES.TSSatisfiesExpression || source.type === import_utils66.AST_NODE_TYPES.TSTypeAssertion) source = source.expression;
+      if (source.type === import_utils66.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils68.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils66.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.name, fields);
-      } else if (source.type === import_utils68.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils68.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils66.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils66.AST_NODE_TYPES.Identifier) {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
@@ -11428,7 +11370,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 === import_utils68.AST_NODE_TYPES.TSParameterProperty ? [reference.name] : [...storedFieldsFrom.get(reference.name) ?? []];
+      const fields = parameter.type === import_utils66.AST_NODE_TYPES.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;
@@ -11443,8 +11385,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
 };
 var parameterCollaborators = (parameter, declared) => {
   let target = parameter;
-  if (target.type === import_utils68.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils68.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils66.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils66.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -11452,9 +11394,9 @@ var parameterCollaborators = (parameter, declared) => {
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils68.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils68.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils68.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils66.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils66.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils66.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference, fields: [] };
@@ -11466,11 +11408,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils68.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils68.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils66.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils66.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils68.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils68.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils66.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils66.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -11479,21 +11421,21 @@ var objectPatternCollaborators = (pattern, declared) => {
   return collaborators;
 };
 var bagMemberTypes = (annotation, declared) => {
-  if (annotation.type === import_utils68.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils66.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils68.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils68.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils66.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils66.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils68.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils66.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils68.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils66.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils66.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils66.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils68.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils68.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils66.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils66.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var subtreeHas = (root, found) => {
   let hit = false;
@@ -11520,19 +11462,19 @@ var invokedInstanceField = (call) => {
   const direct = instanceField(call.callee);
   if (direct !== null) return direct;
   let callee = call.callee;
-  while (callee.type === import_utils68.AST_NODE_TYPES.ChainExpression || callee.type === import_utils68.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils68.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils68.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils68.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
-  return callee.type === import_utils68.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
+  while (callee.type === import_utils66.AST_NODE_TYPES.ChainExpression || callee.type === import_utils66.AST_NODE_TYPES.TSAsExpression || callee.type === import_utils66.AST_NODE_TYPES.TSNonNullExpression || callee.type === import_utils66.AST_NODE_TYPES.TSSatisfiesExpression || callee.type === import_utils66.AST_NODE_TYPES.TSTypeAssertion) callee = callee.expression;
+  return callee.type === import_utils66.AST_NODE_TYPES.MemberExpression ? instanceField(callee.object) : null;
 };
 var instanceField = (candidate) => {
   let node = candidate;
-  while (node.type === import_utils68.AST_NODE_TYPES.ChainExpression || node.type === import_utils68.AST_NODE_TYPES.TSAsExpression || node.type === import_utils68.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils68.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils68.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils68.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils68.AST_NODE_TYPES.ThisExpression ? staticMemberName3(node) : null;
+  while (node.type === import_utils66.AST_NODE_TYPES.ChainExpression || node.type === import_utils66.AST_NODE_TYPES.TSAsExpression || node.type === import_utils66.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils66.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils66.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
+  return node.type === import_utils66.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils66.AST_NODE_TYPES.ThisExpression ? staticMemberName4(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
   const visit = (current) => {
-    if (current.type === import_utils68.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils68.AST_NODE_TYPES.ClassExpression || current.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils68.AST_NODE_TYPES.FunctionExpression) return;
-    if (current.type === import_utils68.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils66.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils66.AST_NODE_TYPES.ClassExpression || current.type === import_utils66.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils66.AST_NODE_TYPES.FunctionExpression) return;
+    if (current.type === import_utils66.AST_NODE_TYPES.CallExpression) {
       const field = invokedInstanceField(current);
       if (field !== null) invoked.add(field);
     }
@@ -11545,14 +11487,14 @@ var behaviorallyInvokedFields = (body2) => {
     }
   };
   for (const member of body2.body) {
-    if (member.type === import_utils68.AST_NODE_TYPES.StaticBlock || member.static) continue;
-    if (member.type === import_utils68.AST_NODE_TYPES.MethodDefinition) {
+    if (member.type === import_utils66.AST_NODE_TYPES.StaticBlock || member.static) continue;
+    if (member.type === import_utils66.AST_NODE_TYPES.MethodDefinition) {
       if (member.value.body !== null && member.value.body !== void 0) visit(member.value.body);
       continue;
     }
-    if (member.type !== import_utils68.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
+    if (member.type !== import_utils66.AST_NODE_TYPES.PropertyDefinition || member.value === null) continue;
     visit(
-      member.value.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
+      member.value.type === import_utils66.AST_NODE_TYPES.ArrowFunctionExpression ? member.value.body : member.value
     );
   }
   return invoked;
@@ -11572,25 +11514,25 @@ var isTransportWrapper = (className, collaborators, program) => {
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils68.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils66.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
 var publicMethodNames = (body2, functionAliases) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type === import_utils68.AST_NODE_TYPES.PropertyDefinition) {
+    if (member.type === import_utils66.AST_NODE_TYPES.PropertyDefinition) {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
-      if (member.value?.type !== import_utils68.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils68.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils68.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils68.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
+      if (member.value?.type !== import_utils66.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils66.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils66.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
+      names.push(member.key.type === import_utils66.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
       continue;
     }
-    if (member.type !== import_utils68.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils66.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils68.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils68.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils66.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils66.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -11598,13 +11540,13 @@ var publicMethodNames = (body2, functionAliases) => {
 var isFluentConstructionObject = (node, getText) => {
   if (node.id === null) return false;
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils68.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
+    (member) => member.type === import_utils66.AST_NODE_TYPES.MethodDefinition && member.kind === "method" && !member.static && member.accessibility !== "private" && member.accessibility !== "protected" && member.value.body !== null
   );
   if (methods.length === 0) return false;
   return methods.every((member) => {
     const result = member.value.returnType?.typeAnnotation;
     if (result === void 0) return false;
-    const returnsOwnType = result.type === import_utils68.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
+    const returnsOwnType = result.type === import_utils66.AST_NODE_TYPES.TSTypeReference && result.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && result.typeName.name === node.id?.name;
     return returnsOwnType || FLUENT_BUILDER_NAME_RE.test(node.id?.name ?? "") && FLUENT_RESULT_TYPE_RE.test(getText(result));
   });
 };
@@ -11612,10 +11554,10 @@ function localClassAbstractness(program) {
   const classes = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils68.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils68.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
+    const declaration = statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils66.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils66.AST_NODE_TYPES.ClassDeclaration && declaration.id !== null) {
       classes.set(declaration.id.name, declaration.abstract === true);
-      if (declaration.superClass?.type === import_utils68.AST_NODE_TYPES.Identifier) {
+      if (declaration.superClass?.type === import_utils66.AST_NODE_TYPES.Identifier) {
         parents.set(declaration.id.name, declaration.superClass.name);
       }
     }
@@ -11637,43 +11579,43 @@ function localInterfaceSurfaces(program) {
   const parents = /* @__PURE__ */ new Map();
   const functionAliases = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils68.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
+    const declaration = statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils66.AST_NODE_TYPES.TSTypeAliasDeclaration && (declaration.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSFunctionType || declaration.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSConstructorType)) functionAliases.add(declaration.id.name);
   }
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils68.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils68.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+    const declaration = statement.type === import_utils66.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils66.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       const callables2 = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
-      const parts = declaration.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
+      const parts = declaration.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSIntersectionType ? declaration.typeAnnotation.types : [declaration.typeAnnotation];
       const inherited = parents.get(declaration.id.name) ?? [];
       for (const part of parts) {
-        if (part.type === import_utils68.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils68.AST_NODE_TYPES.Identifier) {
+        if (part.type === import_utils66.AST_NODE_TYPES.TSTypeReference && part.typeName.type === import_utils66.AST_NODE_TYPES.Identifier) {
           inherited.push(part.typeName.name);
           continue;
         }
-        if (part.type !== import_utils68.AST_NODE_TYPES.TSTypeLiteral) continue;
+        if (part.type !== import_utils66.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
-          if (member.type !== import_utils68.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils68.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils68.AST_NODE_TYPES.Identifier) continue;
-          if (member.type === import_utils68.AST_NODE_TYPES.TSMethodSignature) {
+          if (member.type !== import_utils66.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils66.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.computed || member.key.type !== import_utils66.AST_NODE_TYPES.Identifier) continue;
+          if (member.type === import_utils66.AST_NODE_TYPES.TSMethodSignature) {
             callables2.add(member.key.name);
             continue;
           }
-          if (member.type !== import_utils68.AST_NODE_TYPES.TSPropertySignature) continue;
+          if (member.type !== import_utils66.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils68.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils68.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === import_utils66.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils66.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
       parents.set(declaration.id.name, inherited);
       continue;
     }
-    if (declaration?.type !== import_utils68.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
+    if (declaration?.type !== import_utils66.AST_NODE_TYPES.TSInterfaceDeclaration) continue;
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
-      if (member.type !== import_utils68.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils68.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils68.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils68.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils68.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils68.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      if (member.type !== import_utils66.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils66.AST_NODE_TYPES.TSPropertySignature) continue;
+      if (member.computed || member.key.type !== import_utils66.AST_NODE_TYPES.Identifier) continue;
+      if (member.type === import_utils66.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils66.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils66.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -11681,7 +11623,7 @@ function localInterfaceSurfaces(program) {
       [
         ...parents.get(declaration.id.name) ?? [],
         ...declaration.extends.flatMap(
-          (heritage) => heritage.expression.type === import_utils68.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
+          (heritage) => heritage.expression.type === import_utils66.AST_NODE_TYPES.Identifier ? [heritage.expression.name] : ["*"]
         )
       ]
     );
@@ -11708,7 +11650,7 @@ function localInterfaceSurfaces(program) {
 }
 function hasServicePort(node, methods, classes, interfaces) {
   if (node.superClass !== null) {
-    if (node.superClass.type !== import_utils68.AST_NODE_TYPES.Identifier) return true;
+    if (node.superClass.type !== import_utils66.AST_NODE_TYPES.Identifier) return true;
     const localAbstract = classes.get(node.superClass.name);
     if (localAbstract === void 0 || localAbstract) return true;
   }
@@ -11720,7 +11662,7 @@ function hasServicePort(node, methods, classes, interfaces) {
   if (node.implements.length === 0) return false;
   const combined = /* @__PURE__ */ new Set();
   for (const implementation of node.implements) {
-    if (implementation.expression.type !== import_utils68.AST_NODE_TYPES.Identifier) return true;
+    if (implementation.expression.type !== import_utils66.AST_NODE_TYPES.Identifier) return true;
     const name = implementation.expression.name;
     const localAbstract = classes.get(name);
     if (localAbstract === true) return true;
@@ -11762,7 +11704,7 @@ var require_interface_for_injected_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils68.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
+          (member) => member.type === import_utils66.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -11797,37 +11739,37 @@ var require_interface_for_injected_service_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils69 = require("@typescript-eslint/utils");
+var import_utils67 = require("@typescript-eslint/utils");
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
 function unwrapExpression3(node) {
-  if (node.type === import_utils69.AST_NODE_TYPES.TSAsExpression || node.type === import_utils69.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils69.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils69.AST_NODE_TYPES.TSTypeAssertion) {
+  if (node.type === import_utils67.AST_NODE_TYPES.TSAsExpression || node.type === import_utils67.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils67.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils67.AST_NODE_TYPES.TSTypeAssertion) {
     return unwrapExpression3(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
   const value = unwrapExpression3(node);
-  if (value.type === import_utils69.AST_NODE_TYPES.Literal) {
+  if (value.type === import_utils67.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils69.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils67.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils69.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils67.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils69.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils67.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils69.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils67.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils69.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils69.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils67.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils67.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils69.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils67.AST_NODE_TYPES.Identifier) return property.key.name;
   return typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
@@ -11849,19 +11791,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils69.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils67.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils69.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils67.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
           const config = unwrapExpression3(declaration.init);
-          if (config.type !== import_utils69.AST_NODE_TYPES.ObjectExpression) {
+          if (config.type !== import_utils67.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils69.AST_NODE_TYPES.Property || propertyName2(property) !== "matcher" || property.value.type === import_utils69.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils67.AST_NODE_TYPES.Property || propertyName2(property) !== "matcher" || property.value.type === import_utils67.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -11875,28 +11817,30 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils70 = require("@typescript-eslint/utils");
+var import_utils68 = require("@typescript-eslint/utils");
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils70.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils68.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils70.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils68.AST_NODE_TYPES.Identifier) return false;
   const method = callee.property.name;
-  if (method !== "parse" && method !== "safeParse") return false;
+  if (method !== "parse" && method !== "safeParse" && method !== "parseAsync" && method !== "safeParseAsync") {
+    return false;
+  }
   return looksLikeZodSchema(callee.object);
 };
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils70.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils68.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils68.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils70.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils68.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -11905,12 +11849,12 @@ var looksLikeZodSchema = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils70.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils68.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils70.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils68.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils70.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils70.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -11930,14 +11874,14 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils70.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils68.AST_NODE_TYPES.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils70.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -11948,8 +11892,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils70.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils70.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils68.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -11964,11 +11908,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils70.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils70.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils68.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils68.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
-      const parent = node.parent;
-      if (parent.type === import_utils70.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils70.AST_NODE_TYPES.Identifier) {
+      let current = node;
+      let parent = current.parent;
+      while ((parent.type === import_utils68.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils68.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils68.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils68.AST_NODE_TYPES.ChainExpression) && parent.expression === current) {
+        current = parent;
+        parent = current.parent;
+      }
+      if (parent.type === import_utils68.AST_NODE_TYPES.VariableDeclarator && parent.init === current && parent.id.type === import_utils68.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -11996,7 +11945,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils71 = require("@typescript-eslint/utils");
+var import_utils69 = require("@typescript-eslint/utils");
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
 var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b/i;
 var INSERT_GATE = /insert/i;
@@ -12027,9 +11976,9 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-var import_utils72 = require("@typescript-eslint/utils");
+var import_utils70 = require("@typescript-eslint/utils");
 function isFunction(node) {
-  return node.type === import_utils72.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils72.AST_NODE_TYPES.FunctionExpression;
+  return node.type === import_utils70.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils70.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -12124,8 +12073,8 @@ function moduleScope(context, program) {
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
     program.body.flatMap((statement) => {
-      const node = statement.type === import_utils72.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === import_utils72.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === import_utils70.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -12147,7 +12096,7 @@ function moduleScope(context, program) {
       const nearestFunction = [...ancestors].reverse().find(isFunction);
       const parent = identifier.parent;
       const callerDefinition = nearestFunction === void 0 ? void 0 : byFunction.get(nearestFunction);
-      if (callerDefinition === void 0 || parent.type !== import_utils72.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== import_utils70.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -12162,38 +12111,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== import_utils72.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== import_utils70.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === import_utils72.AST_NODE_TYPES.VariableDeclaration) {
+    if (statement.declaration?.type === import_utils70.AST_NODE_TYPES.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === import_utils72.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === import_utils70.AST_NODE_TYPES.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === import_utils72.AST_NODE_TYPES.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === import_utils70.AST_NODE_TYPES.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === import_utils72.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils72.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
-    if (statement.type === import_utils72.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === import_utils70.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils70.AST_NODE_TYPES.Identifier) names.add(statement.declaration.name);
+    if (statement.type === import_utils70.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === import_utils72.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils72.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === import_utils72.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils70.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === import_utils70.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils72.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils70.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils72.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === import_utils70.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -12206,21 +12155,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === import_utils72.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils72.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (node.key.type === import_utils70.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === import_utils70.AST_NODE_TYPES.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils72.AST_NODE_TYPES.Identifier ? import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === import_utils70.AST_NODE_TYPES.Identifier ? import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils72.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils72.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== import_utils70.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
+  if (node.property.type === import_utils70.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils70.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === import_utils72.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === import_utils70.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === import_utils70.AST_NODE_TYPES.Identifier) return node.property.name;
+  return node.computed && node.property.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -12236,7 +12185,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === import_utils72.AST_NODE_TYPES.MethodDefinition
+    (member) => member.type === import_utils70.AST_NODE_TYPES.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -12244,8 +12193,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== import_utils72.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === import_utils72.AST_NODE_TYPES.Identifier ? member.key.name : null;
+    if (member.type !== import_utils70.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === import_utils70.AST_NODE_TYPES.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -12254,7 +12203,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils72.AST_NODE_TYPES.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === import_utils70.AST_NODE_TYPES.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -12263,11 +12212,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === import_utils72.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils72.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils72.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+  if (node.type === import_utils70.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils70.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils70.AST_NODE_TYPES.Identifier) {
+    const outer = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -12283,27 +12232,27 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === import_utils72.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils72.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils72.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils72.AST_NODE_TYPES.ThisExpression;
+      while (current?.type === import_utils70.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils70.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils70.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
+      return current?.type === import_utils70.AST_NODE_TYPES.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils72.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils72.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils72.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils72.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils72.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils72.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== import_utils70.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils70.AST_NODE_TYPES.AssignmentPattern) return;
+      if (current.type === import_utils70.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils70.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === import_utils70.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
+      const value = current.type === import_utils70.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === import_utils72.AST_NODE_TYPES.ObjectPattern) {
+      if (binding.type === import_utils70.AST_NODE_TYPES.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === import_utils72.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils70.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === import_utils72.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === import_utils70.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== import_utils72.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
+      if (binding.type !== import_utils70.AST_NODE_TYPES.Identifier) return;
+      const variable = import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -12316,16 +12265,16 @@ function classScope(context, node, computedReferenceNames) {
       walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils72.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils72.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
+      if (current.type === import_utils70.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils70.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === import_utils72.AST_NODE_TYPES.RestElement) {
+          if (property.type === import_utils70.AST_NODE_TYPES.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === import_utils72.AST_NODE_TYPES.Property && property.key.type === import_utils72.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === import_utils70.AST_NODE_TYPES.Property && property.key.type === import_utils70.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== import_utils72.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils70.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -12333,12 +12282,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils72.AST_NODE_TYPES.Identifier ? import_utils72.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === import_utils70.AST_NODE_TYPES.Identifier ? import_utils70.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils72.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils70.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -12358,9 +12307,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === import_utils72.AST_NODE_TYPES.MethodDefinition || member.type === import_utils72.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
+    if (member.type === import_utils70.AST_NODE_TYPES.MethodDefinition || member.type === import_utils70.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== import_utils72.AST_NODE_TYPES.MemberExpression) return;
+      if (current.type !== import_utils70.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -12370,7 +12319,7 @@ function classScope(context, node, computedReferenceNames) {
   const accessibility = new Map(
     scopeDefinitions.map((definition) => {
       const method = definition.node;
-      const accessibility2 = method.key.type === import_utils72.AST_NODE_TYPES.PrivateIdentifier ? "private" : method.accessibility ?? "public";
+      const accessibility2 = method.key.type === import_utils70.AST_NODE_TYPES.PrivateIdentifier ? "private" : method.accessibility ?? "public";
       return [definition.name, accessibility2];
     })
   );
@@ -12405,7 +12354,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils72.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils72.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils70.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils70.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -12414,7 +12363,7 @@ var stepdown_default = createRule({
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils73 = require("@typescript-eslint/utils");
+var import_utils71 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -12439,21 +12388,23 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils73.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-var calleeChainStartsWithZ = (node) => {
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils71.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var calleeChainRoot = (node) => {
   let current = node;
-  while (current.type === import_utils73.AST_NODE_TYPES.MemberExpression) {
-    const receiver = current.object;
-    if (receiver.type === import_utils73.AST_NODE_TYPES.Identifier && receiver.name === "z") {
-      return true;
+  for (; ; ) {
+    if (current.type === import_utils71.AST_NODE_TYPES.Identifier) {
+      return current;
+    }
+    if (current.type === import_utils71.AST_NODE_TYPES.MemberExpression) {
+      current = current.object;
+      continue;
     }
-    if (receiver.type === import_utils73.AST_NODE_TYPES.CallExpression) {
-      current = receiver.callee;
+    if (current.type === import_utils71.AST_NODE_TYPES.CallExpression) {
+      current = current.callee;
       continue;
     }
-    return false;
+    return null;
   }
-  return false;
 };
 var zod_naming_convention_default = createRule({
   name: "zod-naming-convention",
@@ -12485,20 +12436,45 @@ var zod_naming_convention_default = createRule({
     const convention = optionsArg?.convention ?? "either";
     const { test, messageId } = CONVENTIONS[convention];
     const acceptsSchemaWord = convention !== "prefix";
+    const zodBindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return import_utils71.ASTUtils.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
+    function recordZodBinding(identifier) {
+      const binding = resolvedBinding(identifier);
+      if (binding !== null) zodBindings.add(binding);
+    }
+    function isZodChain(node) {
+      const root = calleeChainRoot(node);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding);
+    }
     if (isTestFile(context.filename) || BENCHMARK_PATH_RE.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === import_utils71.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils71.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils71.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils71.AST_NODE_TYPES.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+            recordZodBinding(specifier.local);
+          }
+        }
+      },
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils73.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils71.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils73.AST_NODE_TYPES.MemberExpression) return;
-        if (!calleeChainStartsWithZ(callee)) return;
+        if (callee.type !== import_utils71.AST_NODE_TYPES.MemberExpression) return;
+        if (!isZodChain(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== import_utils73.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils71.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -12552,6 +12528,14 @@ var retiredRules = {
     removedIn: "10.0.0",
     reason: "Delete the config entry and suppressions; use the narrower no-comment-cruft, no-restated-comment, and no-long-comment rules."
   },
+  "prefer-string-literal-union": {
+    removedIn: "12.0.0",
+    reason: "Delete the config entry and suppressions; syntax cannot prove that an open string domain is closed."
+  },
+  "prefer-zod-enum": {
+    removedIn: "12.0.0",
+    reason: "Delete the entry; use `zod/prefer-enum-over-literal-union`, which proves every arm is a string literal."
+  },
   "primary-export-file-name": {
     removedIn: "4.0.0",
     reason: "Delete the config entry and suppressions; there is no replacement."
@@ -12586,6 +12570,7 @@ var rules = {
   "no-hand-rolled-spinner": no_hand_rolled_spinner_default,
   "no-insecure-random-id": no_insecure_random_id_default,
   "no-json-stringify-error": no_json_stringify_error_default,
+  "no-impossible-zod-literal-bounds": no_impossible_zod_literal_bounds_default,
   "no-log-only-catch": no_log_only_catch_default,
   "no-long-comment": no_long_comment_default,
   "no-generic-single-export-module": no_generic_single_export_module_default,
@@ -12626,9 +12611,7 @@ var rules = {
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
   "prefer-semantic-colors": prefer_semantic_colors_default,
   "prefer-server-actions": prefer_server_actions_default,
-  "prefer-string-literal-union": prefer_string_literal_union_default,
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
-  "prefer-zod-enum": prefer_zod_enum_default,
   "prefer-zod-infer": prefer_zod_infer_default,
   "require-assert-never": require_assert_never_default,
   "require-fetch-timeout": require_fetch_timeout_default,
@@ -12641,7 +12624,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "11.1.0"
+  version: "12.0.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",
@@ -12662,6 +12645,7 @@ var recommendedRules = {
   "@sarj/no-hand-rolled-spinner": "error",
   "@sarj/no-insecure-random-id": "error",
   "@sarj/no-json-stringify-error": "error",
+  "@sarj/no-impossible-zod-literal-bounds": "error",
   "@sarj/no-log-only-catch": "error",
   "@sarj/no-long-comment": "error",
   "@sarj/no-generic-single-export-module": "error",
@@ -12696,9 +12680,7 @@ var recommendedRules = {
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
-  "@sarj/prefer-string-literal-union": "error",
   "@sarj/prefer-whole-object-assertion": "error",
-  "@sarj/prefer-zod-enum": "error",
   "@sarj/prefer-zod-infer": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",
@@ -12724,6 +12706,7 @@ var strictRules = {
   "@sarj/no-hand-rolled-spinner": "error",
   "@sarj/no-insecure-random-id": "error",
   "@sarj/no-json-stringify-error": "error",
+  "@sarj/no-impossible-zod-literal-bounds": "error",
   "@sarj/no-log-only-catch": "error",
   "@sarj/no-long-comment": "error",
   "@sarj/no-generic-single-export-module": "error",
@@ -12761,9 +12744,7 @@ var strictRules = {
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
-  "@sarj/prefer-string-literal-union": "error",
   "@sarj/prefer-whole-object-assertion": "error",
-  "@sarj/prefer-zod-enum": "error",
   "@sarj/prefer-zod-infer": "error",
   "@sarj/require-assert-never": "error",
   "@sarj/require-fetch-timeout": "error",