@sarj/eslint-plugin 9.5.0 → 9.7.0

package/dist/index.cjs

@@ -45,10 +45,10 @@ var import_utils2 = require("@typescript-eslint/utils");
 // src/rules/_docs.ts
 var import_utils = require("@typescript-eslint/utils");
 var REPO_BLOB = "https://github.com/sarj-ai/standards/blob/main";
-var EVIDENCE_DIR = "docs/rules";
-var evidencePath = (name) => `${EVIDENCE_DIR}/${name}.md`;
-var evidenceUrl = (name) => `${REPO_BLOB}/${evidencePath(name)}`;
-var createRule = import_utils.ESLintUtils.RuleCreator(evidenceUrl);
+var TESTS_DIR = "packages/typescript/tests/rules";
+var examplesPath = (name) => `${TESTS_DIR}/${name}.test.ts`;
+var examplesUrl = (name) => `${REPO_BLOB}/${examplesPath(name)}`;
+var createRule = import_utils.ESLintUtils.RuleCreator(examplesUrl);
 
 // src/rules/_paths.ts
 var SCRIPT_FILE_RE = /([\\/]scripts[\\/])|(\.mjs$)/;
@@ -133,8 +133,8 @@ var enforce_file_structure_default = createRule({
     }
     return {
       Program(node) {
-        const body = node.body;
-        const misplacedUseServer = body.find(
+        const body2 = node.body;
+        const misplacedUseServer = body2.find(
           (statement, index) => index > 0 && isUseServerDirective(statement)
         );
         if (misplacedUseServer !== void 0) {
@@ -145,7 +145,7 @@ var enforce_file_structure_default = createRule({
         }
         let seenBody = false;
         let inMisplacedRun = false;
-        for (const statement of body) {
+        for (const statement of body2) {
           if (isStringDirective(statement)) continue;
           switch (classifyStatement(statement)) {
             case "reexport":
@@ -366,11 +366,11 @@ var PROTECTED_SIGNALS = [
   SECURITY_RE,
   VENDOR_RE
 ];
-function isProtected(body) {
-  return PROTECTED_SIGNALS.some((signal) => signal.test(body));
+function isProtected(body2) {
+  return PROTECTED_SIGNALS.some((signal) => signal.test(body2));
 }
-function hasExternalReference(body) {
-  return REF_RE.test(body);
+function hasExternalReference(body2) {
+  return REF_RE.test(body2);
 }
 var STOPWORDS = new Set(
   `a an the this that these those it its their his her our your my
@@ -518,9 +518,9 @@ function restatableStatementBelow(comment, sourceCode) {
   }
   return null;
 }
-function restatesStatementHead(body, statement) {
+function restatesStatementHead(body2, statement) {
   if (statement === null) return false;
-  const words = body.match(/[A-Za-z][\w$]*/g) ?? [];
+  const words = body2.match(/[A-Za-z][\w$]*/g) ?? [];
   const opener = words[0];
   if (opener === void 0 || words.length > NARRATION_MAX_WORDS) return false;
   if (!NARRATION_VERB_RE.test(opener)) return false;
@@ -533,6 +533,14 @@ function restatesStatementHead(body, statement) {
 
 // src/rules/no-comment-cruft.ts
 var LEADING_PREAMBLE_MIN = 4;
+var WALL_MIN_STATEMENTS = 4;
+var WALL_MIN_COMMENTS = 3;
+var WALL_MIN_COMMENTED_RATIO = 0.6;
+var WALL_MIN_WEAK_RATIO = 0.75;
+var WALL_MAX_WORDS = 18;
+var WALL_MAX_NOVEL_WORDS = 2;
+var WALL_NARRATION_RE = /^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|now|finally|lastly|add|append|assign|await|build|calculate|call|check|clear|close|compute|convert|copy|count|create|declare|define|delete|extract|fetch|filter|find|format|generate|get|handle|initialize|insert|iterate|join|load|log|loop|map|merge|open|parse|print|process|push|read|remove|render|reset|return|save|send|set|setup|sort|split|start|stop|store|update|validate|wrap|write)(?:s|es|d|ed|ing)?\b/i;
+var WALL_STEP_PREFIX_RE = /^(?:\d+[.)]|(?:phase|step)\s+\d+\s*:)\s*/i;
 var STEP_NARRATION_RE = /^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|after(?:wards| that)?|finally|lastly|now)\s*[,:]\s*\S/i;
 var META_COMMENTARY_RE = /\b(?:keeping (?:it|this) simple|could be (?:refactored|improved|cleaned up|simplified)|refactor(?:ed|ing)? (?:later|this)|not sure (?:if|whether|why|how)|quick[- ](?:and[- ]dirty|fix)|(?:a |bit of a )?hacky|is a hack|temporary (?:solution|workaround|fix|hack)|revisit (?:this|later|below)|clean (?:this|it) up|not ideal|placeholder for now)\b/i;
 var FOR_NOW_RE = /\bfor now\b/i;
@@ -711,11 +719,11 @@ function isProse(text) {
   return false;
 }
 var JUSTIFICATION_RE = /\b(?:because|since|until|due to|so that|so we|so it|so the|otherwise|which is why|in order to|to avoid|to work around|to prevent|backwards? compat(?:ibility)?|for compatibility)\b/i;
-function restatesWholeStatement(body, statement) {
-  return statement !== null && restatesStatementHead(body, statement.replaceAll("(", " "));
+function restatesWholeStatement(body2, statement) {
+  return statement !== null && restatesStatementHead(body2, statement.replaceAll("(", " "));
 }
-function isRedundantNarration(body, statementBelow, standalone, isolatedEnumeration, nested) {
-  const t = body.trim();
+function isRedundantNarration(body2, statementBelow, standalone, isolatedEnumeration, nested) {
+  const t = body2.trim();
   if (!t || looksLikeCode(t) || hasPseudocode(t)) return false;
   if (standalone) {
     const justified = JUSTIFICATION_RE.test(t);
@@ -745,6 +753,63 @@ var STATEMENT_CONTAINERS = /* @__PURE__ */ new Set([
   import_utils6.AST_NODE_TYPES.TSModuleBlock,
   import_utils6.AST_NODE_TYPES.TSInterfaceBody
 ]);
+function directStatements(container) {
+  switch (container.type) {
+    case import_utils6.AST_NODE_TYPES.Program:
+    case import_utils6.AST_NODE_TYPES.BlockStatement:
+    case import_utils6.AST_NODE_TYPES.ClassBody:
+    case import_utils6.AST_NODE_TYPES.StaticBlock:
+    case import_utils6.AST_NODE_TYPES.TSModuleBlock:
+      return container.body;
+    case import_utils6.AST_NODE_TYPES.SwitchCase:
+      return container.consequent;
+    case import_utils6.AST_NODE_TYPES.TSInterfaceBody:
+      return container.body;
+    default:
+      return [];
+  }
+}
+var WALL_STATEMENTS = /* @__PURE__ */ new Set([
+  import_utils6.AST_NODE_TYPES.ExpressionStatement,
+  import_utils6.AST_NODE_TYPES.ReturnStatement,
+  import_utils6.AST_NODE_TYPES.ThrowStatement,
+  import_utils6.AST_NODE_TYPES.VariableDeclaration,
+  import_utils6.AST_NODE_TYPES.IfStatement,
+  import_utils6.AST_NODE_TYPES.ForStatement,
+  import_utils6.AST_NODE_TYPES.ForOfStatement,
+  import_utils6.AST_NODE_TYPES.ForInStatement,
+  import_utils6.AST_NODE_TYPES.WhileStatement,
+  import_utils6.AST_NODE_TYPES.DoWhileStatement,
+  import_utils6.AST_NODE_TYPES.SwitchStatement,
+  import_utils6.AST_NODE_TYPES.TryStatement
+]);
+function statementAttachmentBelow(comment, sourceCode) {
+  const token = sourceCode.getTokenAfter(comment, { includeComments: false });
+  if (token === null || token.loc.start.line !== comment.loc.end.line + 1 || token.loc.start.column !== comment.loc.start.column) {
+    return null;
+  }
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node?.parent != null; node = node.parent) {
+    if (!STATEMENT_CONTAINERS.has(node.parent.type) || !WALL_STATEMENTS.has(node.type)) {
+      continue;
+    }
+    const siblings = directStatements(node.parent);
+    const index = siblings.indexOf(node);
+    return index < 0 ? null : { container: node.parent, index, statement: sourceCode.getText(node) };
+  }
+  return null;
+}
+function isWeakWalkthroughComment(body2, statement) {
+  const normalized = body2.replace(WALL_STEP_PREFIX_RE, "");
+  if (normalized.length === 0 || normalized.endsWith("?") || normalized.split(/\s+/).length > WALL_MAX_WORDS || isDirective(normalized) || isProtected(normalized) || !WALL_NARRATION_RE.test(normalized)) {
+    return false;
+  }
+  const words = contentTokens(normalized);
+  const described = words.slice(1);
+  if (described.length === 0) return false;
+  const code = codeTokens(statement);
+  const matched = described.filter((word) => restates([word], code)).length;
+  return matched / described.length >= 0.5 && described.length - matched <= WALL_MAX_NOVEL_WORDS;
+}
 var TYPE_MEMBER_CONTAINERS = /* @__PURE__ */ new Set([
   import_utils6.AST_NODE_TYPES.TSInterfaceBody,
   import_utils6.AST_NODE_TYPES.TSTypeLiteral
@@ -771,8 +836,8 @@ var LEAD_IN_SCAN_LIMIT = 24;
 function hasIllustrationLeadInAbove(comments, index) {
   for (let i = index - 1; i >= 0 && index - i <= LEAD_IN_SCAN_LIMIT; i--) {
     if (!areAdjacentLineComments(comments[i], comments[i + 1])) return false;
-    const body = stripCommentMarker(comments[i]?.value ?? "");
-    if (body.length > 0 && body.endsWith(":")) return true;
+    const body2 = stripCommentMarker(comments[i]?.value ?? "");
+    if (body2.length > 0 && body2.endsWith(":")) return true;
   }
   return false;
 }
@@ -800,6 +865,7 @@ var no_comment_cruft_default = createRule({
       commentedOutCode: "Commented-out code \u2014 delete it; git history remembers.",
       sectionBanner: "Section-banner / region comment \u2014 structure code with functions, not ASCII rules.",
       fileHeaderPreamble: "File-header comment preamble \u2014 use a brief doc comment for the why, not a block of `//` lines.",
+      commentWall: "Statement comment wall ({{count}} narrated steps) \u2014 delete the walkthrough and name the operations in code; keep only constraints or rationale.",
       redundantNarration: "Comment narrates the code \u2014 delete it or say *why*, not *what*. Code is self-documenting.",
       untrackedTodo: "Untracked TODO/FIXME marker \u2014 add an issue ticket or context link."
     }
@@ -819,6 +885,48 @@ var no_comment_cruft_default = createRule({
     function isJsDoc(comment) {
       return comment.type === "Block" && /^\*/.test(comment.value);
     }
+    function findCommentWalls(comments) {
+      const attached = /* @__PURE__ */ new Map();
+      for (const comment of comments) {
+        if (comment.type !== "Line" || !isStandalone(comment)) continue;
+        const attachment = statementAttachmentBelow(comment, sourceCode);
+        if (attachment === null) continue;
+        const body2 = stripCommentMarker(comment.value);
+        const entries = attached.get(attachment.container) ?? [];
+        entries.push({
+          comment,
+          index: attachment.index,
+          weak: isWeakWalkthroughComment(body2, attachment.statement)
+        });
+        attached.set(attachment.container, entries);
+      }
+      const walls = [];
+      for (const entries of attached.values()) {
+        const sorted = entries.toSorted((left, right) => left.index - right.index);
+        const clusters = [];
+        for (const entry of sorted) {
+          const cluster = clusters.at(-1);
+          if (cluster !== void 0 && entry.index <= (cluster.at(-1)?.index ?? 0) + 2) {
+            cluster.push(entry);
+          } else {
+            clusters.push([entry]);
+          }
+        }
+        for (const cluster of clusters) {
+          const firstIndex = cluster[0]?.index;
+          const lastIndex = cluster.at(-1)?.index;
+          if (firstIndex === void 0 || lastIndex === void 0) continue;
+          const span = lastIndex - firstIndex + 1;
+          const weak = cluster.filter((entry) => entry.weak).map((entry) => entry.comment);
+          if (span < WALL_MIN_STATEMENTS || weak.length < WALL_MIN_COMMENTS || cluster.length / span < WALL_MIN_COMMENTED_RATIO || weak.length / cluster.length < WALL_MIN_WEAK_RATIO) {
+            continue;
+          }
+          const leader = weak[0];
+          if (leader !== void 0) walls.push({ leader, members: new Set(weak) });
+        }
+      }
+      return walls;
+    }
     function isSectionJsDoc(comment) {
       const texts = comment.value.split("\n").map(stripCommentMarker).filter((line) => line.length > 0 && !isDirective(line));
       return texts.length > 0 && texts.every(
@@ -832,8 +940,8 @@ var no_comment_cruft_default = createRule({
         if (comment.type !== "Line") break;
         if (comment.loc.start.line >= firstCodeLine) break;
         if (!isStandalone(comment)) break;
-        const body = stripCommentMarker(comment.value);
-        if (isDirective(body) || body.startsWith("!")) continue;
+        const body2 = stripCommentMarker(comment.value);
+        if (isDirective(body2) || body2.startsWith("!")) continue;
         if (prevLine !== null && comment.loc.start.line !== prevLine + 1) break;
         leading.push(comment);
         prevLine = comment.loc.start.line;
@@ -841,8 +949,8 @@ var no_comment_cruft_default = createRule({
       const first = leading[0];
       if (first === void 0 || leading.length < LEADING_PREAMBLE_MIN) return;
       const bodies = leading.map((c) => stripCommentMarker(c.value));
-      if (bodies.some((body) => LICENSE_RE.test(body))) return;
-      if (bodies.some((body) => isProse(body))) return;
+      if (bodies.some((body2) => LICENSE_RE.test(body2))) return;
+      if (bodies.some((body2) => isProse(body2))) return;
       if (bodies.filter(isEnumeratedProseItem).length >= ENUMERATED_PREAMBLE_MIN_ITEMS) {
         return;
       }
@@ -851,6 +959,9 @@ var no_comment_cruft_default = createRule({
     return {
       Program() {
         const comments = sourceCode.getAllComments();
+        const walls = findCommentWalls(comments);
+        const wallByLeader = new Map(walls.map((wall) => [wall.leader, wall]));
+        const wallMembers = new Set(walls.flatMap((wall) => [...wall.members]));
         const firstCodeLine = sourceCode.ast.tokens[0]?.loc.start.line ?? Number.MAX_SAFE_INTEGER;
         const enumerated = comments.filter(
           (c) => c.type === "Line" && ENUMERATION_RE.test(stripCommentMarker(c.value))
@@ -858,6 +969,16 @@ var no_comment_cruft_default = createRule({
         for (let i = 0; i < comments.length; i++) {
           const comment = comments[i];
           if (comment === void 0) continue;
+          const wall = wallByLeader.get(comment);
+          if (wall !== void 0) {
+            context.report({
+              node: comment,
+              messageId: "commentWall",
+              data: { count: String(wall.members.size) }
+            });
+            continue;
+          }
+          if (wallMembers.has(comment)) continue;
           if (isJsDoc(comment)) {
             if (isStandalone(comment) && isSectionJsDoc(comment)) {
               context.report({ node: comment, messageId: "sectionBanner" });
@@ -890,11 +1011,11 @@ var no_comment_cruft_default = createRule({
             continue;
           }
           if (comment.type === "Line" && texts.length === 1) {
-            const body = texts[0];
+            const body2 = texts[0];
             const statement = restatableStatementBelow(comment, sourceCode);
             const standalone = !isInsideCommentRun(comments, i);
             const nested = container !== null && !STATEMENT_CONTAINERS.has(container.type);
-            if (body !== void 0 && !runCitesAReference(comments, i) && isRedundantNarration(body, statement, standalone, enumerated.length === 1, nested)) {
+            if (body2 !== void 0 && !runCitesAReference(comments, i) && isRedundantNarration(body2, statement, standalone, enumerated.length === 1, nested)) {
               context.report({ node: comment, messageId: "redundantNarration" });
             }
           }
@@ -908,11 +1029,12 @@ var no_comment_cruft_default = createRule({
 // src/rules/no-conditional-in-test.ts
 var import_utils7 = require("@typescript-eslint/utils");
 var TEST_CALLERS = /* @__PURE__ */ new Set(["it", "test"]);
-var HOOK_MEMBERS = /* @__PURE__ */ new Set([
+var NON_TEST_MEMBERS = /* @__PURE__ */ new Set([
   "afterAll",
   "afterEach",
   "beforeAll",
-  "beforeEach"
+  "beforeEach",
+  "describe"
 ]);
 var FUNCTION_TYPES = /* @__PURE__ */ new Set([
   import_utils7.AST_NODE_TYPES.FunctionDeclaration,
@@ -952,12 +1074,27 @@ function testCallerName(callee) {
   }
   return null;
 }
+function hasNonTestMember(callee) {
+  if (callee.type === import_utils7.AST_NODE_TYPES.MemberExpression) {
+    if (!callee.computed && callee.property.type === import_utils7.AST_NODE_TYPES.Identifier && NON_TEST_MEMBERS.has(callee.property.name)) {
+      return true;
+    }
+    return hasNonTestMember(callee.object);
+  }
+  if (callee.type === import_utils7.AST_NODE_TYPES.CallExpression) {
+    return hasNonTestMember(callee.callee);
+  }
+  if (callee.type === import_utils7.AST_NODE_TYPES.TaggedTemplateExpression) {
+    return hasNonTestMember(callee.tag);
+  }
+  return false;
+}
 function isTestBody(fn) {
   const call = fn.parent;
   if (call?.type !== import_utils7.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
-  if (call.callee.type === import_utils7.AST_NODE_TYPES.MemberExpression && !call.callee.computed && call.callee.property.type === import_utils7.AST_NODE_TYPES.Identifier && HOOK_MEMBERS.has(call.callee.property.name)) {
+  if (hasNonTestMember(call.callee)) {
     return false;
   }
   const name = testCallerName(call.callee);
@@ -1683,6 +1820,7 @@ var no_enum_default = createRule({
         properties: {
           ignoreFiles: {
             type: "array",
+            description: "Additional generated-file globs to ignore; shared generated paths and header markers are always ignored.",
             items: { type: "string" }
           }
         }
@@ -1892,8 +2030,8 @@ function handlerRethrows(handler) {
   if (handler === null) {
     return false;
   }
-  const body = handler.body.body;
-  const last = body[body.length - 1];
+  const body2 = handler.body.body;
+  const last = body2[body2.length - 1];
   return last !== void 0 && last.type === import_utils12.AST_NODE_TYPES.ThrowStatement;
 }
 var PASS_THROUGH_PARENTS = /* @__PURE__ */ new Set([
@@ -1927,8 +2065,8 @@ function unwrapAwait(expr) {
   return inner.type === import_utils12.AST_NODE_TYPES.AwaitExpression ? unwrap(inner.argument) : inner;
 }
 function handlerEndsByHandingOff(handler) {
-  const body = handler.body.body;
-  const last = body[body.length - 1];
+  const body2 = handler.body.body;
+  const last = body2[body2.length - 1];
   if (last === void 0) {
     return false;
   }
@@ -2502,8 +2640,8 @@ function negatedInstanceofErrorSubject(test) {
   return null;
 }
 function branchTerminates(branch) {
-  const body = branch.type === "BlockStatement" ? branch.body : [branch];
-  const last = body[body.length - 1];
+  const body2 = branch.type === "BlockStatement" ? branch.body : [branch];
+  const last = body2[body2.length - 1];
   return last !== void 0 && (last.type === "ReturnStatement" || last.type === "ThrowStatement");
 }
 function isNarrowedByEarlyReturn(node, argExpr, sourceCode) {
@@ -2755,8 +2893,8 @@ function hasFollowingStatement(node) {
   return false;
 }
 function fallbackFollowsTry(tryStatement) {
-  const body = tryStatement.block.body;
-  const last = body.at(-1);
+  const body2 = tryStatement.block.body;
+  const last = body2.at(-1);
   return last?.type === import_utils17.AST_NODE_TYPES.ReturnStatement && hasFollowingStatement(tryStatement);
 }
 function isSeedValue(node) {
@@ -2873,8 +3011,125 @@ var no_log_only_catch_default = createRule({
   }
 });
 
-// src/rules/no-offset-pagination.ts
+// src/rules/_prose-budget.ts
 var import_utils18 = require("@typescript-eslint/utils");
+var DIRECTIVE_RE2 = /^(?:!|eslint\b|eslint-|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|@vite|webpack|@jsx|@jest-environment|@vitest-environment|#__|todo\b|fixme\b|hack\b)/i;
+var LICENSE_RE2 = /\b(?:copyright|spdx-license-identifier|licensed under)\b/i;
+var TYPED_TAG_RE = /@(arg|argument|param|return|returns|yield|yields)\b/i;
+var VALUE_TAG_RE = /@(example|deprecated|see|remarks|throws|internal|public|alpha|beta|since|template|fileoverview)\b/i;
+var BOUNDARY_RE = /(?<=[.!?])["'`)\]]*\s+(?=[A-Z0-9`])/;
+var BULLET_RE = /^\s*(?:[-*+] |\d+[.)] )/;
+function body(comment) {
+  return comment.value.replace(/^\*/, "").split("\n").map((line) => line.replace(/^\s*\*?\s?/, "")).join("\n").trim();
+}
+function eligible(text, includeValueTags) {
+  return text.length > 0 && !DIRECTIVE_RE2.test(text) && !LICENSE_RE2.test(text) && (includeValueTags || !VALUE_TAG_RE.test(text));
+}
+function sentenceUnits(text) {
+  const cleaned = text.replace(/https?:\/\/\S+/g, "URL").replace(/`[^`\n]+`/g, "CODE").replace(/\b\d+\.\d+\b/g, "NUMBER").replace(/\b(?:e\.g\.|i\.e\.|vs\.|etc\.)/gi, "ABBREVIATION");
+  let units = 0;
+  const prose = [];
+  for (const raw of cleaned.split("\n")) {
+    const line = raw.trim();
+    if (line.length === 0 || /^[A-Za-z][A-Za-z ]+:$/.test(line)) continue;
+    if (BULLET_RE.test(line)) units += 1;
+    else prose.push(line);
+  }
+  if (prose.length > 0) units += prose.join(" ").split(BOUNDARY_RE).length;
+  return units;
+}
+function proseGroups(filename, sourceCode, includeValueTags = false) {
+  if (isGeneratedFile(filename, sourceCode.text) || isStoryFile(filename)) return [];
+  const groups = [];
+  let run = [];
+  const flush = () => {
+    if (run.length === 0) return;
+    const text = run.map(body).join("\n");
+    if (eligible(text, includeValueTags)) groups.push({ comment: run[0], text, hasTypedTags: TYPED_TAG_RE.test(text) });
+    run = [];
+  };
+  for (const comment of sourceCode.getAllComments()) {
+    const text = body(comment);
+    if (comment.type === "Block") {
+      flush();
+      if (eligible(text, includeValueTags)) groups.push({ comment, text, hasTypedTags: TYPED_TAG_RE.test(text) });
+      continue;
+    }
+    const ownLine = sourceCode.lines[comment.loc.start.line - 1]?.slice(0, comment.loc.start.column).trim() === "";
+    if (!ownLine || !eligible(text, includeValueTags)) {
+      flush();
+      continue;
+    }
+    const previous = run.at(-1);
+    if (previous !== void 0 && (comment.loc.start.line !== previous.loc.end.line + 1 || comment.loc.start.column !== previous.loc.start.column)) flush();
+    run.push(comment);
+  }
+  flush();
+  return groups;
+}
+function annotatedParameter(parameter) {
+  if (parameter.type === import_utils18.AST_NODE_TYPES.TSParameterProperty) return annotatedParameter(parameter.parameter);
+  const target = parameter.type === import_utils18.AST_NODE_TYPES.AssignmentPattern ? parameter.left : parameter;
+  return "typeAnnotation" in target && target.typeAnnotation != null;
+}
+function typedFunction(node) {
+  switch (node.type) {
+    case import_utils18.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils18.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return node.declaration != null && typedFunction(node.declaration);
+    case import_utils18.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils18.AST_NODE_TYPES.TSDeclareFunction:
+      return node.returnType != null && node.params.every(annotatedParameter);
+    case import_utils18.AST_NODE_TYPES.VariableDeclaration: {
+      const init = node.declarations[0]?.init;
+      return init != null && (init.type === import_utils18.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils18.AST_NODE_TYPES.FunctionExpression) && init.returnType != null && init.params.every(annotatedParameter);
+    }
+    case import_utils18.AST_NODE_TYPES.MethodDefinition:
+      return node.value.returnType != null && node.value.params.every(annotatedParameter);
+    case import_utils18.AST_NODE_TYPES.TSMethodSignature:
+      return node.returnType != null && node.params.every(annotatedParameter);
+    default:
+      return false;
+  }
+}
+function documentsTypedFunction(sourceCode, comment) {
+  const token = sourceCode.getTokenAfter(comment, { includeComments: false });
+  if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return false;
+  let node = sourceCode.getNodeByRangeIndex(token.range[0]);
+  while (node != null && node.type !== import_utils18.AST_NODE_TYPES.Program) {
+    if (typedFunction(node)) return true;
+    node = node.parent ?? null;
+  }
+  return false;
+}
+
+// src/rules/no-long-comment.ts
+var no_long_comment_default = createRule({
+  name: "no-long-comment",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Limit in-code prose to two sentences." },
+    schema: [],
+    messages: {
+      tooLong: "Comment exceeds two sentences \u2014 keep one local fact and clarify the code itself."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const group of proseGroups(context.filename, context.sourceCode)) {
+          if (!group.hasTypedTags && sentenceUnits(group.text) >= 3) {
+            context.report({ node: group.comment, messageId: "tooLong" });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-offset-pagination.ts
+var import_utils19 = require("@typescript-eslint/utils");
 var OFFSET_PAGINATION = /\bOFFSET\s+(?:%s|%\(\w+\)s|\?\d*|:\w+|@\w+|\$\d+|\d+)/i;
 var OFFSET_GATE = /offset/i;
 var no_offset_pagination_default = createRule({
@@ -2904,15 +3159,15 @@ var no_offset_pagination_default = createRule({
 });
 
 // src/rules/no-positional-tuple-return.ts
-var import_utils19 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 var MIN_ELEMENTS = 2;
 var ACCESSOR_PAIR_LENGTH = 2;
 var AWAITABLE_TYPES = /* @__PURE__ */ new Set(["Promise", "PromiseLike", "Awaited"]);
 function tupleReturnType(node) {
-  if (node.type === import_utils19.AST_NODE_TYPES.TSTupleType) {
+  if (node.type === import_utils20.AST_NODE_TYPES.TSTupleType) {
     return node;
   }
-  if (node.type === import_utils19.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils19.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
+  if (node.type === import_utils20.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils20.AST_NODE_TYPES.Identifier && AWAITABLE_TYPES.has(node.typeName.name)) {
     const argument = node.typeArguments?.params[0];
     return argument === void 0 ? null : tupleReturnType(argument);
   }
@@ -2926,30 +3181,30 @@ function isPermittedTuple(tuple, sourceCode) {
   if (elements.length < MIN_ELEMENTS) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils19.AST_NODE_TYPES.TSRestType)) {
+  if (elements.some((element) => element.type === import_utils20.AST_NODE_TYPES.TSRestType)) {
     return true;
   }
-  if (elements.some((element) => element.type === import_utils19.AST_NODE_TYPES.TSNamedTupleMember)) {
+  if (elements.some((element) => element.type === import_utils20.AST_NODE_TYPES.TSNamedTupleMember)) {
     return true;
   }
-  if (elements[0]?.type === import_utils19.AST_NODE_TYPES.TSLiteralType) {
+  if (elements[0]?.type === import_utils20.AST_NODE_TYPES.TSLiteralType) {
     return true;
   }
-  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils19.AST_NODE_TYPES.TSFunctionType)) {
+  if (elements.length === ACCESSOR_PAIR_LENGTH && elements.some((element) => element.type === import_utils20.AST_NODE_TYPES.TSFunctionType)) {
     return true;
   }
   const texts = new Set(elements.map((element) => normalizedText(sourceCode, element)));
   return texts.size === 1;
 }
 function functionName(node) {
-  if (node.type === import_utils19.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils20.AST_NODE_TYPES.FunctionDeclaration) {
     return node.id?.name ?? null;
   }
   const parent = node.parent;
-  if (parent?.type === import_utils19.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils19.AST_NODE_TYPES.Identifier) {
+  if (parent?.type === import_utils20.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return parent.id.name;
   }
-  if ((parent?.type === import_utils19.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils19.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils19.AST_NODE_TYPES.Property) && parent.key.type === import_utils19.AST_NODE_TYPES.Identifier) {
+  if ((parent?.type === import_utils20.AST_NODE_TYPES.MethodDefinition || parent?.type === import_utils20.AST_NODE_TYPES.PropertyDefinition || parent?.type === import_utils20.AST_NODE_TYPES.Property) && parent.key.type === import_utils20.AST_NODE_TYPES.Identifier) {
     return parent.key.name;
   }
   return null;
@@ -2957,7 +3212,7 @@ function functionName(node) {
 function isInlineExported(node) {
   for (let current = node; current != null; current = current.parent) {
     const parent = current.parent;
-    if (parent?.type === import_utils19.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils19.AST_NODE_TYPES.ExportDefaultDeclaration) {
+    if (parent?.type === import_utils20.AST_NODE_TYPES.ExportNamedDeclaration || parent?.type === import_utils20.AST_NODE_TYPES.ExportDefaultDeclaration) {
       return true;
     }
   }
@@ -2966,18 +3221,18 @@ function isInlineExported(node) {
 function moduleScopeBindingName(node) {
   let current = node;
   let child = node;
-  while (current.parent != null && current.parent.type !== import_utils19.AST_NODE_TYPES.Program) {
+  while (current.parent != null && current.parent.type !== import_utils20.AST_NODE_TYPES.Program) {
     child = current;
     current = current.parent;
   }
-  if (current.parent?.type !== import_utils19.AST_NODE_TYPES.Program) {
+  if (current.parent?.type !== import_utils20.AST_NODE_TYPES.Program) {
     return null;
   }
-  if (current.type === import_utils19.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils19.AST_NODE_TYPES.ClassDeclaration) {
+  if (current.type === import_utils20.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils20.AST_NODE_TYPES.ClassDeclaration) {
     return current.id?.name ?? null;
   }
-  if (current.type === import_utils19.AST_NODE_TYPES.VariableDeclaration) {
-    if (child.type !== import_utils19.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils19.AST_NODE_TYPES.Identifier) {
+  if (current.type === import_utils20.AST_NODE_TYPES.VariableDeclaration) {
+    if (child.type !== import_utils20.AST_NODE_TYPES.VariableDeclarator || child.id.type !== import_utils20.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return child.id.name;
@@ -2987,19 +3242,19 @@ function moduleScopeBindingName(node) {
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type === import_utils19.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
+    if (statement.type === import_utils20.AST_NODE_TYPES.ExportNamedDeclaration && statement.declaration == null && statement.source == null && statement.exportKind !== "type") {
       for (const specifier of statement.specifiers) {
-        if (specifier.exportKind !== "type" && specifier.local.type === import_utils19.AST_NODE_TYPES.Identifier) {
+        if (specifier.exportKind !== "type" && specifier.local.type === import_utils20.AST_NODE_TYPES.Identifier) {
           names.add(specifier.local.name);
         }
       }
       continue;
     }
-    if (statement.type === import_utils19.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils19.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils20.AST_NODE_TYPES.ExportDefaultDeclaration && statement.declaration.type === import_utils20.AST_NODE_TYPES.Identifier) {
       names.add(statement.declaration.name);
       continue;
     }
-    if (statement.type === import_utils19.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils19.AST_NODE_TYPES.Identifier) {
+    if (statement.type === import_utils20.AST_NODE_TYPES.TSExportAssignment && statement.expression.type === import_utils20.AST_NODE_TYPES.Identifier) {
       names.add(statement.expression.name);
     }
   }
@@ -3061,7 +3316,7 @@ var no_positional_tuple_return_default = createRule({
 });
 
 // src/rules/no-raw-env.ts
-var import_utils20 = require("@typescript-eslint/utils");
+var import_utils21 = require("@typescript-eslint/utils");
 var CONFIG_FILE_RE = /(^|[\\/])[\w.-]+\.config\.[cm]?[jt]sx?$/;
 var ENV_BOUNDARY_FILE_RE = /(^|[\\/])(?:env|client-env|server-env|client-settings|server-settings)\.[cm]?[jt]sx?$/;
 var ENV_VALIDATION_MARKER_RE = /\bcreateEnv\s*\(|\bz\.object\s*\(|\.(?:safeParse|parse)\s*\(/;
@@ -3111,11 +3366,11 @@ var no_raw_env_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow direct `process.env` access; use a Zod-validated env module instead."
+      description: "Disallow direct `process.env` and `import.meta.env` reads outside validated boundaries."
     },
     schema: [],
     messages: {
-      noRawEnv: "Do not read from `process.env` directly. Import the Zod-validated env module instead so values are typed and validated at startup."
+      noRawEnv: "Do not read raw environment values directly. Import the validated env module so values are typed and checked at startup."
     }
   },
   defaultOptions: [],
@@ -3138,13 +3393,11 @@ var no_raw_env_default = createRule({
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-var import_utils21 = require("@typescript-eslint/utils");
+var import_utils22 = require("@typescript-eslint/utils");
 var DEFAULT_ALLOW = [
   "[\\\\/]clients?[\\\\/]",
   "-client\\.[cm]?[jt]sx?$",
   "[\\\\/]http-client\\.[cm]?[jt]sx?$",
-  // The `api` spelling of the same client-layer convention: an `api/` directory,
-  // a bare `api.ts`, or a `*-api.ts` / `*.api.ts` module.
   "[\\\\/]api[\\\\/]",
   "[\\\\/]api\\.[cm]?[jt]sx?$",
   "[-.]api\\.[cm]?[jt]sx?$",
@@ -3182,7 +3435,7 @@ function identifierLikeName(node) {
 }
 function isConstructedArgumentHandoff(node) {
   const [first] = node.arguments;
-  return node.arguments.length === 1 && first !== void 0 && first.type === import_utils21.AST_NODE_TYPES.NewExpression;
+  return node.arguments.length === 1 && first !== void 0 && first.type === import_utils22.AST_NODE_TYPES.NewExpression;
 }
 function isPresignedUrlTransfer(node) {
   const first = node.arguments[0];
@@ -3251,16 +3504,16 @@ var no_raw_fetch_outside_clients_default = createRule({
 });
 
 // src/rules/no-repeated-string-literal.ts
-var import_utils22 = require("@typescript-eslint/utils");
+var import_utils23 = require("@typescript-eslint/utils");
 var MIN_LENGTH = 40;
 var MIN_DISTINCT_SCOPES = 2;
 var PREVIEW_LENGTH = 40;
 var SQL_KEYWORD_RE = /\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN|VALUES|ON CONFLICT|RETURNING|GROUP BY|ORDER BY)\b/;
 var IDENTIFIER_RE = /^[a-z_][a-z0-9_.]*$/;
 var FUNCTION_TYPES3 = /* @__PURE__ */ new Set([
-  import_utils22.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils22.AST_NODE_TYPES.FunctionExpression,
-  import_utils22.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils23.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils23.AST_NODE_TYPES.FunctionExpression,
+  import_utils23.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isStructured(value) {
   return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
@@ -3282,7 +3535,8 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
-  return parent.type === import_utils22.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils22.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils22.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils22.AST_NODE_TYPES.TSImportType || parent.type === import_utils22.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils22.AST_NODE_TYPES.TSLiteralType;
+  const isRequireSource = parent.type === import_utils23.AST_NODE_TYPES.CallExpression && parent.callee.type === import_utils23.AST_NODE_TYPES.Identifier && parent.callee.name === "require";
+  return parent.type === import_utils23.AST_NODE_TYPES.ImportDeclaration || parent.type === import_utils23.AST_NODE_TYPES.ImportExpression || parent.type === import_utils23.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils23.AST_NODE_TYPES.ExportAllDeclaration || parent.type === import_utils23.AST_NODE_TYPES.TSImportType || parent.type === import_utils23.AST_NODE_TYPES.JSXAttribute || parent.type === import_utils23.AST_NODE_TYPES.TSLiteralType || isRequireSource;
 }
 var no_repeated_string_literal_default = createRule({
   name: "no-repeated-string-literal",
@@ -3322,7 +3576,7 @@ var no_repeated_string_literal_default = createRule({
         }
       },
       TemplateLiteral(node) {
-        if (node.parent.type === import_utils22.AST_NODE_TYPES.TaggedTemplateExpression) {
+        if (node.parent.type === import_utils23.AST_NODE_TYPES.TaggedTemplateExpression) {
           return;
         }
         const [only] = node.quasis;
@@ -3356,10 +3610,10 @@ var no_repeated_string_literal_default = createRule({
 });
 
 // src/rules/no-restated-comment.ts
-var import_utils23 = require("@typescript-eslint/utils");
+var import_utils24 = require("@typescript-eslint/utils");
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
-var DIRECTIVE_RE2 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
+var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
 var CODEY_RE = /^[\w.$[\]'"]+\s*[:=]\s*\S|^[\w.$]+\s*\(|^(?:return|throw|await|import|export|const|let|var)\b.*[=()[\]{}]/;
 var BANNERISH_RE = /[=\-─-╿*#~_.]{3,}|^[A-Z0-9 _:-]+$/;
 var MODALITY_RE = /\b(?:can|could|should|shall|may|might|must|will|would|cannot)\b/i;
@@ -3368,16 +3622,19 @@ var EMPHASIS_RE = /\*\w[^*]*\*|`[^`]+`/;
 var NEGATION_WORD_RE = /\b(?:no|not|never|neither|nor|without|none|non)\b/i;
 var ACTION_STMT_RE = /[\w.$\])]\s*\(|^\s*(?:return|throw|await|yield)\b/;
 var NON_ASCII_LETTER_RE = /[^\p{ASCII}\p{N}\p{P}\p{Z}]/u;
+var WALL_NARRATION_RE2 = /^(?:(?:\d+[.)]|(?:phase|step)\s+\d+\s*:?)\s*)?(?:add|build|call|check|compute|copy|count|create|fetch|filter|find|get|handle|load|map|merge|parse|process|read|remove|return|save|send|set|sort|store|update|validate|write)(?:s|es|d|ed|ing)?\b/i;
+var WALL_CLUSTER_MAX_LINE_GAP = 8;
+var WALL_CLUSTER_MIN_COMMENTS = 3;
 function areAdjacentLineComments2(a, b) {
   return a !== void 0 && b !== void 0 && a.type === "Line" && b.type === "Line" && b.loc.start.line === a.loc.end.line + 1;
 }
 function headsSiblingRun(node) {
   const parent = node.parent;
   if (parent === void 0) return false;
-  const body = "body" in parent && Array.isArray(parent.body) ? parent.body : void 0;
-  if (body === void 0) return false;
-  const index = body.indexOf(node);
-  const next = index >= 0 ? body[index + 1] : void 0;
+  const body2 = "body" in parent && Array.isArray(parent.body) ? parent.body : void 0;
+  if (body2 === void 0) return false;
+  const index = body2.indexOf(node);
+  const next = index >= 0 ? body2[index + 1] : void 0;
   return next !== void 0 && next.type === node.type;
 }
 var no_restated_comment_default = createRule({
@@ -3406,7 +3663,7 @@ var no_restated_comment_default = createRule({
     function labelsASiblingRun(comment) {
       const token = sourceCode.getTokenAfter(comment, { includeComments: false });
       if (token === null) return false;
-      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils23.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== import_utils24.AST_NODE_TYPES.Program; node = node.parent) {
         if (headsSiblingRun(node)) return true;
       }
       return false;
@@ -3414,25 +3671,45 @@ var no_restated_comment_default = createRule({
     return {
       Program() {
         const comments = sourceCode.getAllComments();
+        const wallMembers = /* @__PURE__ */ new Set();
+        let cluster = [];
+        for (const candidate of comments) {
+          const body2 = candidate.value.replace(/^\/*/, "").trim();
+          if (candidate.type !== "Line" || !isStandalone(candidate) || isProtected(body2) || !WALL_NARRATION_RE2.test(body2)) {
+            continue;
+          }
+          const previous = cluster.at(-1);
+          if (previous !== void 0 && candidate.loc.start.line - previous.loc.start.line > WALL_CLUSTER_MAX_LINE_GAP) {
+            if (cluster.length >= WALL_CLUSTER_MIN_COMMENTS) {
+              for (const member of cluster) wallMembers.add(member);
+            }
+            cluster = [];
+          }
+          cluster.push(candidate);
+        }
+        if (cluster.length >= WALL_CLUSTER_MIN_COMMENTS) {
+          for (const member of cluster) wallMembers.add(member);
+        }
         for (let i = 0; i < comments.length; i++) {
           const comment = comments[i];
           if (comment === void 0 || comment.type !== "Line") continue;
+          if (wallMembers.has(comment)) continue;
           if (!isStandalone(comment)) continue;
           if (areAdjacentLineComments2(comments[i - 1], comment) || areAdjacentLineComments2(comment, comments[i + 1])) {
             continue;
           }
-          const body = comment.value.replace(/^\/*/, "").trim();
-          if (body.length === 0 || body.endsWith("?")) continue;
-          if (DIRECTIVE_RE2.test(body) || CODEY_RE.test(body) || BANNERISH_RE.test(body)) continue;
-          if (NON_ASCII_LETTER_RE.test(body) || isProtected(body)) continue;
-          if (MODALITY_RE.test(body) || LEAD_IN_RE.test(body) || EMPHASIS_RE.test(body)) continue;
-          if (NEGATION_WORD_RE.test(body)) continue;
-          if (body.split(/\s+/).length > MAX_WORDS) continue;
-          const tokens = contentTokens(body);
+          const body2 = comment.value.replace(/^\/*/, "").trim();
+          if (body2.length === 0 || body2.endsWith("?")) continue;
+          if (DIRECTIVE_RE3.test(body2) || CODEY_RE.test(body2) || BANNERISH_RE.test(body2)) continue;
+          if (NON_ASCII_LETTER_RE.test(body2) || isProtected(body2)) continue;
+          if (MODALITY_RE.test(body2) || LEAD_IN_RE.test(body2) || EMPHASIS_RE.test(body2)) continue;
+          if (NEGATION_WORD_RE.test(body2)) continue;
+          if (body2.split(/\s+/).length > MAX_WORDS) continue;
+          const tokens = contentTokens(body2);
           if (tokens.length < MIN_CONTENT_TOKENS) continue;
           const statement = restatableStatementBelow(comment, sourceCode);
           if (statement === null) continue;
-          if (restatesStatementHead(body, statement)) continue;
+          if (restatesStatementHead(body2, statement)) continue;
           const line = lines[comment.loc.start.line] ?? "";
           if (!ACTION_STMT_RE.test(line)) continue;
           if (labelsASiblingRun(comment)) continue;
@@ -3446,7 +3723,7 @@ var no_restated_comment_default = createRule({
 });
 
 // src/rules/no-restated-jsdoc.ts
-var import_utils24 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var MODELLED_TAGS = /* @__PURE__ */ new Set([
   "arg",
   "argument",
@@ -3458,7 +3735,7 @@ var MODELLED_TAGS = /* @__PURE__ */ new Set([
 ]);
 var PARAM_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param"]);
 var RETURN_TAGS = /* @__PURE__ */ new Set(["return", "returns"]);
-var DIRECTIVE_RE3 = /^\s*(?:eslint\b|eslint-|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|@vite|webpack|@jsx|@jest-environment|@vitest-environment|#__)/i;
+var DIRECTIVE_RE4 = /^\s*(?:eslint\b|eslint-|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|@vite|webpack|@jsx|@jest-environment|@vitest-environment|#__)/i;
 var STOPWORDS2 = new Set(
   `the a an of to for in on with and or as at by is are was be been being
    this that it its if whether when where which what will would can could should
@@ -3500,30 +3777,30 @@ function declarationNames(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
-    case import_utils24.AST_NODE_TYPES.ExportNamedDeclaration:
-    case import_utils24.AST_NODE_TYPES.ExportDefaultDeclaration:
+    case import_utils25.AST_NODE_TYPES.ExportNamedDeclaration:
+    case import_utils25.AST_NODE_TYPES.ExportDefaultDeclaration:
       return node.declaration == null ? null : declarationNames(node.declaration);
-    case import_utils24.AST_NODE_TYPES.FunctionDeclaration:
-    case import_utils24.AST_NODE_TYPES.TSDeclareFunction:
+    case import_utils25.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils25.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
-    case import_utils24.AST_NODE_TYPES.ClassDeclaration:
-    case import_utils24.AST_NODE_TYPES.TSInterfaceDeclaration:
-    case import_utils24.AST_NODE_TYPES.TSTypeAliasDeclaration:
-    case import_utils24.AST_NODE_TYPES.TSEnumDeclaration:
+    case import_utils25.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils25.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils25.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils25.AST_NODE_TYPES.TSEnumDeclaration:
       return node.id === null ? null : { name: node.id.name, params: [] };
-    case import_utils24.AST_NODE_TYPES.VariableDeclaration: {
+    case import_utils25.AST_NODE_TYPES.VariableDeclaration: {
       const declarator = node.declarations[0];
-      if (declarator === void 0 || declarator.id.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
+      if (declarator === void 0 || declarator.id.type !== import_utils25.AST_NODE_TYPES.Identifier) return null;
       const init = declarator.init;
-      const params = init != null && (init.type === import_utils24.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils24.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
+      const params = init != null && (init.type === import_utils25.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils25.AST_NODE_TYPES.FunctionExpression) ? paramNames(init.params) : [];
       return { name: declarator.id.name, params };
     }
-    case import_utils24.AST_NODE_TYPES.MethodDefinition:
-    case import_utils24.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils24.AST_NODE_TYPES.TSMethodSignature:
-    case import_utils24.AST_NODE_TYPES.TSPropertySignature: {
-      if (node.key.type !== import_utils24.AST_NODE_TYPES.Identifier) return null;
-      const params = node.type === import_utils24.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils24.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
+    case import_utils25.AST_NODE_TYPES.MethodDefinition:
+    case import_utils25.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils25.AST_NODE_TYPES.TSMethodSignature:
+    case import_utils25.AST_NODE_TYPES.TSPropertySignature: {
+      if (node.key.type !== import_utils25.AST_NODE_TYPES.Identifier) return null;
+      const params = node.type === import_utils25.AST_NODE_TYPES.MethodDefinition ? paramNames(node.value.params) : node.type === import_utils25.AST_NODE_TYPES.TSMethodSignature ? paramNames(node.params) : [];
       return { name: node.key.name, params };
     }
     default:
@@ -3533,9 +3810,9 @@ function declarationNames(node) {
 function paramNames(params) {
   const names = [];
   for (const param of params) {
-    const target = param.type === import_utils24.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
-    if (target.type === import_utils24.AST_NODE_TYPES.Identifier) names.push(target.name);
-    else if (target.type === import_utils24.AST_NODE_TYPES.TSParameterProperty) continue;
+    const target = param.type === import_utils25.AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+    if (target.type === import_utils25.AST_NODE_TYPES.Identifier) names.push(target.name);
+    else if (target.type === import_utils25.AST_NODE_TYPES.TSParameterProperty) continue;
   }
   return names;
 }
@@ -3569,7 +3846,7 @@ var no_restated_jsdoc_default = createRule({
         for (const comment of sourceCode.getAllComments()) {
           if (comment.type !== "Block" || !comment.value.startsWith("*")) continue;
           const { description, tags } = parseJsDoc(comment.value);
-          if (DIRECTIVE_RE3.test(description)) continue;
+          if (DIRECTIVE_RE4.test(description)) continue;
           const tagNames = new Set(tags.map((tag) => tag.name));
           if ([...tagNames].some((name) => !MODELLED_TAGS.has(name))) continue;
           if (isProtected(description)) continue;
@@ -3577,7 +3854,7 @@ var no_restated_jsdoc_default = createRule({
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
           let declaration = null;
-          while (node != null && node.type !== import_utils24.AST_NODE_TYPES.Program) {
+          while (node != null && node.type !== import_utils25.AST_NODE_TYPES.Program) {
             declaration = declarationNames(node);
             if (declaration !== null) break;
             node = node.parent ?? null;
@@ -3632,7 +3909,7 @@ var no_restated_jsdoc_default = createRule({
 });
 
 // src/rules/no-secret-in-log.ts
-var import_utils25 = require("@typescript-eslint/utils");
+var import_utils26 = require("@typescript-eslint/utils");
 
 // src/rules/_secret-names.ts
 var SECRET_WORDS = /* @__PURE__ */ new Set([
@@ -3969,7 +4246,7 @@ var no_secret_in_log_default = createRule({
 });
 
 // src/rules/no-select-star.ts
-var import_utils26 = require("@typescript-eslint/utils");
+var import_utils27 = require("@typescript-eslint/utils");
 var QUERY_SHAPE = /\bSELECT\b[\s\S]*?\bFROM\b/i;
 var SELECT_KEYWORD = /\bSELECT\b/gi;
 var FROM_KEYWORD = /^FROM\b/i;
@@ -4036,12 +4313,12 @@ var no_select_star_default = createRule({
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-var import_utils27 = require("@typescript-eslint/utils");
+var import_utils28 = require("@typescript-eslint/utils");
 function sentinelKind(arg) {
   if (arg === null) {
     return null;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.Literal) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.Literal) {
     if (arg.value === null) {
       return "nullish";
     }
@@ -4053,13 +4330,13 @@ function sentinelKind(arg) {
     }
     return null;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (arg.type === import_utils28.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
     return "nullish";
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.ArrayExpression) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.ArrayExpression) {
     return "array";
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.ObjectExpression) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.ObjectExpression) {
     return "object";
   }
   return null;
@@ -4068,25 +4345,25 @@ function isSentinelArgument(arg) {
   if (arg === null) {
     return false;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.Literal && arg.value === null) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.Literal && arg.value === null) {
     return true;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.Literal && arg.value === false) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.Literal && arg.value === false) {
     return true;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (arg.type === import_utils28.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
     return true;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
     return true;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
     return true;
   }
   return false;
 }
 function isFunctionNode(node) {
-  return node.type === import_utils27.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils27.AST_NODE_TYPES.FunctionExpression || node.type === import_utils27.AST_NODE_TYPES.ArrowFunctionExpression;
+  return node.type === import_utils28.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils28.AST_NODE_TYPES.FunctionExpression || node.type === import_utils28.AST_NODE_TYPES.ArrowFunctionExpression;
 }
 function isNode3(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
@@ -4126,24 +4403,24 @@ function walkWithinScope(node, visit) {
 function containsThrow(node) {
   return walkWithinScope(
     node,
-    (current) => current.type === import_utils27.AST_NODE_TYPES.ThrowStatement
+    (current) => current.type === import_utils28.AST_NODE_TYPES.ThrowStatement
   );
 }
 function bindsName(param, name) {
   switch (param.type) {
-    case import_utils27.AST_NODE_TYPES.Identifier:
+    case import_utils28.AST_NODE_TYPES.Identifier:
       return param.name === name;
-    case import_utils27.AST_NODE_TYPES.AssignmentPattern:
+    case import_utils28.AST_NODE_TYPES.AssignmentPattern:
       return bindsName(param.left, name);
-    case import_utils27.AST_NODE_TYPES.RestElement:
+    case import_utils28.AST_NODE_TYPES.RestElement:
       return bindsName(param.argument, name);
-    case import_utils27.AST_NODE_TYPES.ArrayPattern:
+    case import_utils28.AST_NODE_TYPES.ArrayPattern:
       return param.elements.some(
         (element) => element !== null && bindsName(element, name)
       );
-    case import_utils27.AST_NODE_TYPES.ObjectPattern:
+    case import_utils28.AST_NODE_TYPES.ObjectPattern:
       return param.properties.some(
-        (property) => property.type === import_utils27.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
+        (property) => property.type === import_utils28.AST_NODE_TYPES.RestElement ? bindsName(property.argument, name) : bindsName(property.value, name)
       );
     default:
       return false;
@@ -4158,7 +4435,7 @@ function subtreeReadsName(node, name) {
     if (found) {
       return;
     }
-    if (current.type === import_utils27.AST_NODE_TYPES.Identifier && current.name === name) {
+    if (current.type === import_utils28.AST_NODE_TYPES.Identifier && current.name === name) {
       found = true;
       return;
     }
@@ -4169,10 +4446,10 @@ function subtreeReadsName(node, name) {
       if (key === "parent") {
         continue;
       }
-      if (key === "key" && current.type === import_utils27.AST_NODE_TYPES.Property && !current.computed) {
+      if (key === "key" && current.type === import_utils28.AST_NODE_TYPES.Property && !current.computed) {
         continue;
       }
-      if (key === "property" && current.type === import_utils27.AST_NODE_TYPES.MemberExpression && !current.computed) {
+      if (key === "property" && current.type === import_utils28.AST_NODE_TYPES.MemberExpression && !current.computed) {
         continue;
       }
       const value = current[key];
@@ -4205,10 +4482,10 @@ var SAFE_PARSE_CONSTRUCTORS = /* @__PURE__ */ new Set([
   "URLPattern"
 ]);
 function isParseShapedNode(node) {
-  if (node.type === import_utils27.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils27.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils28.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier) {
     return node.callee.property.name === "parse";
   }
-  if (node.type === import_utils27.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils27.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils28.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils28.AST_NODE_TYPES.Identifier) {
     return SAFE_PARSE_CONSTRUCTORS.has(node.callee.name);
   }
   return false;
@@ -4219,10 +4496,10 @@ var BODY_DECODE_METHODS = /* @__PURE__ */ new Set([
   "arrayBuffer"
 ]);
 function isBodyDecodeNode(node) {
-  return node.type === import_utils27.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils27.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils27.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
+  return node.type === import_utils28.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier && BODY_DECODE_METHODS.has(node.callee.property.name);
 }
 function returnsMatching(stmt, predicate) {
-  return stmt.type === import_utils27.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
+  return stmt.type === import_utils28.AST_NODE_TYPES.ReturnStatement && stmt.argument !== null && walkWithinScope(stmt.argument, predicate);
 }
 function enclosingReturnTypeNode(node) {
   let current = node.parent;
@@ -4240,11 +4517,11 @@ function enclosingFunctionName(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
     if (isFunctionNode(current)) {
-      if ("id" in current && isNode3(current.id) && current.id.type === import_utils27.AST_NODE_TYPES.Identifier) {
+      if ("id" in current && isNode3(current.id) && current.id.type === import_utils28.AST_NODE_TYPES.Identifier) {
         return current.id.name;
       }
       const parent = current.parent;
-      if (parent?.type === import_utils27.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils27.AST_NODE_TYPES.Identifier) {
+      if (parent?.type === import_utils28.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils28.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
       return null;
@@ -4265,10 +4542,10 @@ function isDeclaredBooleanPredicate(catchNode, kind) {
     return false;
   }
   let declared = enclosingReturnTypeNode(catchNode);
-  if (declared?.type === import_utils27.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils27.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
+  if (declared?.type === import_utils28.AST_NODE_TYPES.TSTypeReference && declared.typeName.type === import_utils28.AST_NODE_TYPES.Identifier && declared.typeName.name === "Promise") {
     declared = declared.typeArguments?.params[0] ?? null;
   }
-  return declared?.type === import_utils27.AST_NODE_TYPES.TSBooleanKeyword;
+  return declared?.type === import_utils28.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function tryReturnsSafeParse(catchNode) {
   const tryBlock = tryBlockOf(catchNode);
@@ -4284,7 +4561,7 @@ function tryReturnsSafeParse(catchNode) {
 function enclosingFunctionBody(node) {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === import_utils27.AST_NODE_TYPES.BlockStatement) {
+    if (isFunctionNode(current) && "body" in current && isNode3(current.body) && current.body.type === import_utils28.AST_NODE_TYPES.BlockStatement) {
       return current.body;
     }
     current = current.parent;
@@ -4297,7 +4574,7 @@ function functionReturnsSameSentinelKindElsewhere(catchNode, kind) {
     return false;
   }
   return walkWithinScope(functionBody, (current) => {
-    if (current.type !== import_utils27.AST_NODE_TYPES.ReturnStatement) {
+    if (current.type !== import_utils28.AST_NODE_TYPES.ReturnStatement) {
       return false;
     }
     if (isWithin(current, catchNode.body)) {
@@ -4316,13 +4593,13 @@ function returnedSentinelKinds(arg) {
     kinds.add(direct);
     return kinds;
   }
-  if (arg.type === import_utils27.AST_NODE_TYPES.ConditionalExpression) {
+  if (arg.type === import_utils28.AST_NODE_TYPES.ConditionalExpression) {
     for (const branch of [arg.consequent, arg.alternate]) {
       for (const nested of returnedSentinelKinds(branch)) {
         kinds.add(nested);
       }
     }
-  } else if (arg.type === import_utils27.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
+  } else if (arg.type === import_utils28.AST_NODE_TYPES.LogicalExpression && (arg.operator === "??" || arg.operator === "||")) {
     for (const nested of returnedSentinelKinds(arg.right)) {
       kinds.add(nested);
     }
@@ -4365,7 +4642,7 @@ var no_sentinel_return_on_catch_default = createRule({
     const matcher = createLogMatcher(loggingOptions);
     function logsOrReportsError(catchBody, caughtName) {
       return walkWithinScope(catchBody, (current) => {
-        if (current.type !== import_utils27.AST_NODE_TYPES.CallExpression) {
+        if (current.type !== import_utils28.AST_NODE_TYPES.CallExpression) {
           return false;
         }
         if (matcher.isLoggingCall(current)) {
@@ -4377,12 +4654,12 @@ var no_sentinel_return_on_catch_default = createRule({
     }
     return {
       CatchClause(node) {
-        const body = node.body.body;
-        if (body.length === 0) {
+        const body2 = node.body.body;
+        if (body2.length === 0) {
           return;
         }
-        const last = body[body.length - 1];
-        if (last === void 0 || last.type !== import_utils27.AST_NODE_TYPES.ReturnStatement) {
+        const last = body2[body2.length - 1];
+        if (last === void 0 || last.type !== import_utils28.AST_NODE_TYPES.ReturnStatement) {
           return;
         }
         if (!isSentinelArgument(last.argument)) {
@@ -4391,7 +4668,7 @@ var no_sentinel_return_on_catch_default = createRule({
         if (containsThrow(node.body)) {
           return;
         }
-        const caughtName = node.param?.type === import_utils27.AST_NODE_TYPES.Identifier ? node.param.name : null;
+        const caughtName = node.param?.type === import_utils28.AST_NODE_TYPES.Identifier ? node.param.name : null;
         if (logsOrReportsError(node.body, caughtName)) {
           return;
         }
@@ -4418,9 +4695,9 @@ var no_sentinel_return_on_catch_default = createRule({
 });
 
 // src/rules/no-silent-promise-catch.ts
-var import_utils28 = require("@typescript-eslint/utils");
+var import_utils29 = require("@typescript-eslint/utils");
 function isBodyParseCall(node) {
-  return node.type === import_utils28.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+  return node.type === import_utils29.AST_NODE_TYPES.CallExpression && node.arguments.length === 0 && node.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils29.AST_NODE_TYPES.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -4435,37 +4712,37 @@ var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
 var DIRECTIVE_COMMENT_RE = /^\s*(eslint-|@ts-|prettier-ignore|biome-ignore|c8 |v8 |istanbul )/;
 var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
-  return node.type === import_utils28.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils28.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils28.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
+  return node.type === import_utils29.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.property.type === import_utils29.AST_NODE_TYPES.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
 function isSilentExpression(node) {
   switch (node.type) {
-    case import_utils28.AST_NODE_TYPES.Literal:
+    case import_utils29.AST_NODE_TYPES.Literal:
       return !("regex" in node);
-    case import_utils28.AST_NODE_TYPES.Identifier:
+    case import_utils29.AST_NODE_TYPES.Identifier:
       return node.name === "undefined";
-    case import_utils28.AST_NODE_TYPES.UnaryExpression:
-      return node.operator === "void" && node.argument.type === import_utils28.AST_NODE_TYPES.Literal;
-    case import_utils28.AST_NODE_TYPES.ObjectExpression:
+    case import_utils29.AST_NODE_TYPES.UnaryExpression:
+      return node.operator === "void" && node.argument.type === import_utils29.AST_NODE_TYPES.Literal;
+    case import_utils29.AST_NODE_TYPES.ObjectExpression:
       return node.properties.length === 0;
-    case import_utils28.AST_NODE_TYPES.ArrayExpression:
+    case import_utils29.AST_NODE_TYPES.ArrayExpression:
       return node.elements.length === 0;
-    case import_utils28.AST_NODE_TYPES.TSAsExpression:
+    case import_utils29.AST_NODE_TYPES.TSAsExpression:
       return isSilentExpression(node.expression);
     default:
       return false;
   }
 }
 function isSilentHandler(handler) {
-  const body = handler.body;
-  if (body.type !== import_utils28.AST_NODE_TYPES.BlockStatement) {
-    return isSilentExpression(body);
+  const body2 = handler.body;
+  if (body2.type !== import_utils29.AST_NODE_TYPES.BlockStatement) {
+    return isSilentExpression(body2);
   }
-  if (body.body.length === 0) {
+  if (body2.body.length === 0) {
     return true;
   }
-  if (body.body.length === 1) {
-    const only = body.body[0];
-    if (only !== void 0 && only.type === import_utils28.AST_NODE_TYPES.ReturnStatement) {
+  if (body2.body.length === 1) {
+    const only = body2.body[0];
+    if (only !== void 0 && only.type === import_utils29.AST_NODE_TYPES.ReturnStatement) {
       return only.argument === null || isSilentExpression(only.argument);
     }
   }
@@ -4494,7 +4771,7 @@ var no_silent_promise_catch_default = createRule({
         return true;
       }
       let statement = call;
-      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils28.AST_NODE_TYPES.VariableDeclaration) {
+      while (statement.parent !== void 0 && statement.parent !== null && !statement.type.endsWith("Statement") && statement.type !== import_utils29.AST_NODE_TYPES.VariableDeclaration) {
         statement = statement.parent;
       }
       if (sourceCode.getCommentsBefore(statement).some(isExplanatory)) {
@@ -4506,7 +4783,7 @@ var no_silent_promise_catch_default = createRule({
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils28.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils28.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
+        if (node.callee.type !== import_utils29.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils29.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
           return;
         }
         if (isBodyParseCall(node.callee.object)) {
@@ -4515,14 +4792,14 @@ var no_silent_promise_catch_default = createRule({
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === import_utils28.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
+        if (node.parent.type === import_utils29.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
           return;
         }
         if (node.arguments.length !== 1) {
           return;
         }
         const handler = node.arguments[0];
-        if (handler === void 0 || handler.type !== import_utils28.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils28.AST_NODE_TYPES.FunctionExpression) {
+        if (handler === void 0 || handler.type !== import_utils29.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils29.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (hasExplanatoryComment(node, handler)) {
@@ -4537,7 +4814,7 @@ var no_silent_promise_catch_default = createRule({
 });
 
 // src/rules/no-sleep-in-test-body.ts
-var import_utils29 = require("@typescript-eslint/utils");
+var import_utils30 = require("@typescript-eslint/utils");
 var SLEEP_HELPERS = /* @__PURE__ */ new Set(["sleep", "delay", "wait", "pause"]);
 var TEST_CALLERS2 = /* @__PURE__ */ new Set([
   "it",
@@ -4546,34 +4823,34 @@ var TEST_CALLERS2 = /* @__PURE__ */ new Set([
   "afterEach"
 ]);
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
-  import_utils29.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils29.AST_NODE_TYPES.FunctionExpression,
-  import_utils29.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils30.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils30.AST_NODE_TYPES.FunctionExpression,
+  import_utils30.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isNonzeroNumericLiteral(node) {
-  return node?.type === import_utils29.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
+  return node?.type === import_utils30.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value !== 0;
 }
 function isTimedSetTimeout(node) {
-  return node.type === import_utils29.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
+  return node.type === import_utils30.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils30.AST_NODE_TYPES.Identifier && node.callee.name === "setTimeout" && node.arguments.length >= 2 && isNonzeroNumericLiteral(node.arguments[1]);
 }
 function isPromiseSleep(node) {
-  if (node.callee.type !== import_utils29.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
+  if (node.callee.type !== import_utils30.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise") {
     return false;
   }
   const executor = node.arguments[0];
-  if (executor?.type !== import_utils29.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils29.AST_NODE_TYPES.FunctionExpression) {
+  if (executor?.type !== import_utils30.AST_NODE_TYPES.ArrowFunctionExpression && executor?.type !== import_utils30.AST_NODE_TYPES.FunctionExpression) {
     return false;
   }
-  const body = executor.body;
-  if (body.type !== import_utils29.AST_NODE_TYPES.BlockStatement) {
-    return isTimedSetTimeout(body);
+  const body2 = executor.body;
+  if (body2.type !== import_utils30.AST_NODE_TYPES.BlockStatement) {
+    return isTimedSetTimeout(body2);
   }
-  return body.body.some(
-    (stmt) => stmt.type === import_utils29.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
+  return body2.body.some(
+    (stmt) => stmt.type === import_utils30.AST_NODE_TYPES.ExpressionStatement && isTimedSetTimeout(stmt.expression)
   );
 }
 function isHelperSleep(node) {
-  return node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
+  return node.callee.type === import_utils30.AST_NODE_TYPES.Identifier && SLEEP_HELPERS.has(node.callee.name) && node.arguments.length >= 1 && isNonzeroNumericLiteral(node.arguments[0]);
 }
 function nearestEnclosingFunction2(node) {
   for (let current = node.parent; current != null; current = current.parent) {
@@ -4581,7 +4858,7 @@ function nearestEnclosingFunction2(node) {
       continue;
     }
     const grandparent = current.parent;
-    const isPromiseExecutor = grandparent?.type === import_utils29.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
+    const isPromiseExecutor = grandparent?.type === import_utils30.AST_NODE_TYPES.NewExpression && isPromiseSleep(grandparent);
     if (!isPromiseExecutor) {
       return current;
     }
@@ -4589,23 +4866,23 @@ function nearestEnclosingFunction2(node) {
   return null;
 }
 function testCallerName2(callee) {
-  if (callee.type === import_utils29.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils30.AST_NODE_TYPES.Identifier) {
     return callee.name;
   }
-  if (callee.type === import_utils29.AST_NODE_TYPES.MemberExpression) {
+  if (callee.type === import_utils30.AST_NODE_TYPES.MemberExpression) {
     return testCallerName2(callee.object);
   }
-  if (callee.type === import_utils29.AST_NODE_TYPES.CallExpression) {
+  if (callee.type === import_utils30.AST_NODE_TYPES.CallExpression) {
     return testCallerName2(callee.callee);
   }
-  if (callee.type === import_utils29.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (callee.type === import_utils30.AST_NODE_TYPES.TaggedTemplateExpression) {
     return testCallerName2(callee.tag);
   }
   return null;
 }
 function isTestBody2(fn) {
   const call = fn.parent;
-  if (call?.type !== import_utils29.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== import_utils30.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   const name = testCallerName2(call.callee);
@@ -4651,7 +4928,7 @@ var no_sleep_in_test_body_default = createRule({
 });
 
 // src/rules/no-storage-in-stateless-modules.ts
-var import_utils30 = require("@typescript-eslint/utils");
+var import_utils31 = require("@typescript-eslint/utils");
 var DEFAULT_METHODS2 = [
   "prepare",
   "put",
@@ -4670,7 +4947,7 @@ function compile2(patterns) {
 }
 function storageMethodName(node, methods) {
   const callee = node.callee;
-  if (callee.type !== import_utils30.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils30.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils31.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils31.AST_NODE_TYPES.Identifier) {
     return null;
   }
   const name = callee.property.name;
@@ -4738,7 +5015,7 @@ var no_storage_in_stateless_modules_default = createRule({
 });
 
 // src/rules/no-string-concat-in-loop.ts
-var import_utils31 = require("@typescript-eslint/utils");
+var import_utils32 = require("@typescript-eslint/utils");
 var LOOP_NODE_TYPES = /* @__PURE__ */ new Set([
   "ForStatement",
   "ForOfStatement",
@@ -4803,9 +5080,9 @@ function isDeclaredInsideLoop(variable, loop) {
   if (def === void 0) {
     return false;
   }
-  const body = loop.body;
+  const body2 = loop.body;
   const [declStart, declEnd] = def.node.range;
-  const [bodyStart, bodyEnd] = body.range;
+  const [bodyStart, bodyEnd] = body2.range;
   return declStart >= bodyStart && declEnd <= bodyEnd;
 }
 function enclosingLoop(node) {
@@ -4884,7 +5161,7 @@ var no_string_concat_in_loop_default = createRule({
 });
 
 // src/rules/no-tautological-expect.ts
-var import_utils32 = require("@typescript-eslint/utils");
+var import_utils33 = require("@typescript-eslint/utils");
 var EQUALITY_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ZERO_ARG_MATCHERS = /* @__PURE__ */ new Set([
   "toBeDefined",
@@ -4898,17 +5175,17 @@ var OPERAND_PREVIEW_CHARS = 40;
 var NUMERIC_SIGNS = /* @__PURE__ */ new Set(["-", "+"]);
 function isLiteral(node) {
   switch (node.type) {
-    case import_utils32.AST_NODE_TYPES.Literal:
+    case import_utils33.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils32.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils33.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils32.AST_NODE_TYPES.UnaryExpression:
+    case import_utils33.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS.has(node.operator) && isLiteral(node.argument);
-    case import_utils32.AST_NODE_TYPES.ArrayExpression:
+    case import_utils33.AST_NODE_TYPES.ArrayExpression:
       return node.elements.every((element) => element !== null && isLiteral(element));
-    case import_utils32.AST_NODE_TYPES.ObjectExpression:
+    case import_utils33.AST_NODE_TYPES.ObjectExpression:
       return node.properties.every(
-        (property) => property.type === import_utils32.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
+        (property) => property.type === import_utils33.AST_NODE_TYPES.Property && !property.computed && isLiteral(property.value)
       );
     default:
       return false;
@@ -4916,7 +5193,7 @@ function isLiteral(node) {
 }
 function expectOperand(callee) {
   const receiver = callee.object;
-  if (receiver.type !== import_utils32.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils32.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
+  if (receiver.type !== import_utils33.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils33.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
     return null;
   }
   return receiver.arguments[0] ?? null;
@@ -4946,10 +5223,10 @@ var no_tautological_expect_default = createRule({
     return {
       CallExpression(node) {
         const callee = node.callee;
-        if (callee.type !== import_utils32.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        if (callee.type !== import_utils33.AST_NODE_TYPES.MemberExpression || callee.computed) {
           return;
         }
-        if (callee.property.type !== import_utils32.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils33.AST_NODE_TYPES.Identifier) {
           return;
         }
         const matcher = callee.property.name;
@@ -4982,8 +5259,33 @@ var no_tautological_expect_default = createRule({
   }
 });
 
+// src/rules/no-typed-doc-sections.ts
+var no_typed_doc_sections_default = createRule({
+  name: "no-typed-doc-sections",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Reject typed-signature repetition while preserving behavior that types cannot express." },
+    schema: [],
+    messages: {
+      typedSection: "Typed JSDoc repeats parameters or returns \u2014 delete the tags and improve names or types instead."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const group of proseGroups(context.filename, context.sourceCode, true)) {
+          if (group.hasTypedTags && documentsTypedFunction(context.sourceCode, group.comment)) {
+            context.report({ node: group.comment, messageId: "typedSection" });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-trailing-value-narration.ts
-var import_utils33 = require("@typescript-eslint/utils");
+var import_utils34 = require("@typescript-eslint/utils");
 var NUMBER_RE = /(?<![\w.])(\d+(?:\.\d+)?)(?![\w.])/g;
 var WORD_RE3 = /[A-Za-z]+(?:'[a-z]+)?|\d+(?:\.\d+)?/g;
 var UNIT_WORDS = /* @__PURE__ */ new Set([
@@ -5045,21 +5347,22 @@ var STOPWORDS3 = /* @__PURE__ */ new Set([
   "we",
   "with"
 ]);
-var DIRECTIVE_RE4 = /^\s*(?:eslint\b|eslint-|sarj-noqa\b|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|todo\b|fixme\b|hack\b|xxx\b)/i;
+var DIRECTIVE_RE5 = /^\s*(?:eslint\b|eslint-|sarj-noqa\b|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|todo\b|fixme\b|hack\b|xxx\b)/i;
 function numbersIn(text) {
   return new Set(text.match(NUMBER_RE) ?? []);
 }
-function narratesValue(body, code) {
-  if (body.length === 0 || DIRECTIVE_RE4.test(body) || hasExternalReference(body)) return false;
+function narratesValue(body2, code) {
+  if (body2.length === 0 || DIRECTIVE_RE5.test(body2) || hasExternalReference(body2)) return false;
   const codeNumbers = numbersIn(code);
   if (codeNumbers.size === 0) return false;
-  const words = (body.match(WORD_RE3) ?? []).map((word) => word.toLowerCase());
+  const words = (body2.match(WORD_RE3) ?? []).map((word) => word.toLowerCase());
   if (words.length === 0) return false;
-  const commentNumbers = numbersIn(body);
+  const commentNumbers = numbersIn(body2);
   if (commentNumbers.size === 0) return false;
   for (const number of commentNumbers) {
     if (!codeNumbers.has(number)) return false;
   }
+  if (!words.some((word) => UNIT_WORDS.has(word))) return false;
   const identifiers = codeTokens(code);
   const stems = /* @__PURE__ */ new Set();
   for (const token of identifiers) stems.add(stem(token));
@@ -5072,7 +5375,7 @@ var no_trailing_value_narration_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Flag a trailing comment whose every word and number is already on the line it annotates."
+      description: "Flag a trailing comment that repeats the line's numeric value only to name its unit."
     },
     schema: [],
     messages: {
@@ -5089,14 +5392,25 @@ var no_trailing_value_narration_default = createRule({
       const before = sourceCode.getTokenBefore(comment, { includeComments: false });
       return before !== null && before.loc.end.line === comment.loc.start.line;
     }
+    function isInsideBrackets(comment) {
+      let node = sourceCode.getNodeByRangeIndex(comment.range[0]);
+      while (node != null) {
+        if (node.type === "BlockStatement" || node.type === "Program") return false;
+        if (node.type === "ArrayExpression" || node.type === "CallExpression" || node.type === "NewExpression") {
+          return true;
+        }
+        node = node.parent;
+      }
+      return false;
+    }
     return {
       Program() {
         for (const comment of sourceCode.getAllComments()) {
-          if (!isTrailing(comment)) continue;
+          if (!isTrailing(comment) || isInsideBrackets(comment)) continue;
           const line = sourceCode.lines[comment.loc.start.line - 1] ?? "";
           const code = line.slice(0, comment.loc.start.column);
-          const body = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
-          if (narratesValue(body, code)) {
+          const body2 = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
+          if (narratesValue(body2, code)) {
             context.report({ node: comment, messageId: "narratesValue" });
           }
         }
@@ -5106,10 +5420,10 @@ var no_trailing_value_narration_default = createRule({
 });
 
 // src/rules/no-declaration-comment-wall.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils36 = require("@typescript-eslint/utils");
 
 // src/rules/_comment-wall.ts
-var import_utils34 = require("@typescript-eslint/utils");
+var import_utils35 = require("@typescript-eslint/utils");
 var WALL_DEFAULTS = {
   // Below three rows "a wall" is not a fair description of what the reader sees.
   minCommentedMembers: 3,
@@ -5151,7 +5465,7 @@ var WALL_SCHEMA = {
     }
   }
 };
-var VALUE_TAG_RE = /@(?:deprecated|see|example|throws|remarks|since|default|defaultvalue|link|internal|alpha|beta|experimental|template|typeparam|inheritdoc|todo|fixme|override)\b/i;
+var VALUE_TAG_RE2 = /@(?:deprecated|see|example|throws|remarks|since|default|defaultvalue|link|internal|alpha|beta|experimental|template|typeparam|inheritdoc|todo|fixme|override)\b/i;
 var DEFAULT_RE = /^\s*@?default\b|\bdefaults? (?:to|:)/i;
 var DIGIT_RE = /\d/;
 var UNIT_WORD_RE = /\b(?:ms|milliseconds?|seconds?|minutes?|hours?|days?|weeks?|months?|years?|bytes?|kb|mb|gb|percent|pixels?|px|utc|epoch)\b/i;
@@ -5171,24 +5485,24 @@ var WALL_STOPWORDS = new Set(
 );
 var WORD_RE4 = /[A-Za-z][A-Za-z0-9]*/g;
 var BARE_LABEL_RE = /^[A-Za-z][A-Za-z0-9]*$/;
-function labelStems(body) {
-  return splitIdentifier(body).map(stem).join(" ");
+function labelStems(body2) {
+  return splitIdentifier(body2).map(stem).join(" ");
 }
 function commentBody(comment) {
   return comment.value.replace(/^\*+/, "").replace(/^[ \t]*\*[ \t]?/gm, "").trim();
 }
-function carriesValue(body) {
-  return isProtected(body) || VALUE_TAG_RE.test(body) || DEFAULT_RE.test(body) || DIGIT_RE.test(body) || UNIT_WORD_RE.test(body) || EXAMPLE_RE.test(body) || BANNER_RE.test(body) || NON_ASCII_LETTER_RE2.test(body);
+function carriesValue(body2) {
+  return isProtected(body2) || VALUE_TAG_RE2.test(body2) || DEFAULT_RE.test(body2) || DIGIT_RE.test(body2) || UNIT_WORD_RE.test(body2) || EXAMPLE_RE.test(body2) || BANNER_RE.test(body2) || NON_ASCII_LETTER_RE2.test(body2);
 }
-function isLabel(body) {
+function isLabel(body2) {
   let content = 0;
-  for (const word of body.match(WORD_RE4) ?? []) {
+  for (const word of body2.match(WORD_RE4) ?? []) {
     if (word.length >= 2 && !WALL_STOPWORDS.has(word.toLowerCase())) content += 1;
   }
   return content <= 1;
 }
-function isTagsOnly(body) {
-  return body.length > 0 && body.replace(TAG_TOKEN_RE, "").trim().length === 0;
+function isTagsOnly(body2) {
+  return body2.length > 0 && body2.replace(TAG_TOKEN_RE, "").trim().length === 0;
 }
 function knownTokens(source) {
   const tokens = /* @__PURE__ */ new Set();
@@ -5200,9 +5514,9 @@ function knownTokens(source) {
   }
   return tokens;
 }
-function novelWords(body, known) {
+function novelWords(body2, known) {
   let novel = 0;
-  for (const word of body.match(WORD_RE4) ?? []) {
+  for (const word of body2.match(WORD_RE4) ?? []) {
     const lower = word.toLowerCase();
     if (lower.length < 2 || WALL_STOPWORDS.has(lower)) continue;
     if (!known.has(lower) && !known.has(stem(lower))) novel += 1;
@@ -5213,21 +5527,21 @@ function isWall(members, commented, restated, options) {
   return commented >= options.minCommentedMembers && commented / members >= options.minCommentedRatio && restated / commented >= options.minRestatedRatio;
 }
 var OPAQUE_VALUE_TYPES = /* @__PURE__ */ new Set([
-  import_utils34.AST_NODE_TYPES.FunctionExpression,
-  import_utils34.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils34.AST_NODE_TYPES.ObjectExpression,
-  import_utils34.AST_NODE_TYPES.ArrayExpression
+  import_utils35.AST_NODE_TYPES.FunctionExpression,
+  import_utils35.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils35.AST_NODE_TYPES.ObjectExpression,
+  import_utils35.AST_NODE_TYPES.ArrayExpression
 ]);
 function declarationRange(member) {
-  const body = bodyOf(member);
-  if (body === void 0) return [member.range[0], member.range[1]];
-  return [member.range[0], body.range[0]];
+  const body2 = bodyOf(member);
+  if (body2 === void 0) return [member.range[0], member.range[1]];
+  return [member.range[0], body2.range[0]];
 }
 function bodyOf(member) {
-  if (member.type === import_utils34.AST_NODE_TYPES.MethodDefinition || member.type === import_utils34.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+  if (member.type === import_utils35.AST_NODE_TYPES.MethodDefinition || member.type === import_utils35.AST_NODE_TYPES.TSAbstractMethodDefinition) {
     return member.value.body ?? void 0;
   }
-  if (member.type === import_utils34.AST_NODE_TYPES.Property || member.type === import_utils34.AST_NODE_TYPES.PropertyDefinition) {
+  if (member.type === import_utils35.AST_NODE_TYPES.Property || member.type === import_utils35.AST_NODE_TYPES.PropertyDefinition) {
     const value = member.value;
     if (value !== null && OPAQUE_VALUE_TYPES.has(value.type)) return value;
   }
@@ -5237,12 +5551,12 @@ function bodyOf(member) {
 // src/rules/no-declaration-comment-wall.ts
 function named(node) {
   switch (node.type) {
-    case import_utils35.AST_NODE_TYPES.TSEnumMember:
+    case import_utils36.AST_NODE_TYPES.TSEnumMember:
       return { node, key: node.id };
-    case import_utils35.AST_NODE_TYPES.PropertyDefinition:
-    case import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition:
-    case import_utils35.AST_NODE_TYPES.MethodDefinition:
-    case import_utils35.AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case import_utils36.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils36.AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case import_utils36.AST_NODE_TYPES.MethodDefinition:
+    case import_utils36.AST_NODE_TYPES.TSAbstractMethodDefinition:
       return node.computed ? void 0 : { node, key: node.key };
     default:
       return void 0;
@@ -5286,9 +5600,9 @@ var no_declaration_comment_wall_default = createRule({
     }
     function isGroupLabel(comment, member, headsRun) {
       if (comment.loc.end.line >= member.node.loc.start.line) return false;
-      const body = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body)) return false;
-      if (labelStems(body) === labelStems(sourceCode.getText(member.key))) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
       const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
       return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
     }
@@ -5301,19 +5615,21 @@ var no_declaration_comment_wall_default = createRule({
       }));
       let commented = 0;
       let restated = 0;
+      const claimed = /* @__PURE__ */ new Set();
       for (const [index, { member, comment }] of documented.entries()) {
-        if (comment === void 0) continue;
+        if (comment === void 0 || claimed.has(comment)) continue;
         const next = documented[index + 1];
         if (isGroupLabel(comment, member, next !== void 0 && next.comment === void 0)) {
           continue;
         }
+        claimed.add(comment);
         commented += 1;
-        const body = commentBody(comment);
-        if (body.length === 0 || carriesValue(body) || isTagsOnly(body) || isLabel(body)) {
+        const body2 = commentBody(comment);
+        if (body2.length === 0 || carriesValue(body2) || isTagsOnly(body2) || isLabel(body2)) {
           continue;
         }
         const [start, end] = declarationRange(member.node);
-        if (novelWords(body, knownTokens(sourceCode.text.slice(start, end))) <= options.maxNovelWords) {
+        if (novelWords(body2, knownTokens(sourceCode.text.slice(start, end))) <= options.maxNovelWords) {
           restated += 1;
         }
       }
@@ -5340,7 +5656,7 @@ var no_declaration_comment_wall_default = createRule({
 });
 
 // src/rules/no-union-in-comment.ts
-var import_utils36 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var MAX_LITERAL_LENGTH = 28;
 var LITERAL = String.raw`(?:'[^'\n]*'|"[^"\n]*"|\`[^\`\n]*\`)`;
 var LEAD_IN_RE2 = /^(?:one of|either|values?|allowed(?: values)?|options?|possible(?: values)?)\s*[:=-]?\s*/i;
@@ -5359,14 +5675,14 @@ var STRING_BUILDERS = /* @__PURE__ */ new Set([
 function isBareString(node) {
   if (node === void 0) return false;
   switch (node.type) {
-    case import_utils36.AST_NODE_TYPES.TSStringKeyword:
+    case import_utils37.AST_NODE_TYPES.TSStringKeyword:
       return true;
     // `string[]` holds members of the same closed set, one element at a time.
-    case import_utils36.AST_NODE_TYPES.TSArrayType:
+    case import_utils37.AST_NODE_TYPES.TSArrayType:
       return isBareString(node.elementType);
     // `string | null` is still an unconstrained string, and so is `string | "a"`
     // — the checker collapses that one to `string`.
-    case import_utils36.AST_NODE_TYPES.TSUnionType:
+    case import_utils37.AST_NODE_TYPES.TSUnionType:
       return node.types.some((member) => isBareString(member));
     default:
       return false;
@@ -5376,13 +5692,13 @@ function rootCallee(node) {
   let current = node;
   for (let hops = 0; current != null && hops < 12; hops += 1) {
     switch (current.type) {
-      case import_utils36.AST_NODE_TYPES.CallExpression:
+      case import_utils37.AST_NODE_TYPES.CallExpression:
         current = current.callee;
         break;
-      case import_utils36.AST_NODE_TYPES.MemberExpression:
+      case import_utils37.AST_NODE_TYPES.MemberExpression:
         current = current.object;
         break;
-      case import_utils36.AST_NODE_TYPES.Identifier:
+      case import_utils37.AST_NODE_TYPES.Identifier:
         return current.name;
       default:
         return null;
@@ -5391,26 +5707,26 @@ function rootCallee(node) {
   return null;
 }
 function nameOf(key) {
-  if (key.type === import_utils36.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils36.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils37.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils37.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 }
 function targetOf(node) {
   switch (node.type) {
-    case import_utils36.AST_NODE_TYPES.TSPropertySignature:
-    case import_utils36.AST_NODE_TYPES.PropertyDefinition: {
+    case import_utils37.AST_NODE_TYPES.TSPropertySignature:
+    case import_utils37.AST_NODE_TYPES.PropertyDefinition: {
       const name = node.computed ? null : nameOf(node.key);
       if (name === null || !isBareString(node.typeAnnotation?.typeAnnotation)) return null;
       return { node, name };
     }
-    case import_utils36.AST_NODE_TYPES.Property: {
+    case import_utils37.AST_NODE_TYPES.Property: {
       const name = node.computed || node.shorthand ? null : nameOf(node.key);
       const callee = rootCallee(node.value);
       if (name === null || callee === null || !STRING_BUILDERS.has(callee)) return null;
       return { node, name };
     }
-    case import_utils36.AST_NODE_TYPES.VariableDeclarator: {
-      if (node.id.type !== import_utils36.AST_NODE_TYPES.Identifier) return null;
+    case import_utils37.AST_NODE_TYPES.VariableDeclarator: {
+      if (node.id.type !== import_utils37.AST_NODE_TYPES.Identifier) return null;
       if (!isBareString(node.id.typeAnnotation?.typeAnnotation)) return null;
       return { node, name: node.id.name };
     }
@@ -5418,8 +5734,8 @@ function targetOf(node) {
       return null;
   }
 }
-function unionLiterals(body) {
-  const list = body.replace(LEAD_IN_RE2, "").trim();
+function unionLiterals(body2) {
+  const list = body2.replace(LEAD_IN_RE2, "").trim();
   if (!UNION_BODY_RE.test(list)) return null;
   const literals = (list.match(LITERAL_G) ?? []).map((raw) => raw.slice(1, -1));
   if (literals.some((literal) => literal.length === 0 || literal.length > MAX_LITERAL_LENGTH)) {
@@ -5459,7 +5775,7 @@ var no_union_in_comment_default = createRule({
         if (after === null || after.loc.start.line !== comment.loc.end.line + 1) return null;
         anchor = sourceCode.getNodeByRangeIndex(after.range[0]);
       }
-      for (let node = anchor; node != null && node.type !== import_utils36.AST_NODE_TYPES.Program; node = node.parent) {
+      for (let node = anchor; node != null && node.type !== import_utils37.AST_NODE_TYPES.Program; node = node.parent) {
         const target = targetOf(node);
         if (target !== null) return target;
       }
@@ -5468,9 +5784,9 @@ var no_union_in_comment_default = createRule({
     return {
       Program() {
         for (const comment of sourceCode.getAllComments()) {
-          const body = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
-          if (body.length === 0) continue;
-          const literals = unionLiterals(body);
+          const body2 = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
+          if (body2.length === 0) continue;
+          const literals = unionLiterals(body2);
           if (literals === null) continue;
           const target = annotated(comment);
           if (target === null) continue;
@@ -5488,9 +5804,9 @@ var no_union_in_comment_default = createRule({
 });
 
 // src/rules/no-type-member-comment-wall.ts
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
 function isNamedMember(node) {
-  return (node.type === import_utils37.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils37.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
+  return (node.type === import_utils38.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils38.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
 }
 var no_type_member_comment_wall_default = createRule({
   name: "no-type-member-comment-wall",
@@ -5530,14 +5846,14 @@ var no_type_member_comment_wall_default = createRule({
     }
     function isGroupLabel(comment, member, headsRun) {
       if (comment.loc.end.line >= member.loc.start.line) return false;
-      const body = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body)) return false;
-      if (labelStems(body) === labelStems(sourceCode.getText(member.key))) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
       const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
       return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
     }
     function check(node) {
-      const members = node.type === import_utils37.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
+      const members = node.type === import_utils38.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
       const named2 = members.filter(isNamedMember);
       if (named2.length === 0) return;
       const documented = named2.map((member) => ({ member, comment: documentingComment(member) }));
@@ -5552,9 +5868,9 @@ var no_type_member_comment_wall_default = createRule({
         }
         claimed.add(comment);
         commented += 1;
-        const body = commentBody(comment);
-        if (body.length === 0 || carriesValue(body)) continue;
-        if (novelWords(body, knownTokens(sourceCode.getText(member))) <= options.maxNovelWords) {
+        const body2 = commentBody(comment);
+        if (body2.length === 0 || carriesValue(body2)) continue;
+        if (novelWords(body2, knownTokens(sourceCode.getText(member))) <= options.maxNovelWords) {
           restated += 1;
         }
       }
@@ -5577,7 +5893,7 @@ var no_type_member_comment_wall_default = createRule({
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -5603,13 +5919,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === import_utils38.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils39.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils38.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils39.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils38.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -5624,16 +5940,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils38.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils38.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils39.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils39.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils38.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils39.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils38.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils39.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -5673,13 +5989,13 @@ var no_unnecessary_use_client_default = createRule({
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils38.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils39.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -5689,7 +6005,7 @@ var no_unnecessary_use_client_default = createRule({
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils38.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils39.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -5702,7 +6018,7 @@ var no_unnecessary_use_client_default = createRule({
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils38.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils39.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -5769,18 +6085,18 @@ var no_unnecessary_use_client_default = createRule({
 });
 
 // src/rules/no-unsafe-mock-casting.ts
-var import_utils39 = require("@typescript-eslint/utils");
 var import_utils40 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 function isMockTypeReference(node) {
-  if (node.type !== import_utils40.AST_NODE_TYPES.TSTypeReference) {
+  if (node.type !== import_utils41.AST_NODE_TYPES.TSTypeReference) {
     return false;
   }
   const typeName = node.typeName;
-  if (typeName.type === import_utils40.AST_NODE_TYPES.Identifier) {
+  if (typeName.type === import_utils41.AST_NODE_TYPES.Identifier) {
     const name = typeName.name;
     return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
   }
-  if (typeName.type === import_utils40.AST_NODE_TYPES.TSQualifiedName) {
+  if (typeName.type === import_utils41.AST_NODE_TYPES.TSQualifiedName) {
     const rightName = typeName.right.name;
     return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
   }
@@ -5816,7 +6132,7 @@ var no_unsafe_mock_casting_default = createRule({
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS = [
   /[\\/]generated[\\/]/,
@@ -5834,7 +6150,7 @@ function isZodModule(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap2(node) {
-  if (node.type === import_utils41.AST_NODE_TYPES.TSAsExpression || node.type === import_utils41.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils42.AST_NODE_TYPES.TSAsExpression || node.type === import_utils42.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap2(node.expression);
   }
   return node;
@@ -5842,14 +6158,14 @@ function unwrap2(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils41.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils42.AST_NODE_TYPES.Property) {
       return null;
     }
     if (prop.computed || prop.shorthand || prop.method || prop.kind !== "init") {
       return null;
     }
     const value = prop.value;
-    if (value.type !== import_utils41.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils42.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -5865,7 +6181,7 @@ function resolvesToLocalEnum(node, scope) {
     const variable = current.variables.find((v) => v.name === node.name);
     if (variable !== void 0) {
       return variable.defs.some(
-        (def) => def.node.type === import_utils41.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils42.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -5910,32 +6226,32 @@ var no_zod_native_enum_default = createRule({
     }
     let services;
     try {
-      services = import_utils41.ESLintUtils.getParserServices(context);
+      services = import_utils42.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils41.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils42.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils42.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === import_utils41.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils42.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils41.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils41.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils42.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils41.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils42.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap2(arg);
-      if (inner.type !== import_utils41.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils42.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -5955,7 +6271,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils41.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils41.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils42.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils42.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -5974,7 +6290,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils41.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils42.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -5991,7 +6307,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
 var SENTINEL_WORDS = /(^|_)(SENTINEL|EMPTY|NONE|NULL|UNSET|MISSING|PLACEHOLDER|DUMMY|FAKE|EXAMPLE)(_|$)/;
@@ -6004,36 +6320,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils42.AST_NODE_TYPES.Literal:
+    case import_utils43.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils42.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils43.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils42.AST_NODE_TYPES.Identifier:
+    case import_utils43.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case import_utils42.AST_NODE_TYPES.MemberExpression:
-      return !node.computed && node.property.type === import_utils42.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case import_utils43.AST_NODE_TYPES.MemberExpression:
+      return !node.computed && node.property.type === import_utils43.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils43.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils42.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils43.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils43.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils43.AST_NODE_TYPES.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils43.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -6085,8 +6401,8 @@ var prefer_constant_time_secret_compare_default = createRule({
 });
 
 // src/rules/prefer-discriminated-union.ts
-var import_utils43 = require("@typescript-eslint/utils");
 var import_utils44 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -6096,27 +6412,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils44.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils45.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils44.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils45.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils44.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils45.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils44.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils45.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   let optionalPayloadCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== import_utils44.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils45.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -6137,7 +6453,7 @@ var prefer_discriminated_union_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Flag object types with a boolean status flag and many optionals; model them as a discriminated union instead."
+      description: "Flag object types with a boolean status member and at least two optional members, including a non-boolean payload."
     },
     schema: [],
     messages: {
@@ -6158,7 +6474,7 @@ var prefer_discriminated_union_default = createRule({
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils44.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils45.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -6171,7 +6487,7 @@ var prefer_discriminated_union_default = createRule({
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS2 = [
@@ -6200,9 +6516,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
-  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils45.AST_NODE_TYPES.FunctionExpression,
-  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils46.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils46.AST_NODE_TYPES.FunctionExpression,
+  import_utils46.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile2(filename, sourceText) {
@@ -6215,14 +6531,14 @@ function isLocalFixtureFile(filename) {
   return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap3(node) {
-  if (node.type === import_utils45.AST_NODE_TYPES.TSAsExpression || node.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.TSAsExpression || node.type === import_utils46.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils46.AST_NODE_TYPES.TSNonNullExpression) {
     return unwrap3(node.expression);
   }
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === import_utils45.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils46.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -6230,29 +6546,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap3(node);
   switch (inner.type) {
-    case import_utils45.AST_NODE_TYPES.Literal: {
+    case import_utils46.AST_NODE_TYPES.Literal: {
       return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case import_utils45.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils46.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils45.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils45.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    case import_utils46.AST_NODE_TYPES.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils46.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
     }
-    case import_utils45.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils46.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils45.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils46.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils45.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils46.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils45.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils46.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils45.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils46.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -6265,7 +6581,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap3(node);
-  if (inner.type === import_utils45.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils45.AST_NODE_TYPES.SpreadElement) {
+  if (inner.type === import_utils46.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils46.AST_NODE_TYPES.SpreadElement) {
     return unwrap3(inner.arguments[0]);
   }
   return inner;
@@ -6281,19 +6597,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils46.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils45.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils45.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils46.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils46.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_utils45.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap3(arg);
-    if (entries.type !== import_utils45.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils46.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -6322,10 +6638,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils46.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils45.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils46.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils46.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils46.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -6339,38 +6655,38 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils45.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils45.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === import_utils46.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils46.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils46.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
@@ -6425,7 +6741,7 @@ var prefer_module_level_constant_default = createRule({
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils46.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6437,10 +6753,10 @@ var prefer_module_level_constant_default = createRule({
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils45.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils46.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils46.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6467,7 +6783,7 @@ var prefer_module_level_constant_default = createRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-var import_utils46 = require("@typescript-eslint/utils");
+var import_utils47 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -6533,9 +6849,9 @@ var I18N_RECEIVER_NAMES = /* @__PURE__ */ new Set([
   "intl"
 ]);
 var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
-  import_utils46.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils46.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils46.AST_NODE_TYPES.FunctionExpression
+  import_utils47.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils47.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils47.AST_NODE_TYPES.FunctionExpression
 ]);
 function schemaExpression(node) {
   let current = node;
@@ -6544,10 +6860,10 @@ function schemaExpression(node) {
     if (parent === void 0) {
       return current;
     }
-    if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils46.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
+    if (parent.type === import_utils47.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils47.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
       return current;
     }
-    if (parent.type === import_utils46.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils46.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils46.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
+    if (parent.type === import_utils47.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils47.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils47.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils47.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -6598,22 +6914,22 @@ function subtreeSome(root, predicate) {
 function readsReceiver(node) {
   return subtreeSome(
     node,
-    (inner) => inner.type === import_utils46.AST_NODE_TYPES.ThisExpression || inner.type === import_utils46.AST_NODE_TYPES.Super || inner.type === import_utils46.AST_NODE_TYPES.Identifier && inner.name === "arguments"
+    (inner) => inner.type === import_utils47.AST_NODE_TYPES.ThisExpression || inner.type === import_utils47.AST_NODE_TYPES.Super || inner.type === import_utils47.AST_NODE_TYPES.Identifier && inner.name === "arguments"
   );
 }
 function buildsLocalizedText(node) {
   return subtreeSome(node, (inner) => {
-    if (inner.type === import_utils46.AST_NODE_TYPES.TaggedTemplateExpression) {
+    if (inner.type === import_utils47.AST_NODE_TYPES.TaggedTemplateExpression) {
       return true;
     }
-    if (inner.type !== import_utils46.AST_NODE_TYPES.CallExpression) {
+    if (inner.type !== import_utils47.AST_NODE_TYPES.CallExpression) {
       return false;
     }
     const { callee } = inner;
-    if (callee.type === import_utils46.AST_NODE_TYPES.Identifier) {
+    if (callee.type === import_utils47.AST_NODE_TYPES.Identifier) {
       return I18N_CALLEE_NAMES.has(callee.name);
     }
-    return callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils46.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
+    return callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils47.AST_NODE_TYPES.Identifier && I18N_RECEIVER_NAMES.has(callee.object.name);
   });
 }
 function collectReferences(scope, out) {
@@ -6670,15 +6986,15 @@ var prefer_module_level_schema_default = createRule({
     }
     const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodCall(node) {
-      return node.type === import_utils46.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils46.AST_NODE_TYPES.Identifier && zodNamespaces.has(node.callee.object.name);
+      return node.type === import_utils47.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils47.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_utils46.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
+        if (current !== node && isZodCall(current) && current.callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils47.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === import_utils46.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils46.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === import_utils47.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils47.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils47.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -6693,11 +7009,11 @@ var prefer_module_level_schema_default = createRule({
         if (parent === void 0) {
           return confirmed;
         }
-        if (parent.type === import_utils46.AST_NODE_TYPES.Property && parent.value === current || parent.type === import_utils46.AST_NODE_TYPES.ObjectExpression || parent.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
+        if (parent.type === import_utils47.AST_NODE_TYPES.Property && parent.value === current || parent.type === import_utils47.AST_NODE_TYPES.ObjectExpression || parent.type === import_utils47.AST_NODE_TYPES.ArrayExpression) {
           current = parent;
           continue;
         }
-        if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
+        if (parent.type === import_utils47.AST_NODE_TYPES.CallExpression && parent.arguments.includes(current) && isSchemaComposition(parent)) {
           current = schemaExpression(parent);
           confirmed = current;
           continue;
@@ -6707,7 +7023,7 @@ var prefer_module_level_schema_default = createRule({
     }
     function isSchemaComposition(node) {
       const { callee } = node;
-      const isCombinator = callee.type === import_utils46.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils46.AST_NODE_TYPES.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
+      const isCombinator = callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils47.AST_NODE_TYPES.Identifier && ZOD_COMBINATOR_METHODS.has(callee.property.name);
       return isCombinator || isZodCall(node);
     }
     function closesOverNothing(node, enclosing) {
@@ -6741,13 +7057,13 @@ var prefer_module_level_schema_default = createRule({
     }
     function ownerName(enclosing) {
       const parent = enclosing.parent ?? void 0;
-      if (enclosing.type === import_utils46.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
+      if (enclosing.type === import_utils47.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
         return enclosing.id.name;
       }
-      if (parent !== void 0 && parent.type === import_utils46.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils46.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && parent.type === import_utils47.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils47.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
-      if (parent !== void 0 && (parent.type === import_utils46.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils46.AST_NODE_TYPES.Property) && parent.key.type === import_utils46.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && (parent.type === import_utils47.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils47.AST_NODE_TYPES.Property) && parent.key.type === import_utils47.AST_NODE_TYPES.Identifier) {
         return parent.key.name;
       }
       return "this function";
@@ -6758,7 +7074,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils46.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils46.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils46.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils46.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils47.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils47.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils47.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils47.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -6768,7 +7084,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const callee = node.callee;
-        if (callee.property.type !== import_utils46.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils47.AST_NODE_TYPES.Identifier) {
           return;
         }
         const factory = callee.property.name;
@@ -6783,7 +7099,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const shape = node.arguments[0];
-        if (shape !== void 0 && shape.type === import_utils46.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
+        if (shape !== void 0 && shape.type === import_utils47.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
           return;
         }
         const expression = schemaExpression(node);
@@ -6811,20 +7127,20 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils47 = require("@typescript-eslint/utils");
+var import_utils48 = require("@typescript-eslint/utils");
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === import_utils47.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils47.AST_NODE_TYPES.Literal) return String(key.value);
+  if (key.type === import_utils48.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils48.AST_NODE_TYPES.Literal) return String(key.value);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === import_utils47.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils47.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils47.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils48.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils48.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils48.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function isNullishType(node) {
-  return node.type === import_utils47.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils47.AST_NODE_TYPES.TSUndefinedKeyword;
+  return node.type === import_utils48.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils48.AST_NODE_TYPES.TSUndefinedKeyword;
 }
 function isNullableArrayOnly(node) {
   const values = node.types.filter((member) => !isNullishType(member));
@@ -6835,7 +7151,7 @@ var prefer_non_nullable_collection_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Require array types to use an empty array instead of explicit nullish unions with two equivalent empty states."
+      description: "Require declared data-shape properties and direct aliases to use non-null arrays instead of explicit nullish unions."
     },
     schema: [],
     messages: {
@@ -6851,7 +7167,7 @@ var prefer_non_nullable_collection_default = createRule({
     function checkOptionalProperty(node) {
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== import_utils47.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== import_utils48.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -6864,7 +7180,7 @@ var prefer_non_nullable_collection_default = createRule({
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils47.AST_NODE_TYPES.TSUnionType) return;
+        if (node.typeAnnotation.type !== import_utils48.AST_NODE_TYPES.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -6877,13 +7193,13 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils48 = require("@typescript-eslint/utils");
+var import_utils49 = require("@typescript-eslint/utils");
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils48.AST_NODE_TYPES.TSAsExpression || current.type === import_utils48.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils48.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils48.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils49.AST_NODE_TYPES.TSAsExpression || current.type === import_utils49.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils49.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils49.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils48.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils49.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -6898,23 +7214,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === import_utils48.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils48.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === import_utils49.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils49.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_utils48.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils49.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== import_utils48.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils49.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== import_utils48.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils49.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils49.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -6924,17 +7240,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_utils48.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
-  !isLocalFileRead(current.arguments[0]);
+  return property.name === "parse" && object !== null && object.type === import_utils49.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_utils48.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils49.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap4(current.callee);
-      const name = callee?.type === import_utils48.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils48.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils48.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      const name = callee?.type === import_utils49.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils49.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils49.AST_NODE_TYPES.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -6956,15 +7271,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_utils48.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils49.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils48.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils49.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils48.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils49.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils48.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils49.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -6983,39 +7298,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_utils48.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils48.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils48.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils48.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils48.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils49.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils49.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils49.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils49.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils49.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils48.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils49.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils48.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils49.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils48.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils48.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils48.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils49.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils49.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils49.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils48.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils49.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_utils48.AST_NODE_TYPES.UnaryExpression:
-      case import_utils48.AST_NODE_TYPES.LogicalExpression:
-      case import_utils48.AST_NODE_TYPES.ChainExpression:
+      case import_utils49.AST_NODE_TYPES.UnaryExpression:
+      case import_utils49.AST_NODE_TYPES.LogicalExpression:
+      case import_utils49.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils48.AST_NODE_TYPES.IfStatement:
-      case import_utils48.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils48.AST_NODE_TYPES.WhileStatement:
-      case import_utils48.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils48.AST_NODE_TYPES.ForStatement:
+      case import_utils49.AST_NODE_TYPES.IfStatement:
+      case import_utils49.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils49.AST_NODE_TYPES.WhileStatement:
+      case import_utils49.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils49.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -7025,7 +7340,7 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils49.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -7068,11 +7383,11 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils48.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils49.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils48.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils48.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils49.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils49.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             if (!isFullyNarrowedPattern(node)) {
               context.report({ node: node.id, messageId: "unparsedJsonAccess" });
@@ -7086,7 +7401,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils48.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils49.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -7096,7 +7411,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils48.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils48.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils49.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils49.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -7113,15 +7428,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils48.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils49.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_utils48.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils49.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils49.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -7135,13 +7450,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_utils48.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils48.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils49.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils49.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_utils48.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils49.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -7154,7 +7469,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils49 = require("@typescript-eslint/utils");
+var import_utils50 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -7254,8 +7569,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils49.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils49.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils49.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils50.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils50.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils50.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -7277,11 +7592,11 @@ var SVG_SHAPE_PRIMITIVES = /* @__PURE__ */ new Set([
   "tspan",
   "use"
 ]);
-var EMAIL_OR_PDF_IMPORT_RE = /@react-(?:email|pdf)\//;
+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_utils49.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils50.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -7292,7 +7607,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils49.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils49.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils49.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils49.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils50.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils50.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils50.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils50.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -7429,10 +7744,16 @@ var hasSemanticTokenSystem = (filename) => {
   return root !== null && workspaceHasMarker(root);
 };
 var propName = (key) => {
-  if (key.type === import_utils49.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils49.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils50.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils50.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
+var staticallyImportsEmailOrPdfRenderer = (program) => program.body.some((statement) => {
+  if (statement.type !== import_utils50.AST_NODE_TYPES.ImportDeclaration && statement.type !== import_utils50.AST_NODE_TYPES.ExportNamedDeclaration && statement.type !== import_utils50.AST_NODE_TYPES.ExportAllDeclaration) {
+    return false;
+  }
+  return statement.source !== null && typeof statement.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(statement.source.value);
+});
 var prefer_semantic_colors_default = createRule({
   name: "prefer-semantic-colors",
   meta: {
@@ -7458,44 +7779,49 @@ var prefer_semantic_colors_default = createRule({
   defaultOptions: [{}],
   create(context, [options]) {
     if (STORIES_FILE_RE.test(context.filename)) return {};
-    if (EMAIL_OR_PDF_IMPORT_RE.test(context.sourceCode.getText())) return {};
+    if (staticallyImportsEmailOrPdfRenderer(context.sourceCode.ast)) return {};
     if (options?.requireSemanticTokens === true && !hasSemanticTokenSystem(context.filename)) {
       return {};
     }
+    let importsEmailOrPdfRenderer = false;
+    const pendingReports = [];
+    const report = (node, messageId, data) => {
+      pendingReports.push({ node, messageId, data });
+    };
     const reportClasses = (value, node) => {
       for (const token of classTokens(value)) {
         const base = tailwindBase(token);
         if (RAW_PALETTE_RE.test(base)) {
-          context.report({ node, messageId: "rawPalette", data: { class: token } });
+          report(node, "rawPalette", { class: token });
         } else if (ARBITRARY_COLOR_RE.test(base) && !CSS_VAR_REFERENCE_RE.test(base)) {
-          context.report({ node, messageId: "arbitraryColor", data: { class: token } });
+          report(node, "arbitraryColor", { class: token });
         }
       }
     };
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils49.AST_NODE_TYPES.Literal:
+        case import_utils50.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils49.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils50.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils49.AST_NODE_TYPES.ArrayExpression:
+        case import_utils50.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils49.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils50.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils49.AST_NODE_TYPES.ObjectExpression:
+        case import_utils50.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils49.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils50.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils49.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils50.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils49.AST_NODE_TYPES.LogicalExpression:
+        case import_utils50.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -7503,29 +7829,32 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils49.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
-        context.report({ node, messageId: "inlineColor", data: { value: node.value } });
+      if (node.type === import_utils50.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_utils49.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils49.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils49.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils50.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils50.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils50.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils49.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils50.AST_NODE_TYPES.Identifier && node.callee.name === "require" && node.arguments[0]?.type === import_utils50.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_utils50.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils49.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils50.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils49.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils50.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -7533,13 +7862,11 @@ var prefer_semantic_colors_default = createRule({
         const name = propName(node.key);
         if (name !== null && CLASS_NAME_RE.test(name)) checkClassNode(node.value);
       },
-      // SVG presentation attributes: <path fill="#7c3aed" stroke="#7c3aed" />.
-      // Neutral drawing literals and anything inside an SVG defs container are
-      // structural, not UI tokens, so they never fire.
+      // SVG artwork colors are exempt; component presentation colors still report.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils49.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils50.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils49.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils50.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())) {
@@ -7551,13 +7878,22 @@ var prefer_semantic_colors_default = createRule({
       "JSXAttribute[name.name='style'] ObjectExpression > Property"(node) {
         const name = propName(node.key);
         if (name !== null && STYLE_COLOR_PROPS.has(name)) checkColorValueNode(node.value);
+      },
+      ImportExpression(node) {
+        if (node.source.type === import_utils50.AST_NODE_TYPES.Literal && typeof node.source.value === "string" && EMAIL_OR_PDF_MODULE_RE.test(node.source.value)) {
+          importsEmailOrPdfRenderer = true;
+        }
+      },
+      "Program:exit"() {
+        if (importsEmailOrPdfRenderer) return;
+        for (const descriptor of pendingReports) context.report(descriptor);
       }
     };
   }
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils50 = require("@typescript-eslint/utils");
+var import_utils51 = 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\/)/;
@@ -7618,6 +7954,22 @@ function isMutationMethod(node, context) {
   }
   return false;
 }
+function isFunctionArgument(node, context) {
+  const resolved = resolveNode(node, context);
+  if (resolved?.type === "ArrowFunctionExpression" || resolved?.type === "FunctionExpression") {
+    return true;
+  }
+  if (node.type !== "Identifier") return false;
+  let scope = getScope(context, node);
+  while (scope) {
+    const variable = scope.set.get(node.name);
+    if (variable?.defs.some((definition) => definition.type === "FunctionName")) {
+      return true;
+    }
+    scope = scope.upper;
+  }
+  return false;
+}
 function getPropertyNode(objNode, propName2) {
   if (!objNode || objNode.type !== "ObjectExpression") return null;
   for (const prop of objNode.properties) {
@@ -7655,13 +8007,10 @@ var prefer_server_actions_default = createRule({
     if (SKIP_FILE_REGEX.test(filename)) {
       return {};
     }
-    let isNonReactFramework = false;
+    const isNonReactFramework = context.sourceCode.ast.body.some(
+      (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(node.source.value)
+    );
     return {
-      ImportDeclaration(node) {
-        if (typeof node.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(node.source.value)) {
-          isNonReactFramework = true;
-        }
-      },
       CallExpression(node) {
         if (isNonReactFramework) return;
         let isMutation = false;
@@ -7682,7 +8031,7 @@ var prefer_server_actions_default = createRule({
           if (AXIOS_MUTATION_METHODS.has(methodName)) {
             const urlArg = node.arguments[0];
             const hasHandlerArg = node.arguments.some(
-              (arg) => arg.type === "ArrowFunctionExpression" || arg.type === "FunctionExpression"
+              (arg) => arg.type !== "SpreadElement" && isFunctionArgument(arg, context)
             );
             if (urlArg && urlArg.type !== "SpreadElement" && !hasHandlerArg && isApiUrl(urlArg, context)) {
               isMutation = true;
@@ -7709,8 +8058,33 @@ var prefer_server_actions_default = createRule({
   }
 });
 
+// src/rules/prefer-single-sentence-comment.ts
+var prefer_single_sentence_comment_default = createRule({
+  name: "prefer-single-sentence-comment",
+  meta: {
+    type: "suggestion",
+    docs: { description: "Prefer one sentence and self-documenting code over a two-sentence comment." },
+    schema: [],
+    messages: {
+      preferOneSentence: "Two-sentence comment \u2014 prefer one sentence and self-documenting code."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const group of proseGroups(context.filename, context.sourceCode)) {
+          if (!group.hasTypedTags && sentenceUnits(group.text) === 2) {
+            context.report({ node: group.comment, messageId: "preferOneSentence" });
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/rules/prefer-string-literal-union.ts
-var import_utils51 = require("@typescript-eslint/utils");
+var import_utils52 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -7753,19 +8127,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils51.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils52.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils52.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils51.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils51.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils52.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils52.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils51.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils52.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -7794,12 +8168,12 @@ function bindingSourceExpression(decl) {
   return ts2.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils51.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils52.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils51.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils52.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils52.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -7807,7 +8181,7 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils51.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils52.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
@@ -7848,7 +8222,7 @@ var prefer_string_literal_union_default = createRule({
     );
     let services;
     try {
-      services = import_utils51.ESLintUtils.getParserServices(context);
+      services = import_utils52.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -7960,7 +8334,7 @@ var prefer_string_literal_union_default = createRule({
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils51.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils52.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -8048,10 +8422,10 @@ var prefer_string_literal_union_default = createRule({
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils51.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils52.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils51.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils52.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -8060,7 +8434,7 @@ var prefer_string_literal_union_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils52 = require("@typescript-eslint/utils");
+var import_utils53 = 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"]);
@@ -8069,11 +8443,11 @@ var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
 var MIN_RUN_LENGTH = 2;
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils52.AST_NODE_TYPES.Literal:
+    case import_utils53.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils52.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils53.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils52.AST_NODE_TYPES.UnaryExpression:
+    case import_utils53.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -8081,15 +8455,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils52.AST_NODE_TYPES.Identifier:
-    case import_utils52.AST_NODE_TYPES.ThisExpression:
+    case import_utils53.AST_NODE_TYPES.Identifier:
+    case import_utils53.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils52.AST_NODE_TYPES.MemberExpression:
+    case import_utils53.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils52.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils53.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -8097,7 +8471,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils52.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils53.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -8123,24 +8497,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils52.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils53.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils52.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils53.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils52.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils52.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils52.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils53.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils53.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_utils52.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils53.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -8154,7 +8528,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         key = { kind: "index", index };
       } else {
-        if (actual.property.type !== import_utils52.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
+        if (actual.property.type !== import_utils53.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 };
@@ -8166,7 +8540,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_utils52.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils53.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -8242,7 +8616,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
       });
     }
-    function checkBody(body) {
+    function checkBody(body2) {
       let run = [];
       const flush = () => {
         const first = run[0];
@@ -8255,7 +8629,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         run = [];
       };
-      for (const statement of body) {
+      for (const statement of body2) {
         const assertion = parseAssertion(statement);
         const previous = run.at(-1);
         if (assertion !== null && previous !== void 0 && previous.key.kind === assertion.key.kind && sourceCode.getText(previous.receiver) === sourceCode.getText(assertion.receiver)) {
@@ -8281,7 +8655,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/prefer-zod-enum.ts
-var import_utils53 = require("@typescript-eslint/utils");
+var import_utils54 = require("@typescript-eslint/utils");
 var prefer_zod_enum_default = createRule({
   name: "prefer-zod-enum",
   meta: {
@@ -8301,33 +8675,39 @@ var prefer_zod_enum_default = createRule({
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils53.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils54.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils54.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_utils53.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== import_utils54.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
         return null;
       }
       const values = [];
+      let canFix = true;
       for (const element of argument.elements) {
-        if (element === null || element.type !== import_utils53.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils53.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
+        if (element?.type === import_utils54.AST_NODE_TYPES.SpreadElement) {
+          canFix = false;
+          continue;
+        }
+        if (element === null || element.type !== import_utils54.AST_NODE_TYPES.CallExpression || element.callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils54.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils54.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
           return null;
         }
         const value = element.arguments[0];
-        if (value === void 0 || value.type !== import_utils53.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
-          return null;
+        if (element.arguments.length !== 1 || value === void 0 || value.type !== import_utils54.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+          canFix = false;
+          continue;
         }
         values.push(value);
       }
-      return values;
+      return canFix ? values : void 0;
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils53.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== import_utils54.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils54.AST_NODE_TYPES.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -8344,7 +8724,7 @@ var prefer_zod_enum_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils53.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils53.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils53.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils53.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils54.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils54.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils54.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils54.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -8354,7 +8734,7 @@ var prefer_zod_enum_default = createRule({
         if (values === null) {
           return;
         }
-        const fix = buildFix(node, values);
+        const fix = values === void 0 ? void 0 : buildFix(node, values);
         context.report({
           node,
           messageId: "preferEnum",
@@ -8366,7 +8746,7 @@ var prefer_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils54 = require("@typescript-eslint/utils");
+var import_utils55 = require("@typescript-eslint/utils");
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -8403,44 +8783,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils54.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils54.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils54.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils54.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils54.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils54.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils54.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils54.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils54.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils54.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils54.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils54.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils54.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils54.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils54.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils54.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils54.AST_NODE_TYPES.TSArrayType, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils54.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils54.AST_NODE_TYPES.TSTypeLiteral, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils54.AST_NODE_TYPES.TSTypeLiteral, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils54.AST_NODE_TYPES.TSTypeLiteral, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils54.AST_NODE_TYPES.TSTypeReference, import_utils54.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils54.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils54.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils54.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils54.AST_NODE_TYPES.TSUnionType, import_utils54.AST_NODE_TYPES.TSTypeReference, import_utils54.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils54.AST_NODE_TYPES.TSUnionType, import_utils54.AST_NODE_TYPES.TSTypeReference, import_utils54.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils54.AST_NODE_TYPES.TSUnionType, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils54.AST_NODE_TYPES.TSUnionType, import_utils54.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils54.AST_NODE_TYPES.TSIntersectionType, import_utils54.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils55.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils55.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils55.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils55.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils55.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils55.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils55.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils55.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils55.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils55.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils55.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils55.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils55.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils55.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils55.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils55.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils55.AST_NODE_TYPES.TSArrayType, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils55.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils55.AST_NODE_TYPES.TSTypeLiteral, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils55.AST_NODE_TYPES.TSTypeLiteral, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils55.AST_NODE_TYPES.TSTypeLiteral, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils55.AST_NODE_TYPES.TSTypeReference, import_utils55.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils55.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils55.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils55.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils55.AST_NODE_TYPES.TSUnionType, import_utils55.AST_NODE_TYPES.TSTypeReference, import_utils55.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils55.AST_NODE_TYPES.TSUnionType, import_utils55.AST_NODE_TYPES.TSTypeReference, import_utils55.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils55.AST_NODE_TYPES.TSUnionType, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils55.AST_NODE_TYPES.TSUnionType, import_utils55.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils55.AST_NODE_TYPES.TSIntersectionType, import_utils55.AST_NODE_TYPES.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -8449,20 +8829,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils54.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils55.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils54.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils55.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils54.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils55.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils54.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils55.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -8527,14 +8907,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils54.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils55.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils54.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils55.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils54.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils55.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -8543,19 +8923,19 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName(call) {
       const callee = call.callee;
-      return callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils54.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === import_utils54.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils55.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils54.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils54.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils55.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils54.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils55.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -8586,16 +8966,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils54.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils55.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils54.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils55.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils54.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils54.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils55.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils55.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -8606,11 +8986,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils54.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils55.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils54.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils54.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils55.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils55.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -8624,8 +9004,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils54.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils54.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils55.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils55.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -8633,11 +9013,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils55.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils54.AST_NODE_TYPES.TSUnionType || node.type === import_utils54.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils55.AST_NODE_TYPES.TSUnionType || node.type === import_utils55.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -8681,13 +9061,13 @@ var prefer_zod_infer_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils54.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils54.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils54.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils54.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils55.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils55.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils55.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils55.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils54.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils55.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -8695,16 +9075,16 @@ var prefer_zod_infer_default = createRule({
           schemas.push({ name: node.id.name, fields });
         }
       },
-      /** Guard (f): `XSchema.transform(...)` anywhere in the module. */
+      /** Records `XSchema.transform(...)` and equivalent module-level reshaping. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils54.AST_NODE_TYPES.Identifier && node.property.type === import_utils54.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils55.AST_NODE_TYPES.Identifier && node.property.type === import_utils55.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
-      /** Guard (c): `z.ZodType<T>` and every other type argument it carries. */
+      /** Records every type argument carried by a Zod constraint. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils54.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils54.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils54.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils55.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils55.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils55.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -8722,7 +9102,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils54.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils55.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -8767,10 +9147,10 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils55 = require("@typescript-eslint/utils");
+var import_utils56 = require("@typescript-eslint/utils");
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils55.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils55.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils56.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils56.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -8786,7 +9166,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_utils55.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils56.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -8826,7 +9206,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils56 = require("@typescript-eslint/utils");
+var import_utils57 = require("@typescript-eslint/utils");
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
   "window",
@@ -8842,14 +9222,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils56.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils57.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils56.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils57.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils56.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils56.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils57.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils57.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -8859,7 +9239,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isStringish(node) {
-  return node.type === import_utils56.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils56.AST_NODE_TYPES.TemplateLiteral;
+  return node.type === import_utils57.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils57.AST_NODE_TYPES.TemplateLiteral;
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -8896,14 +9276,14 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils56.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils57.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils56.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils57.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils56.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils57.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -8923,7 +9303,7 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils57 = require("@typescript-eslint/utils");
+var import_utils58 = 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)$/;
@@ -8931,20 +9311,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_utils57.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils57.AST_NODE_TYPES.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === import_utils57.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils57.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var isExportedClass = (node) => node.parent.type === import_utils58.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils58.AST_NODE_TYPES.ExportDefaultDeclaration;
+var qualifiedName = (name) => name.type === import_utils58.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils58.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var readTypeReference = (annotation) => {
-  if (annotation === void 0 || annotation.type !== import_utils57.AST_NODE_TYPES.TSTypeReference) return null;
+  if (annotation === void 0 || annotation.type !== import_utils58.AST_NODE_TYPES.TSTypeReference) return null;
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils57.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils57.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils58.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils58.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_utils57.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils57.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils57.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils58.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils58.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils58.AST_NODE_TYPES.Identifier) return null;
   const reference = readTypeReference(target.typeAnnotation?.typeAnnotation);
   if (reference === null) return null;
   return { name: target.name, ...reference };
@@ -8952,8 +9332,8 @@ var namedParameterCollaborator = (annotated) => {
 var propertySignatureTypes = (members) => {
   const types = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (member.type !== import_utils57.AST_NODE_TYPES.TSPropertySignature) continue;
-    if (member.computed || member.key.type !== import_utils57.AST_NODE_TYPES.Identifier) continue;
+    if (member.type !== import_utils58.AST_NODE_TYPES.TSPropertySignature) continue;
+    if (member.computed || member.key.type !== import_utils58.AST_NODE_TYPES.Identifier) continue;
     const reference = readTypeReference(member.typeAnnotation?.typeAnnotation);
     if (reference === null) continue;
     types.set(member.key.name, reference);
@@ -8964,18 +9344,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_utils57.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils57.AST_NODE_TYPES.TSInterfaceDeclaration) {
+    const declaration = statement.type === import_utils58.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils58.AST_NODE_TYPES.TSInterfaceDeclaration) {
       objects.set(declaration.id.name, propertySignatureTypes(declaration.body.body));
       continue;
     }
-    if (declaration?.type !== import_utils57.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
+    if (declaration?.type !== import_utils58.AST_NODE_TYPES.TSTypeAliasDeclaration) continue;
     const aliased = declaration.typeAnnotation;
-    if (aliased.type === import_utils57.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils57.AST_NODE_TYPES.TSConstructorType) {
+    if (aliased.type === import_utils58.AST_NODE_TYPES.TSFunctionType || aliased.type === import_utils58.AST_NODE_TYPES.TSConstructorType) {
       functionAliases.add(declaration.id.name);
       continue;
     }
-    const literals = aliased.type === import_utils57.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils57.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils57.AST_NODE_TYPES.TSTypeLiteral) : [];
+    const literals = aliased.type === import_utils58.AST_NODE_TYPES.TSTypeLiteral ? [aliased] : aliased.type === import_utils58.AST_NODE_TYPES.TSIntersectionType ? aliased.types.filter((part) => part.type === import_utils58.AST_NODE_TYPES.TSTypeLiteral) : [];
     if (literals.length === 0) continue;
     const merged = /* @__PURE__ */ new Map();
     for (const literal of literals) {
@@ -8988,10 +9368,10 @@ var fileTypeIndex = (program) => {
   return { objects, functionAliases };
 };
 var bagMemberTypes = (annotation, declared) => {
-  if (annotation.type === import_utils57.AST_NODE_TYPES.TSTypeLiteral) {
+  if (annotation.type === import_utils58.AST_NODE_TYPES.TSTypeLiteral) {
     return propertySignatureTypes(annotation.members);
   }
-  if (annotation.type !== import_utils57.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils57.AST_NODE_TYPES.Identifier) {
+  if (annotation.type !== import_utils58.AST_NODE_TYPES.TSTypeReference || annotation.typeName.type !== import_utils58.AST_NODE_TYPES.Identifier) {
     return null;
   }
   return declared().objects.get(annotation.typeName.name) ?? null;
@@ -9003,11 +9383,11 @@ var objectPatternCollaborators = (pattern, declared) => {
   if (members === null) return [];
   const collaborators = [];
   for (const property of pattern.properties) {
-    if (property.type !== import_utils57.AST_NODE_TYPES.Property || property.computed) continue;
-    if (property.key.type !== import_utils57.AST_NODE_TYPES.Identifier) continue;
+    if (property.type !== import_utils58.AST_NODE_TYPES.Property || property.computed) continue;
+    if (property.key.type !== import_utils58.AST_NODE_TYPES.Identifier) continue;
     const key = property.key.name;
-    const bound = property.value.type === import_utils57.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
-    if (bound.type !== import_utils57.AST_NODE_TYPES.Identifier) continue;
+    const bound = property.value.type === import_utils58.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+    if (bound.type !== import_utils58.AST_NODE_TYPES.Identifier) continue;
     if (CONFIGISH_NAME_RE.test(key)) continue;
     const reference = members.get(key);
     if (reference === void 0) continue;
@@ -9017,8 +9397,8 @@ var objectPatternCollaborators = (pattern, declared) => {
 };
 var parameterCollaborators = (parameter, declared) => {
   let target = parameter;
-  if (target.type === import_utils57.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type === import_utils57.AST_NODE_TYPES.ObjectPattern) {
+  if (target.type === import_utils58.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type === import_utils58.AST_NODE_TYPES.ObjectPattern) {
     return objectPatternCollaborators(target, declared);
   }
   const named2 = namedParameterCollaborator(parameter);
@@ -9032,22 +9412,22 @@ var typeParameterNames = (...declarations) => {
   return names;
 };
 var readConstructor = (ctor, declared, typeParameters) => {
-  const body = ctor.value.body;
+  const body2 = ctor.value.body;
   const storedFrom = /* @__PURE__ */ new Set();
   let constructedFields = 0;
-  if (body !== null && body !== void 0) {
-    for (const statement of body.body) {
-      if (statement.type !== import_utils57.AST_NODE_TYPES.ExpressionStatement) continue;
+  if (body2 !== null && body2 !== void 0) {
+    for (const statement of body2.body) {
+      if (statement.type !== import_utils58.AST_NODE_TYPES.ExpressionStatement) continue;
       const expression = statement.expression;
-      if (expression.type !== import_utils57.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils57.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils57.AST_NODE_TYPES.ThisExpression) {
+      if (expression.type !== import_utils58.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils58.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils58.AST_NODE_TYPES.ThisExpression) {
         continue;
       }
       const source = expression.right;
-      if (source.type === import_utils57.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils58.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils57.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils58.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === import_utils57.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils57.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils58.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils58.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -9055,7 +9435,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_utils57.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
+      const stored = parameter.type === import_utils58.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;
@@ -9088,20 +9468,20 @@ var subtreeHas = (root, found) => {
   visit(root);
   return hit;
 };
-var isFrameworkWiring = (body) => subtreeHas(body, (node) => {
-  if (node.type === import_utils57.AST_NODE_TYPES.CallExpression) {
+var isFrameworkWiring = (body2) => subtreeHas(body2, (node) => {
+  if (node.type === import_utils58.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils57.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils58.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils58.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils58.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils57.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils57.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils58.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils58.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_utils57.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils57.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils58.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils58.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
@@ -9116,14 +9496,14 @@ var isTransportWrapper = (className, collaborators, program) => {
     return target.endsWith(other) || other.endsWith(target);
   });
 };
-var publicMethodNames = (body) => {
+var publicMethodNames = (body2) => {
   const names = [];
-  for (const member of body.body) {
-    if (member.type !== import_utils57.AST_NODE_TYPES.MethodDefinition) continue;
+  for (const member of body2.body) {
+    if (member.type !== import_utils58.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_utils57.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils57.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils58.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils58.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -9156,7 +9536,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_utils57.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils58.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(
@@ -9185,18 +9565,18 @@ var require_interface_for_injected_service_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils58 = require("@typescript-eslint/utils");
+var import_utils59 = require("@typescript-eslint/utils");
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils58.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils59.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils58.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils59.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils58.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils59.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -9204,23 +9584,23 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils58.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils59.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils58.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils58.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils59.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_utils58.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils59.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils58.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils59.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils58.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils58.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils59.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils59.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -9240,14 +9620,14 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils58.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils59.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_utils58.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils59.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -9258,8 +9638,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils58.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils58.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils59.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -9274,11 +9654,11 @@ var require_zod_form_validation_default = createRule({
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils58.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
+      return parent !== null && parent !== void 0 && parent.type === import_utils59.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === import_utils59.AST_NODE_TYPES.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === import_utils58.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils58.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils59.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils59.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -9306,7 +9686,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils59 = require("@typescript-eslint/utils");
+var import_utils60 = 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;
@@ -9337,7 +9717,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils60 = require("@typescript-eslint/utils");
+var import_utils61 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -9362,15 +9742,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils60.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils61.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils60.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils61.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils60.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils61.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils60.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils61.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -9415,13 +9795,13 @@ var zod_naming_convention_default = createRule({
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils60.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils61.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils61.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_utils60.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils61.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -9445,47 +9825,47 @@ var renamedRules = {
 var retiredRules = {
   "ban-loose-type-guards-in-tests": {
     removedIn: "5.0.0",
-    reason: "Read at 39 findings with 0 true positives in the #183 corpus audit. Delete the config entry; no replacement."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   },
   "no-implicit-attribute-access": {
     removedIn: "5.0.0",
-    reason: "Read at 50 findings with 0 true positives in the #183 corpus audit. Delete the config entry; no replacement."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   },
   "no-sequential-await": {
     removedIn: "3.0.0",
-    reason: "218 findings, 100% range-contained in core `no-await-in-loop`, which the shipped config already enables. Delete the entry; `no-await-in-loop` covers it."
+    reason: "Delete the entry; core `no-await-in-loop` covers it."
   },
   "no-template-literal-in-log": {
     removedIn: "2.3.1",
-    reason: "Withdrawn. Delete the config entry; no replacement."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   },
   "no-unsafe-cast": {
     removedIn: "3.0.0",
-    reason: '1,089 findings, matching `@typescript-eslint/consistent-type-assertions` ("never") at the identical line and column with zero residue. Delete the entry; keep that rule enabled.'
+    reason: "Delete the entry; keep `@typescript-eslint/consistent-type-assertions` enabled."
   },
   "prefer-setup-file-mocks": {
     removedIn: "5.0.0",
-    reason: "Read at 50 findings with 0 true positives in the #183 corpus audit. Delete the config entry; no replacement."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   },
   "prefer-shadcn": {
     removedIn: "3.0.0",
-    reason: "645 findings, a subset of `react/forbid-elements`; its 24-position residue was all design-system primitives being told not to be the design system. Delete the entry."
+    reason: "Delete the entry; use `react/forbid-elements` for element restrictions."
   },
   "primary-export-file-name": {
     removedIn: "4.0.0",
-    reason: "Renamed files after one of their exports \u2014 316 findings over 1,966 files sampled 11 harmful / 15 useless / 4 valuable, including telling `next.config.ts` to become `next-config.ts`. Delete the config entry."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   },
   "require-parameterized-tests": {
     removedIn: "4.0.0",
-    reason: "Landed in #153 and never wired up: absent from the `rules` record, every preset, and eslint.strict.mjs. Nothing to migrate."
+    reason: "Delete stale references; the rule was never registered."
   },
   "require-schema-validate-search": {
     removedIn: "3.0.0",
-    reason: "14 findings, all matched line-and-column by `@typescript-eslint/consistent-type-assertions`. Delete the entry."
+    reason: "Delete the entry; use `@typescript-eslint/consistent-type-assertions`."
   },
   "single-public-export": {
     removedIn: "3.0.0",
-    reason: "3 findings, all also reported by the then-live `primary-export-file-name` (itself withdrawn in 4.0.0). Delete the entry."
+    reason: "Delete the config entry and suppressions; there is no replacement."
   }
 };
 
@@ -9504,6 +9884,7 @@ var rules = {
   "no-insecure-random-id": no_insecure_random_id_default,
   "no-json-stringify-error": no_json_stringify_error_default,
   "no-log-only-catch": no_log_only_catch_default,
+  "no-long-comment": no_long_comment_default,
   "no-offset-pagination": no_offset_pagination_default,
   "no-positional-tuple-return": no_positional_tuple_return_default,
   "no-raw-env": no_raw_env_default,
@@ -9519,6 +9900,7 @@ var rules = {
   "no-storage-in-stateless-modules": no_storage_in_stateless_modules_default,
   "no-string-concat-in-loop": no_string_concat_in_loop_default,
   "no-tautological-expect": no_tautological_expect_default,
+  "no-typed-doc-sections": no_typed_doc_sections_default,
   "no-trailing-value-narration": no_trailing_value_narration_default,
   "no-declaration-comment-wall": no_declaration_comment_wall_default,
   "no-union-in-comment": no_union_in_comment_default,
@@ -9534,6 +9916,7 @@ var rules = {
   "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
   "prefer-semantic-colors": prefer_semantic_colors_default,
   "prefer-server-actions": prefer_server_actions_default,
+  "prefer-single-sentence-comment": prefer_single_sentence_comment_default,
   "prefer-string-literal-union": prefer_string_literal_union_default,
   "prefer-whole-object-assertion": prefer_whole_object_assertion_default,
   "prefer-zod-enum": prefer_zod_enum_default,
@@ -9547,7 +9930,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "9.5.0"
+  version: "9.7.0"
 };
 var recommendedRules = {
   "@sarj/enforce-file-structure": "warn",
@@ -9562,6 +9945,7 @@ var recommendedRules = {
   "@sarj/no-insecure-random-id": "warn",
   "@sarj/no-json-stringify-error": "warn",
   "@sarj/no-log-only-catch": "warn",
+  "@sarj/no-long-comment": "warn",
   "@sarj/no-offset-pagination": "warn",
   "@sarj/no-positional-tuple-return": "warn",
   "@sarj/no-repeated-string-literal": "warn",
@@ -9574,6 +9958,7 @@ var recommendedRules = {
   "@sarj/no-sleep-in-test-body": "warn",
   "@sarj/no-string-concat-in-loop": "warn",
   "@sarj/no-tautological-expect": "warn",
+  "@sarj/no-typed-doc-sections": "warn",
   "@sarj/no-trailing-value-narration": "warn",
   "@sarj/no-declaration-comment-wall": "warn",
   "@sarj/no-union-in-comment": "warn",
@@ -9589,6 +9974,7 @@ var recommendedRules = {
   "@sarj/prefer-schema-for-api-payload": "warn",
   "@sarj/prefer-semantic-colors": ["warn", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "warn",
+  "@sarj/prefer-single-sentence-comment": "warn",
   "@sarj/prefer-string-literal-union": "warn",
   "@sarj/prefer-whole-object-assertion": "warn",
   "@sarj/prefer-zod-enum": "warn",
@@ -9614,6 +10000,7 @@ var strictRules = {
   "@sarj/no-insecure-random-id": "error",
   "@sarj/no-json-stringify-error": "error",
   "@sarj/no-log-only-catch": "error",
+  "@sarj/no-long-comment": "error",
   "@sarj/no-offset-pagination": "error",
   "@sarj/no-positional-tuple-return": "error",
   "@sarj/no-raw-env": "error",
@@ -9629,6 +10016,7 @@ var strictRules = {
   "@sarj/no-storage-in-stateless-modules": "error",
   "@sarj/no-string-concat-in-loop": "error",
   "@sarj/no-tautological-expect": "error",
+  "@sarj/no-typed-doc-sections": "error",
   "@sarj/no-trailing-value-narration": "error",
   "@sarj/no-declaration-comment-wall": "error",
   "@sarj/no-union-in-comment": "error",
@@ -9644,6 +10032,7 @@ var strictRules = {
   "@sarj/prefer-schema-for-api-payload": "error",
   "@sarj/prefer-semantic-colors": ["error", { requireSemanticTokens: true }],
   "@sarj/prefer-server-actions": "error",
+  "@sarj/prefer-single-sentence-comment": "warn",
   "@sarj/prefer-string-literal-union": "error",
   "@sarj/prefer-whole-object-assertion": "error",
   "@sarj/prefer-zod-enum": "error",