@sarj/eslint-plugin 9.12.1 → 9.13.1

package/dist/index.cjs

@@ -683,7 +683,7 @@ var CODE_KEYWORD_RE = /^(import |export |const |let |var |function\b|class |inte
 var CODE_TAIL_RE = /[;{}()]\s*$|=>\s*$|,\s*$/;
 var ASSIGN_RE = /^[A-Za-z_$][\w.$[\]]*\s*(?:=(?![=>])|\+=|-=|\*=)\s*\S.*[;)}\]]\s*$/;
 var CALL_RE = /^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
-var ASSERTION_CODE_RE = /^(?:await\s+)?(?:expect(?:TypeOf)?\s*\(.+\)\s*(?:\.\w+(?:<[^\n]*>)?)+(?:\s*\(.*\))?|assert(?:\.\w+)?\s*\(.+\))\s*;?\s*$/;
+var ASSERTION_CODE_RE = /^(?:await\s+)?(?:expect(?:TypeOf)?|assert(?:\.\w+)?)\s*\(/;
 var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
 function stripCommentMarker(line) {
   return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
@@ -6747,8 +6747,154 @@ var prefer_input_group_search_default = createRule({
   }
 });
 
-// src/rules/prefer-shadcn-primitives.ts
+// src/rules/prefer-immutable-module-constant.ts
 var import_utils49 = require("@typescript-eslint/utils");
+var CONSTANT_NAME = /^_?[A-Z][A-Z0-9_]*$/;
+var MUTATING_METHODS = /* @__PURE__ */ new Set([
+  "add",
+  "clear",
+  "copyWithin",
+  "delete",
+  "fill",
+  "pop",
+  "push",
+  "reverse",
+  "set",
+  "shift",
+  "sort",
+  "splice",
+  "unshift"
+]);
+function isAsConst(node, sourceText) {
+  if (node.type === import_utils49.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return isAsConst(node.expression, sourceText);
+  }
+  return node.type === import_utils49.AST_NODE_TYPES.TSAsExpression && sourceText(node.typeAnnotation).trim() === "const";
+}
+function unwrapExpression(node) {
+  if (node.type === import_utils49.AST_NODE_TYPES.TSAsExpression || node.type === import_utils49.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils49.AST_NODE_TYPES.TSNonNullExpression) {
+    return unwrapExpression(node.expression);
+  }
+  return node;
+}
+function isObjectFreeze(node, isUnshadowedGlobal) {
+  const inner = unwrapExpression(node);
+  if (inner.type === import_utils49.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils49.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils49.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === import_utils49.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
+    const argument = inner.arguments[0];
+    return argument !== void 0 && argument.type !== import_utils49.AST_NODE_TYPES.SpreadElement && collectionKind(argument, isUnshadowedGlobal) === "literal";
+  }
+  return false;
+}
+function collectionKind(node, isUnshadowedGlobal) {
+  const inner = unwrapExpression(node);
+  if (inner.type === import_utils49.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils49.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils49.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal(inner.callee.object) && inner.callee.property.type === import_utils49.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils49.AST_NODE_TYPES.SpreadElement) {
+    return collectionKind(inner.arguments[0], isUnshadowedGlobal);
+  }
+  if (inner.type === import_utils49.AST_NODE_TYPES.ArrayExpression || inner.type === import_utils49.AST_NODE_TYPES.ObjectExpression) {
+    return "literal";
+  }
+  if (inner.type === import_utils49.AST_NODE_TYPES.NewExpression && inner.callee.type === import_utils49.AST_NODE_TYPES.Identifier && (inner.callee.name === "Set" || inner.callee.name === "Map") && isUnshadowedGlobal(inner.callee)) {
+    return inner.callee.name;
+  }
+  return null;
+}
+function isReadonlyType(node, kind) {
+  if (node.type === import_utils49.AST_NODE_TYPES.TSTypeOperator && node.operator === "readonly") {
+    return true;
+  }
+  if (node.type !== import_utils49.AST_NODE_TYPES.TSTypeReference || node.typeName.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+    return false;
+  }
+  if (node.typeName.name === "Readonly") {
+    return kind === "literal";
+  }
+  return kind === "literal" ? node.typeName.name === "ReadonlyArray" : node.typeName.name === `Readonly${kind}`;
+}
+function declaredReadonlyType(node, kind) {
+  const annotation = node.id.type === import_utils49.AST_NODE_TYPES.Identifier ? node.id.typeAnnotation : void 0;
+  if (annotation !== void 0 && isReadonlyType(annotation.typeAnnotation, kind)) {
+    return true;
+  }
+  return node.init?.type === import_utils49.AST_NODE_TYPES.TSAsExpression && isReadonlyType(node.init.typeAnnotation, kind);
+}
+function referenceMutates(identifier) {
+  let member = identifier.parent;
+  if (member?.type !== import_utils49.AST_NODE_TYPES.MemberExpression || member.object !== identifier) {
+    return member?.type === import_utils49.AST_NODE_TYPES.CallExpression && member.arguments[0] === identifier && member.callee.type === import_utils49.AST_NODE_TYPES.MemberExpression && !member.callee.computed && member.callee.object.type === import_utils49.AST_NODE_TYPES.Identifier && member.callee.object.name === "Object" && member.callee.property.type === import_utils49.AST_NODE_TYPES.Identifier && member.callee.property.name === "assign";
+  }
+  while (member.parent.type === import_utils49.AST_NODE_TYPES.MemberExpression && member.parent.object === member) {
+    member = member.parent;
+  }
+  const parent = member.parent;
+  if (parent?.type === import_utils49.AST_NODE_TYPES.AssignmentExpression && parent.left === member) {
+    return true;
+  }
+  if (parent?.type === import_utils49.AST_NODE_TYPES.UpdateExpression && parent.argument === member) {
+    return true;
+  }
+  if (parent?.type === import_utils49.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete" && parent.argument === member) {
+    return true;
+  }
+  return parent?.type === import_utils49.AST_NODE_TYPES.CallExpression && parent.callee === member && member.property.type === import_utils49.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(member.property.name);
+}
+var prefer_immutable_module_constant_default = createRule({
+  name: "prefer-immutable-module-constant",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require module-level constant collections to expose readonly state."
+    },
+    schema: [],
+    messages: {
+      preferAsConst: "Module constant `{{name}}` is a mutable literal. Add `as const` or use `Object.freeze` so consumers cannot mutate shared state.",
+      preferReadonlyCollection: "Module constant `{{name}}` is a mutable {{kind}}. Expose it as `Readonly{{kind}}` or an immutable collection."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const isUnshadowedGlobal = (identifier) => {
+      const variable = import_utils49.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+      return variable === null || variable.defs.length === 0;
+    };
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
+      return {};
+    }
+    return {
+      VariableDeclarator(node) {
+        const declaration = node.parent;
+        if (declaration.type !== import_utils49.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || node.id.type !== import_utils49.AST_NODE_TYPES.Identifier || node.init === null || !CONSTANT_NAME.test(node.id.name)) {
+          return;
+        }
+        const container = declaration.parent;
+        if (container.type !== import_utils49.AST_NODE_TYPES.Program && !(container.type === import_utils49.AST_NODE_TYPES.ExportNamedDeclaration && container.parent.type === import_utils49.AST_NODE_TYPES.Program)) {
+          return;
+        }
+        if (isAsConst(node.init, (target) => sourceCode.getText(target)) || isObjectFreeze(node.init, isUnshadowedGlobal)) {
+          return;
+        }
+        const kind = collectionKind(node.init, isUnshadowedGlobal);
+        if (kind === null || declaredReadonlyType(node, kind)) {
+          return;
+        }
+        const variable = sourceCode.getDeclaredVariables(node)[0];
+        if (variable?.references.some(
+          (reference) => reference.identifier.type === import_utils49.AST_NODE_TYPES.Identifier && referenceMutates(reference.identifier)
+        ) === true) {
+          return;
+        }
+        context.report({
+          node: node.id,
+          messageId: kind === "literal" ? "preferAsConst" : "preferReadonlyCollection",
+          data: { name: node.id.name, kind }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-shadcn-primitives.ts
+var import_utils50 = require("@typescript-eslint/utils");
 var SHADCN_PRIMITIVES = {
   button: "Button",
   dialog: "Dialog or AlertDialog family",
@@ -6769,15 +6915,15 @@ var LABELABLE_ELEMENTS = /* @__PURE__ */ new Set([
   "textarea"
 ]);
 function rawElementName(node) {
-  if (node.name.type !== import_utils49.AST_NODE_TYPES.JSXIdentifier) return null;
+  if (node.name.type !== import_utils50.AST_NODE_TYPES.JSXIdentifier) return null;
   const name = node.name.name;
   return Object.hasOwn(SHADCN_PRIMITIVES, name) ? name : null;
 }
 function staticExpressionString(expression) {
-  if (expression.type === import_utils49.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils50.AST_NODE_TYPES.Literal) {
     return typeof expression.value === "string" ? expression.value : null;
   }
-  if (expression.type === import_utils49.AST_NODE_TYPES.TemplateLiteral) {
+  if (expression.type === import_utils50.AST_NODE_TYPES.TemplateLiteral) {
     let value = expression.quasis[0]?.value.cooked ?? "";
     for (const [index, substitution] of expression.expressions.entries()) {
       const staticSubstitution = staticExpressionString(substitution);
@@ -6787,24 +6933,24 @@ function staticExpressionString(expression) {
     }
     return value;
   }
-  if (expression.type === import_utils49.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils49.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils49.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils49.AST_NODE_TYPES.TSTypeAssertion) {
+  if (expression.type === import_utils50.AST_NODE_TYPES.TSAsExpression || expression.type === import_utils50.AST_NODE_TYPES.TSNonNullExpression || expression.type === import_utils50.AST_NODE_TYPES.TSSatisfiesExpression || expression.type === import_utils50.AST_NODE_TYPES.TSTypeAssertion) {
     return staticExpressionString(expression.expression);
   }
   return null;
 }
 function staticString(value) {
-  if (value?.type === import_utils49.AST_NODE_TYPES.Literal) {
+  if (value?.type === import_utils50.AST_NODE_TYPES.Literal) {
     return typeof value.value === "string" ? value.value : null;
   }
-  if (value?.type !== import_utils49.AST_NODE_TYPES.JSXExpressionContainer) return null;
+  if (value?.type !== import_utils50.AST_NODE_TYPES.JSXExpressionContainer) return null;
   return staticExpressionString(value.expression);
 }
 function effectiveAttribute(node, attributeName) {
   for (const attribute of node.attributes.toReversed()) {
-    if (attribute.type === import_utils49.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attribute.type === import_utils50.AST_NODE_TYPES.JSXSpreadAttribute) {
       return { kind: "unknown" };
     }
-    if (attribute.name.type !== import_utils49.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== attributeName) {
+    if (attribute.name.type !== import_utils50.AST_NODE_TYPES.JSXIdentifier || attribute.name.name !== attributeName) {
       continue;
     }
     const value = staticString(attribute.value);
@@ -6813,7 +6959,7 @@ function effectiveAttribute(node, attributeName) {
   return { kind: "missing" };
 }
 function isLabelableElement(node) {
-  if (node.openingElement.name.type !== import_utils49.AST_NODE_TYPES.JSXIdentifier) {
+  if (node.openingElement.name.type !== import_utils50.AST_NODE_TYPES.JSXIdentifier) {
     return false;
   }
   const name = node.openingElement.name.name;
@@ -6825,10 +6971,10 @@ function isLabelableElement(node) {
 }
 function containsLabelableElement(node) {
   return node.children.some((child) => {
-    if (child.type === import_utils49.AST_NODE_TYPES.JSXElement) {
+    if (child.type === import_utils50.AST_NODE_TYPES.JSXElement) {
       return isLabelableElement(child) || containsLabelableElement(child);
     }
-    if (child.type === import_utils49.AST_NODE_TYPES.JSXFragment) {
+    if (child.type === import_utils50.AST_NODE_TYPES.JSXFragment) {
       return containsLabelableElement(child);
     }
     return false;
@@ -6837,7 +6983,7 @@ function containsLabelableElement(node) {
 function isStaticallyAssociatedLabel(node) {
   const htmlFor = effectiveAttribute(node, "htmlFor");
   if (htmlFor.kind === "known" && htmlFor.value.trim().length > 0) return true;
-  return node.parent.type === import_utils49.AST_NODE_TYPES.JSXElement && containsLabelableElement(node.parent);
+  return node.parent.type === import_utils50.AST_NODE_TYPES.JSXElement && containsLabelableElement(node.parent);
 }
 function replacementFor(node, element) {
   if (element !== "input") return SHADCN_PRIMITIVES[element];
@@ -6881,7 +7027,7 @@ var prefer_shadcn_primitives_default = createRule({
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils50 = require("@typescript-eslint/utils");
+var import_utils51 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS2 = [
@@ -6890,7 +7036,7 @@ var IGNORE_PATTERNS2 = [
   /\.generated\.tsx?$/,
   /\.d\.ts$/
 ];
-var MUTATING_METHODS = /* @__PURE__ */ new Set([
+var MUTATING_METHODS2 = /* @__PURE__ */ new Set([
   // Array
   "push",
   "pop",
@@ -6910,9 +7056,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
-  import_utils50.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils50.AST_NODE_TYPES.FunctionExpression,
-  import_utils50.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils51.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils51.AST_NODE_TYPES.FunctionExpression,
+  import_utils51.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile2(filename, sourceText) {
@@ -6925,14 +7071,14 @@ function isLocalFixtureFile(filename) {
   return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap3(node) {
-  if (node.type === import_utils50.AST_NODE_TYPES.TSAsExpression || node.type === import_utils50.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils50.AST_NODE_TYPES.TSNonNullExpression) {
+  if (node.type === import_utils51.AST_NODE_TYPES.TSAsExpression || node.type === import_utils51.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils51.AST_NODE_TYPES.TSNonNullExpression) {
     return unwrap3(node.expression);
   }
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === import_utils50.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils51.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6940,29 +7086,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap3(node);
   switch (inner.type) {
-    case import_utils50.AST_NODE_TYPES.Literal: {
+    case import_utils51.AST_NODE_TYPES.Literal: {
       return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case import_utils50.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils51.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils50.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils50.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    case import_utils51.AST_NODE_TYPES.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils51.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
     }
-    case import_utils50.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils51.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils50.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils51.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils50.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils51.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils50.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils51.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils50.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils51.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6975,7 +7121,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap3(node);
-  if (inner.type === import_utils50.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils50.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils50.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils50.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils50.AST_NODE_TYPES.SpreadElement) {
+  if (inner.type === import_utils51.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils51.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils51.AST_NODE_TYPES.SpreadElement) {
     return unwrap3(inner.arguments[0]);
   }
   return inner;
@@ -6991,19 +7137,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils50.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils51.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils50.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils51.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils50.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils50.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils51.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils51.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils50.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils51.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap3(arg);
-    if (entries.type !== import_utils50.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils51.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -7032,10 +7178,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils50.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils51.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils50.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils51.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils51.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -7049,38 +7195,38 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils50.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils50.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils51.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils50.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils51.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils50.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils51.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils50.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils50.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === import_utils51.AST_NODE_TYPES.Identifier && MUTATING_METHODS2.has(parent.property.name) && grandparent.type === import_utils51.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils50.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils50.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils50.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils50.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils51.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils50.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils51.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
@@ -7104,7 +7250,7 @@ var prefer_module_level_constant_default = createRule({
       }
     ],
     messages: {
-      hoistCollection: "`{{name}}` is a literal-only {{kind}} rebuilt on every call. Hoist it to module scope so it is allocated once and can be reused, exported, and tested.",
+      hoistCollection: "`{{name}}` is a literal-only {{kind}} rebuilt on every call. Hoist it to module scope in immutable form (`as const`, a readonly collection, or `Object.freeze`) so it is allocated once without exposing mutable shared state.",
       hoistRegex: "`{{name}}` is a constant regex recompiled on every call. Hoist it to module scope."
     }
   },
@@ -7135,7 +7281,7 @@ var prefer_module_level_constant_default = createRule({
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils51.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -7147,10 +7293,10 @@ var prefer_module_level_constant_default = createRule({
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils50.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils51.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils50.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils51.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -7177,7 +7323,7 @@ var prefer_module_level_constant_default = createRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-var import_utils51 = require("@typescript-eslint/utils");
+var import_utils52 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -7243,9 +7389,9 @@ var I18N_RECEIVER_NAMES = /* @__PURE__ */ new Set([
   "intl"
 ]);
 var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
-  import_utils51.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils51.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils51.AST_NODE_TYPES.FunctionExpression
+  import_utils52.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils52.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils52.AST_NODE_TYPES.FunctionExpression
 ]);
 function schemaExpression(node) {
   let current = node;
@@ -7254,10 +7400,10 @@ function schemaExpression(node) {
     if (parent === void 0) {
       return current;
     }
-    if (parent.type === import_utils51.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils51.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
+    if (parent.type === import_utils52.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils52.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
       return current;
     }
-    if (parent.type === import_utils51.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils51.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils51.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils51.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
+    if (parent.type === import_utils52.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils52.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils52.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils52.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -7308,22 +7454,22 @@ function subtreeSome(root, predicate) {
 function readsReceiver(node) {
   return subtreeSome(
     node,
-    (inner) => inner.type === import_utils51.AST_NODE_TYPES.ThisExpression || inner.type === import_utils51.AST_NODE_TYPES.Super || inner.type === import_utils51.AST_NODE_TYPES.Identifier && inner.name === "arguments"
+    (inner) => inner.type === import_utils52.AST_NODE_TYPES.ThisExpression || inner.type === import_utils52.AST_NODE_TYPES.Super || inner.type === import_utils52.AST_NODE_TYPES.Identifier && inner.name === "arguments"
   );
 }
 function buildsLocalizedText(node) {
   return subtreeSome(node, (inner) => {
-    if (inner.type === import_utils51.AST_NODE_TYPES.TaggedTemplateExpression) {
+    if (inner.type === import_utils52.AST_NODE_TYPES.TaggedTemplateExpression) {
       return true;
     }
-    if (inner.type !== import_utils51.AST_NODE_TYPES.CallExpression) {
+    if (inner.type !== import_utils52.AST_NODE_TYPES.CallExpression) {
       return false;
     }
     const { callee } = inner;
-    if (callee.type === import_utils51.AST_NODE_TYPES.Identifier) {
+    if (callee.type === import_utils52.AST_NODE_TYPES.Identifier) {
       return I18N_CALLEE_NAMES.has(callee.name);
     }
-    return callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils51.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
+    return callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils52.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
   });
 }
 function collectReferences(scope, out) {
@@ -7380,15 +7526,15 @@ var prefer_module_level_schema_default = createRule({
     }
     const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodCall(node) {
-      return node.type === import_utils51.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils51.AST_NODE_TYPES.Identifier && zodNamespaces.has(node.callee.object.name);
+      return node.type === import_utils52.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils52.AST_NODE_TYPES.Identifier && zodNamespaces.has(node.callee.object.name);
     }
     function isCovered(node) {
       let current = node.parent ?? void 0;
       while (current !== void 0) {
-        if (current !== node && isZodCall(current) && current.callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
+        if (current !== node && isZodCall(current) && current.callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils52.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === import_utils51.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils51.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === import_utils52.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils52.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils52.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -7403,11 +7549,11 @@ var prefer_module_level_schema_default = createRule({
         if (parent === void 0) {
           return confirmed;
         }
-        if (parent.type === import_utils51.AST_NODE_TYPES.Property && parent.value === current || parent.type === import_utils51.AST_NODE_TYPES.ObjectExpression || parent.type === import_utils51.AST_NODE_TYPES.ArrayExpression) {
+        if (parent.type === import_utils52.AST_NODE_TYPES.Property && parent.value === current || parent.type === import_utils52.AST_NODE_TYPES.ObjectExpression || parent.type === import_utils52.AST_NODE_TYPES.ArrayExpression) {
           current = parent;
           continue;
         }
-        if (parent.type === import_utils51.AST_NODE_TYPES.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
+        if (parent.type === import_utils52.AST_NODE_TYPES.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
           current = schemaExpression(parent);
           confirmed = current;
           continue;
@@ -7417,7 +7563,7 @@ var prefer_module_level_schema_default = createRule({
     }
     function isSchemaComposition(node) {
       const { callee } = node;
-      const isCombinator = callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils51.AST_NODE_TYPES.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
+      const isCombinator = callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils52.AST_NODE_TYPES.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
       return isCombinator || isZodCall(node);
     }
     function closesOverNothing(node, enclosing) {
@@ -7451,13 +7597,13 @@ var prefer_module_level_schema_default = createRule({
     }
     function ownerName(enclosing) {
       const parent = enclosing.parent ?? void 0;
-      if (enclosing.type === import_utils51.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
+      if (enclosing.type === import_utils52.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
         return enclosing.id.name;
       }
-      if (parent !== void 0 && parent.type === import_utils51.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils51.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && parent.type === import_utils52.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils52.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
-      if (parent !== void 0 && (parent.type === import_utils51.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils51.AST_NODE_TYPES.Property) && parent.key.type === import_utils51.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && (parent.type === import_utils52.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils52.AST_NODE_TYPES.Property) && parent.key.type === import_utils52.AST_NODE_TYPES.Identifier) {
         return parent.key.name;
       }
       return "this function";
@@ -7468,7 +7614,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils51.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils51.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils51.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils51.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils52.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils52.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils52.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils52.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -7478,7 +7624,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const callee = node.callee;
-        if (callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier) {
           return;
         }
         const factory = callee.property.name;
@@ -7493,7 +7639,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const shape = node.arguments[0];
-        if (shape !== void 0 && shape.type === import_utils51.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
+        if (shape !== void 0 && shape.type === import_utils52.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
           return;
         }
         const expression = schemaExpression(node);
@@ -7521,9 +7667,9 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-var import_utils52 = require("@typescript-eslint/utils");
+var import_utils53 = require("@typescript-eslint/utils");
 function requireUuid(node) {
-  return node?.type === import_utils52.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils52.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils52.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
+  return node?.type === import_utils53.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils53.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments.length === 1 && node.arguments[0]?.type === import_utils53.AST_NODE_TYPES.Literal && node.arguments[0].value === "uuid";
 }
 var prefer_native_random_uuid_default = createRule({
   name: "prefer-native-random-uuid",
@@ -7544,7 +7690,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return import_utils52.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return import_utils53.ASTUtils.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -7566,37 +7712,37 @@ var prefer_native_random_uuid_default = createRule({
       ImportDeclaration(node) {
         if (node.source.value !== "uuid") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils52.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils52.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
+          if (specifier.type === import_utils53.AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === import_utils53.AST_NODE_TYPES.Identifier ? specifier.imported.name === "v4" : specifier.imported.value === "v4")) {
             record(specifier.local, directBindings);
-          } else if (specifier.type === import_utils52.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+          } else if (specifier.type === import_utils53.AST_NODE_TYPES.ImportNamespaceSpecifier) {
             record(specifier.local, namespaceBindings);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.parent.kind !== "const" || !requireUuid(node.init)) return;
-        if (node.init?.type !== import_utils52.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils52.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
+        if (node.init?.type !== import_utils53.AST_NODE_TYPES.CallExpression || node.init.callee.type !== import_utils53.AST_NODE_TYPES.Identifier || (resolve(node.init.callee)?.defs.length ?? 0) > 0) {
           return;
         }
-        if (node.id.type === import_utils52.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils53.AST_NODE_TYPES.Identifier) {
           record(node.id, namespaceBindings);
           return;
         }
-        if (node.id.type !== import_utils52.AST_NODE_TYPES.ObjectPattern) return;
+        if (node.id.type !== import_utils53.AST_NODE_TYPES.ObjectPattern) return;
         for (const property of node.id.properties) {
-          if (property.type === import_utils52.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils52.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils52.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils52.AST_NODE_TYPES.Identifier) {
+          if (property.type === import_utils53.AST_NODE_TYPES.Property && !property.computed && (property.key.type === import_utils53.AST_NODE_TYPES.Identifier && property.key.name === "v4" || property.key.type === import_utils53.AST_NODE_TYPES.Literal && property.key.value === "v4") && property.value.type === import_utils53.AST_NODE_TYPES.Identifier) {
             record(property.value, directBindings);
           }
         }
       },
       "CallExpression:exit"(node) {
         if (node.arguments.length !== 0) return;
-        if (node.callee.type === import_utils52.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils53.AST_NODE_TYPES.Identifier) {
           const variable2 = resolve(node.callee);
           if (variable2 !== null && directBindings.has(variable2)) report(node);
           return;
         }
-        if (node.callee.type !== import_utils52.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils52.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
+        if (node.callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.object.type !== import_utils53.AST_NODE_TYPES.Identifier || node.callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier || node.callee.property.name !== "v4") {
           return;
         }
         const variable = resolve(node.callee.object);
@@ -7607,20 +7753,20 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils53 = require("@typescript-eslint/utils");
+var import_utils54 = require("@typescript-eslint/utils");
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === import_utils53.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils53.AST_NODE_TYPES.Literal) return String(key.value);
+  if (key.type === import_utils54.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils54.AST_NODE_TYPES.Literal) return String(key.value);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === import_utils53.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils53.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils53.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils54.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils54.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils54.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function isNullishType(node) {
-  return node.type === import_utils53.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils53.AST_NODE_TYPES.TSUndefinedKeyword;
+  return node.type === import_utils54.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils54.AST_NODE_TYPES.TSUndefinedKeyword;
 }
 function isNullableArrayOnly(node) {
   const values = node.types.filter((member) => !isNullishType(member));
@@ -7648,7 +7794,7 @@ var prefer_non_nullable_collection_default = createRule({
       if (node.optional) return;
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== import_utils53.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== import_utils54.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -7661,7 +7807,7 @@ var prefer_non_nullable_collection_default = createRule({
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils53.AST_NODE_TYPES.TSUnionType) return;
+        if (node.typeAnnotation.type !== import_utils54.AST_NODE_TYPES.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -7674,13 +7820,13 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils54 = require("@typescript-eslint/utils");
+var import_utils55 = require("@typescript-eslint/utils");
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils54.AST_NODE_TYPES.TSAsExpression || current.type === import_utils54.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils54.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils54.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils55.AST_NODE_TYPES.TSAsExpression || current.type === import_utils55.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils55.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils55.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils54.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils55.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -7695,23 +7841,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === import_utils54.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils54.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === import_utils55.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils55.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node) => {
   let current = unwrap4(node);
   if (current === null) return false;
-  if (current.type === import_utils54.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils55.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== import_utils54.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils55.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== import_utils54.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils55.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -7721,16 +7867,16 @@ var isRawPayloadSource = (node) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils54.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]);
+  return property.name === "parse" && object !== null && object.type === import_utils55.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
 var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils54.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils55.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap4(current.callee);
-      const name = callee?.type === import_utils54.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils54.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils54.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      const name = callee?.type === import_utils55.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -7752,15 +7898,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils54.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils55.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils54.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils55.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils54.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils55.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils54.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils55.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -7779,39 +7925,39 @@ var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
 var isValidationRead = (node) => {
   let current = node;
   let parent = current.parent;
-  while (parent !== null && parent !== void 0 && (parent.type === import_utils54.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils54.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils54.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils54.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils54.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils55.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils55.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils55.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils55.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils55.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils54.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils55.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils54.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils55.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils54.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils54.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils54.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils55.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var isGuardTestPosition = (node) => {
   let current = node;
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils54.AST_NODE_TYPES.UnaryExpression:
-      case import_utils54.AST_NODE_TYPES.LogicalExpression:
-      case import_utils54.AST_NODE_TYPES.ChainExpression:
+      case import_utils55.AST_NODE_TYPES.UnaryExpression:
+      case import_utils55.AST_NODE_TYPES.LogicalExpression:
+      case import_utils55.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils54.AST_NODE_TYPES.IfStatement:
-      case import_utils54.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils54.AST_NODE_TYPES.WhileStatement:
-      case import_utils54.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils54.AST_NODE_TYPES.ForStatement:
+      case import_utils55.AST_NODE_TYPES.IfStatement:
+      case import_utils55.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils55.AST_NODE_TYPES.WhileStatement:
+      case import_utils55.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils55.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -7821,7 +7967,7 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== import_utils54.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils55.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -7864,11 +8010,11 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils54.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils55.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils54.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils54.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils55.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils55.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             if (!isFullyNarrowedPattern(node)) {
               context.report({ node: node.id, messageId: "unparsedJsonAccess" });
@@ -7882,7 +8028,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils54.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils55.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -7892,7 +8038,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils54.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils54.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils55.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils55.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -7909,15 +8055,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils54.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils55.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils54.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils55.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils54.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils55.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -7931,13 +8077,13 @@ var prefer_schema_for_api_payload_default = createRule({
         const obj = unwrap4(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils54.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils54.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils55.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils55.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils54.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils55.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -7950,7 +8096,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils55 = require("@typescript-eslint/utils");
+var import_utils56 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -8050,8 +8196,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils55.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils55.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils55.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils56.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils56.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils56.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -8077,7 +8223,7 @@ var EMAIL_OR_PDF_MODULE_RE = /^@react-(?:email|pdf)\//;
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils55.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils56.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -8088,7 +8234,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils55.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils55.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils55.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils55.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils56.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils56.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils56.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils56.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -8225,12 +8371,12 @@ var hasSemanticTokenSystem = (filename) => {
   return root !== null && workspaceHasMarker(root);
 };
 var propName = (key) => {
-  if (key.type === import_utils55.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils55.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils56.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils56.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
-  if (statement.type !== import_utils55.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils55.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils55.AST_NODE_TYPES.ExportAllDeclaration) {
+  if (statement.type !== import_utils56.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils56.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils56.AST_NODE_TYPES.ExportAllDeclaration) {
     return false;
   }
   return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
@@ -8282,27 +8428,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils55.AST_NODE_TYPES.Literal:
+        case import_utils56.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils55.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils56.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils55.AST_NODE_TYPES.ArrayExpression:
+        case import_utils56.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils55.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils56.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils55.AST_NODE_TYPES.ObjectExpression:
+        case import_utils56.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils55.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils56.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils55.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils56.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils55.AST_NODE_TYPES.LogicalExpression:
+        case import_utils56.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -8310,32 +8456,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === import_utils56.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         report(node, "inlineColor", { value: node.value });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils55.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils55.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils55.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils56.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils56.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils56.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils55.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
+        if (node.callee.type === import_utils56.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils56.AST_NODE_TYPES.Literal && typeof node.arguments[0].value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.arguments[0].value)) {
           importsEmailOrPdfRenderer = true;
         }
-        if (node.callee.type === import_utils55.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils56.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils55.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils56.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils55.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils56.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -8345,9 +8491,9 @@ var prefer_semantic_colors_default = createRule({
       },
       // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils55.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils56.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils55.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils56.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -8361,7 +8507,7 @@ var prefer_semantic_colors_default = createRule({
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+        if (node.source.type === import_utils56.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
           importsEmailOrPdfRenderer = true;
         }
       },
@@ -8374,7 +8520,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils56 = require("@typescript-eslint/utils");
+var import_utils57 = require("@typescript-eslint/utils");
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
@@ -8565,7 +8711,7 @@ var prefer_single_sentence_comment_default = createRule({
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils57 = require("@typescript-eslint/utils");
+var import_utils58 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -8608,19 +8754,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils57.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils58.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils57.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils58.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils57.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils57.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils58.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils58.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils57.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils58.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -8649,12 +8795,12 @@ function bindingSourceExpression(decl) {
   return ts2.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils57.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils58.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils57.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils58.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils57.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils58.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -8662,7 +8808,7 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils57.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils58.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
@@ -8703,7 +8849,7 @@ var prefer_string_literal_union_default = createRule({
     );
     let services;
     try {
-      services = import_utils57.ESLintUtils.getParserServices(context);
+      services = import_utils58.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -8815,7 +8961,7 @@ var prefer_string_literal_union_default = createRule({
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils57.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils58.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -8903,10 +9049,10 @@ var prefer_string_literal_union_default = createRule({
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils57.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils58.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils57.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils58.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -8915,7 +9061,7 @@ var prefer_string_literal_union_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils58 = require("@typescript-eslint/utils");
+var import_utils59 = 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"]);
@@ -8924,11 +9070,11 @@ var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
 var MIN_RUN_LENGTH = 2;
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils58.AST_NODE_TYPES.Literal:
+    case import_utils59.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils58.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils59.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils58.AST_NODE_TYPES.UnaryExpression:
+    case import_utils59.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -8936,15 +9082,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils58.AST_NODE_TYPES.Identifier:
-    case import_utils58.AST_NODE_TYPES.ThisExpression:
+    case import_utils59.AST_NODE_TYPES.Identifier:
+    case import_utils59.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils58.AST_NODE_TYPES.MemberExpression:
+    case import_utils59.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils58.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils59.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -8952,7 +9098,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils58.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils59.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -8978,24 +9124,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils58.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils59.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils58.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils59.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils58.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils58.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils59.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils58.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils58.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils59.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils59.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_utils58.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils59.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -9009,7 +9155,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         key = { kind: "index", index };
       } else {
-        if (actual.property.type !== import_utils58.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
+        if (actual.property.type !== import_utils59.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 };
@@ -9021,7 +9167,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_utils58.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils59.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -9136,7 +9282,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/prefer-zod-enum.ts
-var import_utils59 = require("@typescript-eslint/utils");
+var import_utils60 = require("@typescript-eslint/utils");
 var prefer_zod_enum_default = createRule({
   name: "prefer-zod-enum",
   meta: {
@@ -9156,25 +9302,25 @@ var prefer_zod_enum_default = createRule({
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils59.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils59.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils60.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils60.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_utils59.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== import_utils60.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_utils59.AST_NODE_TYPES.SpreadElement) {
+        if (element?.type === import_utils60.AST_NODE_TYPES.SpreadElement) {
           canFix = false;
           continue;
         }
-        if (element === null || element.type !== import_utils59.AST_NODE_TYPES.CallExpression || element.callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils59.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils59.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
+        if (element === null || element.type !== import_utils60.AST_NODE_TYPES.CallExpression || element.callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils60.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils60.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_utils59.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+        if (element.arguments.length !== 1 || value === void 0 || value.type !== import_utils60.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
           canFix = false;
           continue;
         }
@@ -9184,11 +9330,11 @@ var prefer_zod_enum_default = createRule({
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils59.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== import_utils60.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils59.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils60.AST_NODE_TYPES.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -9205,7 +9351,7 @@ var prefer_zod_enum_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils59.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils59.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils59.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils59.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils60.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils60.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils60.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils60.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -9227,7 +9373,7 @@ var prefer_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils60 = require("@typescript-eslint/utils");
+var import_utils61 = require("@typescript-eslint/utils");
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -9264,44 +9410,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils60.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils60.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils60.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils60.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils60.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils60.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils60.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils60.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils60.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils60.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils60.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils60.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils60.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils60.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils60.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils60.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils60.AST_NODE_TYPES.TSArrayType, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils60.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils60.AST_NODE_TYPES.TSTypeLiteral, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils60.AST_NODE_TYPES.TSTypeLiteral, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils60.AST_NODE_TYPES.TSTypeLiteral, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils60.AST_NODE_TYPES.TSTypeReference, import_utils60.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils60.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils60.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils60.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils60.AST_NODE_TYPES.TSUnionType, import_utils60.AST_NODE_TYPES.TSTypeReference, import_utils60.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils60.AST_NODE_TYPES.TSUnionType, import_utils60.AST_NODE_TYPES.TSTypeReference, import_utils60.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils60.AST_NODE_TYPES.TSUnionType, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils60.AST_NODE_TYPES.TSUnionType, import_utils60.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils60.AST_NODE_TYPES.TSIntersectionType, import_utils60.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils61.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils61.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils61.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils61.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils61.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils61.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils61.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils61.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils61.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils61.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils61.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils61.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils61.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils61.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils61.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils61.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils61.AST_NODE_TYPES.TSArrayType, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils61.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils61.AST_NODE_TYPES.TSTypeLiteral, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils61.AST_NODE_TYPES.TSTypeLiteral, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils61.AST_NODE_TYPES.TSTypeLiteral, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils61.AST_NODE_TYPES.TSTypeReference, import_utils61.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils61.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils61.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils61.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils61.AST_NODE_TYPES.TSUnionType, import_utils61.AST_NODE_TYPES.TSTypeReference, import_utils61.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils61.AST_NODE_TYPES.TSUnionType, import_utils61.AST_NODE_TYPES.TSTypeReference, import_utils61.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils61.AST_NODE_TYPES.TSUnionType, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils61.AST_NODE_TYPES.TSUnionType, import_utils61.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils61.AST_NODE_TYPES.TSIntersectionType, import_utils61.AST_NODE_TYPES.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -9310,20 +9456,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils60.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils61.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils60.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils61.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils60.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils61.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils60.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils61.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -9388,14 +9534,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils60.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils61.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils60.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils61.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils61.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils60.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils61.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -9404,19 +9550,19 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName(call) {
       const callee = call.callee;
-      return callee.type === import_utils60.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils60.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils61.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils61.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === import_utils60.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils61.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils60.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils61.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils61.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils60.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils61.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -9447,16 +9593,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils60.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils61.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils60.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils61.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils60.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils60.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils61.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils61.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -9467,11 +9613,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils60.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils61.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils60.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils60.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils61.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils61.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -9485,8 +9631,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils60.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils60.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils61.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils61.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -9494,11 +9640,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils60.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils61.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils60.AST_NODE_TYPES.TSUnionType || node.type === import_utils60.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils61.AST_NODE_TYPES.TSUnionType || node.type === import_utils61.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -9542,13 +9688,13 @@ var prefer_zod_infer_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils60.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils60.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils60.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils60.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils61.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils61.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils61.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils61.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils60.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils61.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -9558,14 +9704,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils60.AST_NODE_TYPES.Identifier && node.property.type === import_utils60.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils61.AST_NODE_TYPES.Identifier && node.property.type === import_utils61.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_utils60.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils60.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils60.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils61.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils61.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils61.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -9583,7 +9729,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils60.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils61.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -9628,10 +9774,10 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils61 = require("@typescript-eslint/utils");
+var import_utils62 = require("@typescript-eslint/utils");
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils61.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils61.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils62.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils62.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -9647,7 +9793,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils61.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils62.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -9687,7 +9833,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils62 = require("@typescript-eslint/utils");
+var import_utils63 = require("@typescript-eslint/utils");
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -9703,14 +9849,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils62.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils63.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils62.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils63.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils62.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils62.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils63.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils63.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -9720,7 +9866,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isStringish(node) {
-  return node.type === import_utils62.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils62.AST_NODE_TYPES.TemplateLiteral;
+  return node.type === import_utils63.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils63.AST_NODE_TYPES.TemplateLiteral;
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -9757,14 +9903,14 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils62.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils63.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils62.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils63.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils62.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils62.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils62.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils63.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils63.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils63.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -9784,7 +9930,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils63 = require("@typescript-eslint/utils");
+var import_utils64 = 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)$/;
@@ -9792,20 +9938,20 @@ var BUILTIN_CONTAINER_TYPE_RE = /^(?:Record|Map|WeakMap|Set|WeakSet|Array|Readon
 var TRANSPORT_WRAPPER_NAME_RE = /Client$/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
-var isExportedClass = (node) => node.parent.type === import_utils63.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils63.AST_NODE_TYPES.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === import_utils63.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils63.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var isExportedClass = (node) => node.parent.type === import_utils64.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils64.AST_NODE_TYPES.ExportDefaultDeclaration;
+var qualifiedName = (name) => name.type === import_utils64.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils64.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var readTypeReference = (annotation) => {
-  if (annotation === void 0 || annotation.type !== import_utils63.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils64.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils63.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils63.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils64.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils64.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { typeName: rightmost, display: qualifiedName(typeName) };
 };
 var namedParameterCollaborator = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils63.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils63.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils63.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils64.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils64.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils64.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference };
@@ -9813,8 +9959,8 @@ var namedParameterCollaborator = (annotated) => {
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils63.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils63.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils64.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils64.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -9825,18 +9971,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_utils63.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils64.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils64.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils63.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils64.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils63.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils63.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils64.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils64.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils63.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils63.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils63.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils64.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils64.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils64.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -9849,10 +9995,10 @@ var fileTypeIndex = (program) => {
   return { objects, functionAliases };
 };
 var bagMemberTypes = (annotation, declared) => {
-  if (annotation.type === import_utils63.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils64.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils63.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils63.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils64.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils64.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
@@ -9864,11 +10010,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils63.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils63.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils64.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils64.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils63.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils63.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils64.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils64.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -9878,8 +10024,8 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var parameterCollaborators = (parameter, declared) => {
   let target = parameter;
-  if (target.type === import_utils63.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils63.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils64.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils64.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -9898,17 +10044,17 @@ var readConstructor = (ctor, declared, typeParameters) => {
   let constructedFields = 0;
   if (body2 !== null && body2 !== void 0) {
     for (const statement of body2.body) {
-      if (statement.type !== import_utils63.AST_NODE_TYPES.ExpressionStatement) continue;
+      if (statement.type !== import_utils64.AST_NODE_TYPES.ExpressionStatement) continue;
       const expression = statement.expression;
-      if (expression.type !== import_utils63.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils63.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils63.AST_NODE_TYPES.ThisExpression) {
+      if (expression.type !== import_utils64.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils64.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils64.AST_NODE_TYPES.ThisExpression) {
         continue;
       }
       const source = expression.right;
-      if (source.type === import_utils63.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils64.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils63.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils64.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === import_utils63.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils63.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils64.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils64.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -9916,7 +10062,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
   const collaborators = [];
   for (const parameter of ctor.value.params) {
     for (const reference of parameterCollaborators(parameter, declared)) {
-      const stored = parameter.type === import_utils63.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
+      const stored = parameter.type === import_utils64.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
       if (!stored) continue;
       if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
       if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -9950,19 +10096,19 @@ var subtreeHas = (root, found) => {
   return hit;
 };
 var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
-  if (node.type === import_utils63.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils64.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils63.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils63.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils63.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils64.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils64.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils64.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils63.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils63.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils64.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils64.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var stem2 = (name) => name.replace(/^I(?=[A-Z])/, "").replace(/Impl$/, "");
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils63.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils63.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils64.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils64.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
@@ -9980,11 +10126,11 @@ var isTransportWrapper = (className, collaborators, program) => {
 var publicMethodNames = (body2) => {
   const names = [];
   for (const member of body2.body) {
-    if (member.type !== import_utils63.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils64.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_utils63.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils63.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils64.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils64.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -10017,7 +10163,7 @@ var require_interface_for_injected_service_default = createRule({
         if (node.implements.length > 0) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils63.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils64.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(
@@ -10046,37 +10192,37 @@ var require_interface_for_injected_service_default = createRule({
 });
 
 // src/rules/require-static-next-matcher.ts
-var import_utils64 = require("@typescript-eslint/utils");
+var import_utils65 = require("@typescript-eslint/utils");
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
-function unwrapExpression(node) {
-  if (node.type === import_utils64.AST_NODE_TYPES.TSAsExpression || node.type === import_utils64.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils64.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils64.AST_NODE_TYPES.TSTypeAssertion) {
-    return unwrapExpression(node.expression);
+function unwrapExpression2(node) {
+  if (node.type === import_utils65.AST_NODE_TYPES.TSAsExpression || node.type === import_utils65.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils65.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils65.AST_NODE_TYPES.TSTypeAssertion) {
+    return unwrapExpression2(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
-  const value = unwrapExpression(node);
-  if (value.type === import_utils64.AST_NODE_TYPES.Literal) {
+  const value = unwrapExpression2(node);
+  if (value.type === import_utils65.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (value.type === import_utils64.AST_NODE_TYPES.TemplateLiteral) {
+  if (value.type === import_utils65.AST_NODE_TYPES.TemplateLiteral) {
     return value.expressions.length === 0;
   }
-  if (value.type === import_utils64.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils65.AST_NODE_TYPES.ArrayExpression) {
     return value.elements.every(
-      (element) => element !== null && element.type !== import_utils64.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
+      (element) => element !== null && element.type !== import_utils65.AST_NODE_TYPES.SpreadElement && isStaticValue(element)
     );
   }
-  if (value.type === import_utils64.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils65.AST_NODE_TYPES.ObjectExpression) {
     return value.properties.every(
-      (property) => property.type === import_utils64.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils64.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
+      (property) => property.type === import_utils65.AST_NODE_TYPES.Property && property.kind === "init" && !property.computed && property.value.type !== import_utils65.AST_NODE_TYPES.AssignmentPattern && isStaticValue(property.value)
     );
   }
   return false;
 }
 function propertyName2(property) {
   if (property.computed) return null;
-  if (property.key.type === import_utils64.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils65.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({
@@ -10098,19 +10244,19 @@ var require_static_next_matcher_default = createRule({
     }
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils64.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== import_utils65.AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         for (const declaration of node.declaration.declarations) {
-          if (declaration.id.type !== import_utils64.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
+          if (declaration.id.type !== import_utils65.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
-          const config = unwrapExpression(declaration.init);
-          if (config.type !== import_utils64.AST_NODE_TYPES.ObjectExpression) {
+          const config = unwrapExpression2(declaration.init);
+          if (config.type !== import_utils65.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
           for (const property of config.properties) {
-            if (property.type !== import_utils64.AST_NODE_TYPES.Property || propertyName2(property) !== "matcher" || property.value.type === import_utils64.AST_NODE_TYPES.AssignmentPattern) {
+            if (property.type !== import_utils65.AST_NODE_TYPES.Property || propertyName2(property) !== "matcher" || property.value.type === import_utils65.AST_NODE_TYPES.AssignmentPattern) {
               continue;
             }
             if (!isStaticValue(property.value)) {
@@ -10124,18 +10270,18 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils65 = require("@typescript-eslint/utils");
+var import_utils66 = require("@typescript-eslint/utils");
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils65.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils66.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils65.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils66.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils65.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils66.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -10143,23 +10289,23 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils65.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils66.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils65.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils66.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils65.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier) return false;
   const method = callee.property.name;
   if (method !== "parse" && method !== "safeParse") return false;
   return looksLikeZodSchema(callee.object);
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils65.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils66.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils65.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils66.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils65.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils65.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils66.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils66.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -10179,14 +10325,14 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils65.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils66.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_utils65.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils66.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -10197,8 +10343,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils65.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils65.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils66.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -10213,11 +10359,11 @@ var require_zod_form_validation_default = createRule({
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils65.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils65.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === import_utils66.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils66.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === import_utils65.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils65.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils66.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils66.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -10245,7 +10391,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils66 = require("@typescript-eslint/utils");
+var import_utils67 = 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;
@@ -10276,7 +10422,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils67 = require("@typescript-eslint/utils");
+var import_utils68 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -10301,15 +10447,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils67.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils68.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils67.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils68.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils67.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils68.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils67.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils68.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -10354,13 +10500,13 @@ var zod_naming_convention_default = createRule({
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils67.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils68.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils67.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils68.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== import_utils67.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils68.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -10472,6 +10618,7 @@ var rules = {
   "prefer-constant-time-secret-compare": prefer_constant_time_secret_compare_default,
   "prefer-discriminated-union": prefer_discriminated_union_default,
   "prefer-input-group-search": prefer_input_group_search_default,
+  "prefer-immutable-module-constant": prefer_immutable_module_constant_default,
   "prefer-shadcn-primitives": prefer_shadcn_primitives_default,
   "prefer-module-level-constant": prefer_module_level_constant_default,
   "prefer-module-level-schema": prefer_module_level_schema_default,
@@ -10495,7 +10642,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "9.12.1"
+  version: "9.13.1"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",
@@ -10540,6 +10687,7 @@ var recommendedRules = {
   "@sarj/prefer-constant-time-secret-compare": "error",
   "@sarj/prefer-discriminated-union": "warn",
   "@sarj/prefer-input-group-search": "error",
+  "@sarj/prefer-immutable-module-constant": "warn",
   "@sarj/prefer-module-level-constant": "warn",
   "@sarj/prefer-module-level-schema": "warn",
   "@sarj/prefer-non-nullable-collection": "warn",
@@ -10601,6 +10749,7 @@ var strictRules = {
   "@sarj/prefer-constant-time-secret-compare": "error",
   "@sarj/prefer-discriminated-union": "error",
   "@sarj/prefer-input-group-search": "error",
+  "@sarj/prefer-immutable-module-constant": "warn",
   "@sarj/prefer-module-level-constant": "error",
   "@sarj/prefer-module-level-schema": "error",
   "@sarj/prefer-non-nullable-collection": "error",
@@ -10651,4 +10800,3 @@ var index_default = plugin;
   rules,
   strictRules
 });
-//# sourceMappingURL=index.cjs.map