@sarj/eslint-plugin 13.0.0 → 14.0.0

package/dist/index.js

@@ -622,77 +622,8 @@ var duplicate_test_body_default = createRule({
   }
 });
 
-// src/rules/no-async-callback-in-wait-for.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
-var noAsyncCallbackInWaitForDocumentation = {
-  summary: "Disallow async callbacks in `waitFor` to prevent swallowed promise rejections.",
-  rationale: "`waitFor` retries synchronous assertions; an async callback changes that contract and can hide a rejected assertion promise.",
-  remediation: "Remove `async` and keep the assertions inside `waitFor` synchronous.",
-  category: "testing",
-  aliases: ["no-async-callback-in-waitfor"],
-  limitations: [
-    "The rule checks inline first-argument callbacks to bare or non-computed `.waitFor` calls in test files."
-  ],
-  examples: [
-    {
-      id: "synchronous-wait-for-callback",
-      title: "waitFor retries a synchronous assertion",
-      outcome: "no-match",
-      files: [{ path: "src/component.test.ts", source: "it('works', async () => { await waitFor(() => expect(foo).toBe(true)); });" }],
-      focusPath: "src/component.test.ts",
-      expectedCount: 0,
-      public: true
-    },
-    {
-      id: "async-wait-for-callback",
-      title: "waitFor receives an async callback",
-      outcome: "match",
-      files: [{ path: "src/component.test.ts", source: "it('fails', async () => { await waitFor(async () => expect(foo).toBe(true)); });" }],
-      focusPath: "src/component.test.ts",
-      expectedCount: 1,
-      public: true
-    }
-  ]
-};
-var isWaitForCallee = (callee) => {
-  if (callee.type === AST_NODE_TYPES3.Identifier) return callee.name === "waitFor";
-  return callee.type === AST_NODE_TYPES3.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES3.Identifier && callee.property.name === "waitFor";
-};
-var no_async_callback_in_wait_for_default = createRule({
-  name: "no-async-callback-in-wait-for",
-  documentation: noAsyncCallbackInWaitForDocumentation,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow async callbacks in `waitFor` to prevent swallowed promise rejections."
-    },
-    schema: [],
-    messages: {
-      noAsyncCallbackInWaitFor: "The callback to `waitFor` should not be async. It expects synchronous assertions and runs the callback repeatedly."
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (!isTestFile(context.filename)) {
-      return {};
-    }
-    return {
-      CallExpression(node) {
-        if (!isWaitForCallee(node.callee)) return;
-        const callback = node.arguments[0];
-        if (callback && (callback.type === AST_NODE_TYPES3.ArrowFunctionExpression || callback.type === AST_NODE_TYPES3.FunctionExpression) && callback.async) {
-          context.report({
-            node: callback,
-            messageId: "noAsyncCallbackInWaitFor"
-          });
-        }
-      }
-    };
-  }
-});
-
 // src/rules/no-client-side-data-fetching.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 var noClientSideDataFetchingDocumentation = {
   summary: "Disallow direct data fetching inside `useEffect` or `useLayoutEffect`.",
   rationale: "Effect-driven reads begin after rendering and can create request waterfalls, duplicate fetches, and loading-state layout shifts.",
@@ -745,33 +676,33 @@ var ANALYTICS_SEGMENTS = /* @__PURE__ */ new Set([
 ]);
 function isEffectHookCall(node) {
   const callee = node.callee;
-  if (callee.type === AST_NODE_TYPES4.Identifier) {
+  if (callee.type === AST_NODE_TYPES3.Identifier) {
     return callee.name === "useEffect" || callee.name === "useLayoutEffect";
   }
-  if (callee.type === AST_NODE_TYPES4.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES4.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES4.Identifier) {
+  if (callee.type === AST_NODE_TYPES3.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES3.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES3.Identifier) {
     return callee.property.name === "useEffect" || callee.property.name === "useLayoutEffect";
   }
   return false;
 }
 function isFetchCall(node) {
   const callee = node.callee;
-  if (callee.type === AST_NODE_TYPES4.Identifier && callee.name === "fetch") {
+  if (callee.type === AST_NODE_TYPES3.Identifier && callee.name === "fetch") {
     const method = readMethodProperty(node.arguments[1]);
     if (method !== null && method !== "GET") {
       return false;
     }
     return true;
   }
-  if (callee.type === AST_NODE_TYPES4.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES4.Identifier && FETCH_LIBS.has(callee.object.name) && callee.property.type === AST_NODE_TYPES4.Identifier) {
+  if (callee.type === AST_NODE_TYPES3.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES3.Identifier && FETCH_LIBS.has(callee.object.name) && callee.property.type === AST_NODE_TYPES3.Identifier) {
     return HTTP_METHOD_NAMES.has(callee.property.name);
   }
-  if (callee.type === AST_NODE_TYPES4.Identifier && (callee.name === "axios" || callee.name === "ky")) {
+  if (callee.type === AST_NODE_TYPES3.Identifier && (callee.name === "axios" || callee.name === "ky")) {
     const firstArg = node.arguments[0];
     const secondArg = node.arguments[1];
     let configArg;
-    if (firstArg?.type === AST_NODE_TYPES4.ObjectExpression) {
+    if (firstArg?.type === AST_NODE_TYPES3.ObjectExpression) {
       configArg = firstArg;
-    } else if (secondArg?.type === AST_NODE_TYPES4.ObjectExpression) {
+    } else if (secondArg?.type === AST_NODE_TYPES3.ObjectExpression) {
       configArg = secondArg;
     }
     const method = readMethodProperty(configArg);
@@ -783,16 +714,16 @@ function isFetchCall(node) {
   return false;
 }
 function readMethodProperty(optionsArg) {
-  if (!optionsArg || optionsArg.type !== AST_NODE_TYPES4.ObjectExpression) {
+  if (!optionsArg || optionsArg.type !== AST_NODE_TYPES3.ObjectExpression) {
     return null;
   }
   for (const prop of optionsArg.properties) {
-    if (prop.type !== AST_NODE_TYPES4.Property) continue;
+    if (prop.type !== AST_NODE_TYPES3.Property) continue;
     if (prop.computed) continue;
     const key = prop.key;
-    const matchesMethodKey = key.type === AST_NODE_TYPES4.Identifier && key.name === "method" || key.type === AST_NODE_TYPES4.Literal && key.value === "method";
+    const matchesMethodKey = key.type === AST_NODE_TYPES3.Identifier && key.name === "method" || key.type === AST_NODE_TYPES3.Literal && key.value === "method";
     if (!matchesMethodKey) continue;
-    if (prop.value.type === AST_NODE_TYPES4.Literal && typeof prop.value.value === "string") {
+    if (prop.value.type === AST_NODE_TYPES3.Literal && typeof prop.value.value === "string") {
       return prop.value.value.toUpperCase();
     }
     return null;
@@ -807,13 +738,13 @@ function isAnalyticsCall(node) {
 function extractUrlString(node) {
   const firstArg = node.arguments[0];
   if (!firstArg) return "";
-  if (firstArg.type === AST_NODE_TYPES4.Literal && typeof firstArg.value === "string") {
+  if (firstArg.type === AST_NODE_TYPES3.Literal && typeof firstArg.value === "string") {
     return firstArg.value;
   }
-  if (firstArg.type === AST_NODE_TYPES4.TemplateLiteral) {
+  if (firstArg.type === AST_NODE_TYPES3.TemplateLiteral) {
     return firstArg.quasis.map((q) => q.value.cooked).join("");
   }
-  if (firstArg.type === AST_NODE_TYPES4.Identifier) {
+  if (firstArg.type === AST_NODE_TYPES3.Identifier) {
     return firstArg.name;
   }
   return "";
@@ -855,10 +786,10 @@ var no_client_side_data_fetching_default = createRule({
 });
 
 // src/rules/no-comment-cruft.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
 
 // src/rules/_comments.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
 var REF_RE = /https?:\/\/|\bRFC[- ]?\d+|\bPEP[- ]?\d+|\bCVE-\d{4}|\b(?!UTF-|SHA-|ISO-|AES-|CRC-|MD-|PCM-|EOF-|API-|BASE-)[A-Z][A-Z0-9]{1,9}-\d[A-Z0-9]{0,5}\b|(?<![&\w])#\d{2,6}\b|@[a-z][\w.-]*\.(?:us|com|ai|io|net|org|dev)\b/;
 var VERSION_RE = /(?:>=|<=|==|<|>)\s*v?\d+\.\d+|\bv\d+\.\d+|\b(?:since|until|as of)\s+(?:v?\d+\.\d+|Python\s*\d)/i;
 var UNITS_RE = /[~<>]?\d+(?:\.\d+)?\s?(?:ms|s\b|sec\b|seconds?\b|min\b|minutes?\b|hours?\b|days?\b|KB|MB|MiB|GiB|kHz|Hz|bytes?\b|bit\b|-bit\b|%|px\b|rps\b|qps\b)|\b[1-5]xx\b|\b(?:301|302|304|307|308|400|401|403|404|405|409|410|412|422|425|429|500|501|502|503|504)\b/;
@@ -944,10 +875,10 @@ var NARRATION_MAX_WORDS = 6;
 var NARRATION_MIN_CONTENT = 1;
 var TOKEN_PLURAL_MIN = 4;
 var RESTATABLE_STATEMENTS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES5.ExpressionStatement,
-  AST_NODE_TYPES5.ReturnStatement,
-  AST_NODE_TYPES5.ThrowStatement,
-  AST_NODE_TYPES5.VariableDeclaration
+  AST_NODE_TYPES4.ExpressionStatement,
+  AST_NODE_TYPES4.ReturnStatement,
+  AST_NODE_TYPES4.ThrowStatement,
+  AST_NODE_TYPES4.VariableDeclaration
 ]);
 var NARRATION_VERB_RE = /^(?:add|append|assign|build|calculate|call|check|clear|close|compute|convert|copy|count|create|declare|decrement|define|delete|extract|fetch|filter|find|format|generate|get|handle|increment|init|initialise|initialize|insert|iterate|join|load|log|loop|make|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)?$/i;
 var NARRATION_STOPWORDS = /* @__PURE__ */ new Set([
@@ -1002,12 +933,12 @@ function normalizeToken(word) {
 function restatableStatementBelow(comment, sourceCode) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
   if (token === null || token.loc.start.line !== comment.loc.end.line + 1) return null;
-  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== AST_NODE_TYPES5.Program; node = node.parent) {
+  for (let node = sourceCode.getNodeByRangeIndex(token.range[0]); node != null && node.type !== AST_NODE_TYPES4.Program; node = node.parent) {
     if (!RESTATABLE_STATEMENTS.has(node.type)) continue;
     if (node.loc.start.line !== token.loc.start.line || node.loc.end.line !== node.loc.start.line) {
       return null;
     }
-    if (node.type === AST_NODE_TYPES5.VariableDeclaration && isTrivialInitializer(node)) {
+    if (node.type === AST_NODE_TYPES4.VariableDeclaration && isTrivialInitializer(node)) {
       return null;
     }
     return sourceCode.getText(node);
@@ -1017,8 +948,8 @@ function restatableStatementBelow(comment, sourceCode) {
 function isTrivialInitializer(node) {
   return node.declarations.every((declarator) => {
     const init = declarator.init;
-    if (init == null || init.type === AST_NODE_TYPES5.Literal) return true;
-    return init.type === AST_NODE_TYPES5.ArrayExpression && init.elements.length === 0 || init.type === AST_NODE_TYPES5.ObjectExpression && init.properties.length === 0;
+    if (init == null || init.type === AST_NODE_TYPES4.Literal) return true;
+    return init.type === AST_NODE_TYPES4.ArrayExpression && init.elements.length === 0 || init.type === AST_NODE_TYPES4.ObjectExpression && init.properties.length === 0;
   });
 }
 function restatesStatementHead(body2, statement) {
@@ -1099,6 +1030,7 @@ var STEP_NARRATION_RE = /^(?:first(?:ly)?|second(?:ly)?|third(?:ly)?|then|next|a
 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 EDITORIAL_PLACEHOLDER_RE = /^(?:(?:implementation omitted|existing code here|your code here|rest of (?:the )?code (?:is )?unchanged|same as above|placeholder implementation)\s*[.!]?|in a real (?:app(?:lication)?|implementation),?\s+(?:this|we|you|it)\s+would\s+(?:call|fetch|generate|download|persist|save|send|store|write)\b[^,;]*[.!]?)$/i;
 var FOR_NOW_RE = /\bfor now\b/i;
+var JSDOC_DEBT_RE = /^@?(?:todo|fixme)\b/i;
 var DEFERRAL_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -1227,6 +1159,7 @@ var DIAGRAM_ARROW_RE = /[-=~]{2,}>|<[-=~]{2,}/;
 var CODE_KEYWORD_RE = /^(import |export |const |let |var |function\b|class |interface |type \w|enum |return\b|throw |await |async |if\s*\(|for\s*\(|while\s*\(|switch\s*\(|new |console\.)/;
 var CODE_TAIL_RE = /[;{}()]\s*$|=>\s*$|,\s*$/;
 var ASSIGN_RE = /^[A-Za-z_$][\w.$[\]]*\s*(?:=(?![=>])|\+=|-=|\*=)\s*\S.*[;)}\]]\s*$/;
+var DECLARATION_RE = /^(?:export\s+)?(?:declare\s+)?(?:const|let|var)\s+[A-Za-z_$][\w$]*(?:\s*:\s*[^=]+)?\s*=\s*(?:[A-Za-z_$][\w.$]*(?:\s*\(|\s*$)|["'`]|\[|\{|\d|true\b|false\b|null\b|undefined\b|new\b|await\b|async\b|function\b|class\b)/;
 var CALL_RE = /^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
 var ASSERTION_CODE_RE = /^(?:await\s+)?(?:expect(?:TypeOf)?|assert(?:\.\w+)?)\s*\(/;
 var HTTP_CONTRACT_RE = /\b(?:GET|HEAD|OPTIONS|PATCH|POST|PUT|DELETE)\s+(?:https?:\/\/|\/|\{[A-Za-z_$])/;
@@ -1254,6 +1187,7 @@ function looksLikeCode(text, allowCall = true) {
   if (!t) return false;
   if (PROSE_ASSIGNMENT_RE.test(t)) return false;
   if (CODE_KEYWORD_RE.test(t) && CODE_TAIL_RE.test(t)) return true;
+  if (DECLARATION_RE.test(t)) return true;
   if (ASSIGN_RE.test(t)) return true;
   if (ASSERTION_CODE_RE.test(t)) return true;
   return allowCall && CALL_RE.test(t);
@@ -1317,13 +1251,13 @@ function restatesWholeStatement(body2, statement) {
   return statement !== null && restatesStatementHead(body2, statement.replaceAll("(", " "));
 }
 var STATEMENT_CONTAINERS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES6.Program,
-  AST_NODE_TYPES6.BlockStatement,
-  AST_NODE_TYPES6.ClassBody,
-  AST_NODE_TYPES6.StaticBlock,
-  AST_NODE_TYPES6.SwitchCase,
-  AST_NODE_TYPES6.TSModuleBlock,
-  AST_NODE_TYPES6.TSInterfaceBody
+  AST_NODE_TYPES5.Program,
+  AST_NODE_TYPES5.BlockStatement,
+  AST_NODE_TYPES5.ClassBody,
+  AST_NODE_TYPES5.StaticBlock,
+  AST_NODE_TYPES5.SwitchCase,
+  AST_NODE_TYPES5.TSModuleBlock,
+  AST_NODE_TYPES5.TSInterfaceBody
 ]);
 function statementAttachmentBelow(comment, sourceCode) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
@@ -1341,30 +1275,30 @@ function statementAttachmentBelow(comment, sourceCode) {
   return null;
 }
 var WALL_STATEMENTS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES6.ExpressionStatement,
-  AST_NODE_TYPES6.ReturnStatement,
-  AST_NODE_TYPES6.ThrowStatement,
-  AST_NODE_TYPES6.VariableDeclaration,
-  AST_NODE_TYPES6.IfStatement,
-  AST_NODE_TYPES6.ForStatement,
-  AST_NODE_TYPES6.ForOfStatement,
-  AST_NODE_TYPES6.ForInStatement,
-  AST_NODE_TYPES6.WhileStatement,
-  AST_NODE_TYPES6.DoWhileStatement,
-  AST_NODE_TYPES6.SwitchStatement,
-  AST_NODE_TYPES6.TryStatement
+  AST_NODE_TYPES5.ExpressionStatement,
+  AST_NODE_TYPES5.ReturnStatement,
+  AST_NODE_TYPES5.ThrowStatement,
+  AST_NODE_TYPES5.VariableDeclaration,
+  AST_NODE_TYPES5.IfStatement,
+  AST_NODE_TYPES5.ForStatement,
+  AST_NODE_TYPES5.ForOfStatement,
+  AST_NODE_TYPES5.ForInStatement,
+  AST_NODE_TYPES5.WhileStatement,
+  AST_NODE_TYPES5.DoWhileStatement,
+  AST_NODE_TYPES5.SwitchStatement,
+  AST_NODE_TYPES5.TryStatement
 ]);
 function directStatements(container) {
   switch (container.type) {
-    case AST_NODE_TYPES6.Program:
-    case AST_NODE_TYPES6.BlockStatement:
-    case AST_NODE_TYPES6.ClassBody:
-    case AST_NODE_TYPES6.StaticBlock:
-    case AST_NODE_TYPES6.TSModuleBlock:
+    case AST_NODE_TYPES5.Program:
+    case AST_NODE_TYPES5.BlockStatement:
+    case AST_NODE_TYPES5.ClassBody:
+    case AST_NODE_TYPES5.StaticBlock:
+    case AST_NODE_TYPES5.TSModuleBlock:
       return container.body;
-    case AST_NODE_TYPES6.SwitchCase:
+    case AST_NODE_TYPES5.SwitchCase:
       return container.consequent;
-    case AST_NODE_TYPES6.TSInterfaceBody:
+    case AST_NODE_TYPES5.TSInterfaceBody:
       return container.body;
     default:
       return [];
@@ -1383,8 +1317,8 @@ function isWeakWalkthroughComment(body2, statement) {
   return matched / described.length >= 0.5 && described.length - matched <= WALL_MAX_NOVEL_WORDS;
 }
 var TYPE_MEMBER_CONTAINERS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES6.TSInterfaceBody,
-  AST_NODE_TYPES6.TSTypeLiteral
+  AST_NODE_TYPES5.TSInterfaceBody,
+  AST_NODE_TYPES5.TSTypeLiteral
 ]);
 function runCitesAReference(comments, index) {
   for (let i = index; i >= 0; i--) {
@@ -1478,10 +1412,10 @@ var no_comment_cruft_default = createRule({
       for (let node = sourceCode.getNodeByRangeIndex(
         comment.range[0]
       ); node != null; node = node.parent) {
-        if (node.type === AST_NODE_TYPES6.JSXExpressionContainer) {
-          return node.expression.type === AST_NODE_TYPES6.JSXEmptyExpression;
+        if (node.type === AST_NODE_TYPES5.JSXExpressionContainer) {
+          return node.expression.type === AST_NODE_TYPES5.JSXEmptyExpression;
         }
-        if (node.type === AST_NODE_TYPES6.Program) return false;
+        if (node.type === AST_NODE_TYPES5.Program) return false;
       }
       return false;
     }
@@ -1583,6 +1517,11 @@ var no_comment_cruft_default = createRule({
           }
           if (wallMembers.has(comment)) continue;
           if (isJsDoc(comment)) {
+            const debt = comment.value.split("\n").map(stripCommentMarker).find((line) => JSDOC_DEBT_RE.test(line));
+            if (debt !== void 0 && !runCitesAReference(comments, i)) {
+              context.report({ node: comment, messageId: "untrackedTodo" });
+              continue;
+            }
             if (isStandalone(comment) && isSectionJsDoc(comment)) {
               context.report({ node: comment, messageId: "sectionBanner" });
             }
@@ -1648,7 +1587,7 @@ var no_comment_cruft_default = createRule({
 });
 
 // src/rules/no-conditional-in-test.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
 var noConditionalInTestDocumentation = {
   summary: "Disallow test conditionals that can skip a runtime assertion or exit the test before one runs.",
   rationale: "A branch can skip the assertion that gives a test its meaning, allowing unexpected inputs to pass silently.",
@@ -1687,9 +1626,9 @@ var NON_TEST_MEMBERS = /* @__PURE__ */ new Set([
   "describe"
 ]);
 var FUNCTION_TYPES2 = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES7.FunctionDeclaration,
-  AST_NODE_TYPES7.FunctionExpression,
-  AST_NODE_TYPES7.ArrowFunctionExpression
+  AST_NODE_TYPES6.FunctionDeclaration,
+  AST_NODE_TYPES6.FunctionExpression,
+  AST_NODE_TYPES6.ArrowFunctionExpression
 ]);
 var ASSERTION_ROOTS = /* @__PURE__ */ new Set([
   "expect",
@@ -1710,38 +1649,38 @@ function nearestEnclosingFunction(node) {
   return null;
 }
 function testCallerName(callee) {
-  if (callee.type === AST_NODE_TYPES7.Identifier) {
+  if (callee.type === AST_NODE_TYPES6.Identifier) {
     return callee.name;
   }
-  if (callee.type === AST_NODE_TYPES7.MemberExpression) {
+  if (callee.type === AST_NODE_TYPES6.MemberExpression) {
     return testCallerName(callee.object);
   }
-  if (callee.type === AST_NODE_TYPES7.CallExpression) {
+  if (callee.type === AST_NODE_TYPES6.CallExpression) {
     return testCallerName(callee.callee);
   }
-  if (callee.type === AST_NODE_TYPES7.TaggedTemplateExpression) {
+  if (callee.type === AST_NODE_TYPES6.TaggedTemplateExpression) {
     return testCallerName(callee.tag);
   }
   return null;
 }
 function hasNonTestMember(callee) {
-  if (callee.type === AST_NODE_TYPES7.MemberExpression) {
-    if (!callee.computed && callee.property.type === AST_NODE_TYPES7.Identifier && NON_TEST_MEMBERS.has(callee.property.name)) {
+  if (callee.type === AST_NODE_TYPES6.MemberExpression) {
+    if (!callee.computed && callee.property.type === AST_NODE_TYPES6.Identifier && NON_TEST_MEMBERS.has(callee.property.name)) {
       return true;
     }
     return hasNonTestMember(callee.object);
   }
-  if (callee.type === AST_NODE_TYPES7.CallExpression) {
+  if (callee.type === AST_NODE_TYPES6.CallExpression) {
     return hasNonTestMember(callee.callee);
   }
-  if (callee.type === AST_NODE_TYPES7.TaggedTemplateExpression) {
+  if (callee.type === AST_NODE_TYPES6.TaggedTemplateExpression) {
     return hasNonTestMember(callee.tag);
   }
   return false;
 }
 function isTestBody(fn) {
   const call = fn.parent;
-  if (call?.type !== AST_NODE_TYPES7.CallExpression || !call.arguments.some((argument) => argument === fn)) {
+  if (call?.type !== AST_NODE_TYPES6.CallExpression || !call.arguments.some((argument) => argument === fn)) {
     return false;
   }
   if (hasNonTestMember(call.callee)) {
@@ -1787,22 +1726,22 @@ function subtreeMatches(node, predicate, descendIntoFunctions = true) {
 }
 function rootIdentifier2(node) {
   switch (node.type) {
-    case AST_NODE_TYPES7.Identifier:
+    case AST_NODE_TYPES6.Identifier:
       return node.name;
-    case AST_NODE_TYPES7.MemberExpression:
+    case AST_NODE_TYPES6.MemberExpression:
       return rootIdentifier2(node.object);
-    case AST_NODE_TYPES7.UnaryExpression:
+    case AST_NODE_TYPES6.UnaryExpression:
       return rootIdentifier2(node.argument);
-    case AST_NODE_TYPES7.AwaitExpression:
+    case AST_NODE_TYPES6.AwaitExpression:
       return rootIdentifier2(node.argument);
-    case AST_NODE_TYPES7.ChainExpression:
-    case AST_NODE_TYPES7.TSNonNullExpression:
-    case AST_NODE_TYPES7.TSAsExpression:
+    case AST_NODE_TYPES6.ChainExpression:
+    case AST_NODE_TYPES6.TSNonNullExpression:
+    case AST_NODE_TYPES6.TSAsExpression:
       return rootIdentifier2(node.expression);
-    case AST_NODE_TYPES7.BinaryExpression:
-    case AST_NODE_TYPES7.LogicalExpression:
+    case AST_NODE_TYPES6.BinaryExpression:
+    case AST_NODE_TYPES6.LogicalExpression:
       return rootIdentifier2(node.left);
-    case AST_NODE_TYPES7.CallExpression:
+    case AST_NODE_TYPES6.CallExpression:
       return rootIdentifier2(node.callee);
     default:
       return null;
@@ -1811,26 +1750,26 @@ function rootIdentifier2(node) {
 function calleeRootName(call) {
   let current = call.callee;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES7.Identifier) {
+    if (current.type === AST_NODE_TYPES6.Identifier) {
       return current.name;
     }
-    if (current.type === AST_NODE_TYPES7.MemberExpression) {
+    if (current.type === AST_NODE_TYPES6.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES7.CallExpression) {
+    if (current.type === AST_NODE_TYPES6.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES7.ChainExpression || current.type === AST_NODE_TYPES7.TSNonNullExpression) {
+    if (current.type === AST_NODE_TYPES6.ChainExpression || current.type === AST_NODE_TYPES6.TSNonNullExpression) {
       current = current.expression;
       continue;
     }
     return null;
   }
 }
-var isAssertionCall = (node) => node.type === AST_NODE_TYPES7.CallExpression && ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
-var isTypeAssertionCall = (node) => node.type === AST_NODE_TYPES7.CallExpression && TYPE_ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
+var isAssertionCall = (node) => node.type === AST_NODE_TYPES6.CallExpression && ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
+var isTypeAssertionCall = (node) => node.type === AST_NODE_TYPES6.CallExpression && TYPE_ASSERTION_ROOTS.has(calleeRootName(node) ?? "");
 var containsAssertion = (node) => subtreeMatches(node, isAssertionCall);
 var containsRuntimeAssertion = (node) => subtreeMatches(
   node,
@@ -1838,22 +1777,22 @@ var containsRuntimeAssertion = (node) => subtreeMatches(
 );
 var containsSkipCall = (node) => subtreeMatches(
   node,
-  (current) => current.type === AST_NODE_TYPES7.CallExpression && current.callee.type === AST_NODE_TYPES7.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES7.Identifier && current.callee.property.name === "skip"
+  (current) => current.type === AST_NODE_TYPES6.CallExpression && current.callee.type === AST_NODE_TYPES6.MemberExpression && !current.callee.computed && current.callee.property.type === AST_NODE_TYPES6.Identifier && current.callee.property.name === "skip"
 );
 var containsEscape = (node) => subtreeMatches(
   node,
-  (current) => current.type === AST_NODE_TYPES7.ReturnStatement || current.type === AST_NODE_TYPES7.ContinueStatement || current.type === AST_NODE_TYPES7.BreakStatement || current.type === AST_NODE_TYPES7.ThrowStatement,
+  (current) => current.type === AST_NODE_TYPES6.ReturnStatement || current.type === AST_NODE_TYPES6.ContinueStatement || current.type === AST_NODE_TYPES6.BreakStatement || current.type === AST_NODE_TYPES6.ThrowStatement,
   false
 );
 function branchStatements(branch) {
-  return branch.type === AST_NODE_TYPES7.BlockStatement ? branch.body : [branch];
+  return branch.type === AST_NODE_TYPES6.BlockStatement ? branch.body : [branch];
 }
 function previousSibling(node) {
   const parent = node.parent;
   let siblings = null;
-  if (parent.type === AST_NODE_TYPES7.BlockStatement || parent.type === AST_NODE_TYPES7.Program || parent.type === AST_NODE_TYPES7.StaticBlock) {
+  if (parent.type === AST_NODE_TYPES6.BlockStatement || parent.type === AST_NODE_TYPES6.Program || parent.type === AST_NODE_TYPES6.StaticBlock) {
     siblings = parent.body;
-  } else if (parent.type === AST_NODE_TYPES7.SwitchCase) {
+  } else if (parent.type === AST_NODE_TYPES6.SwitchCase) {
     siblings = parent.consequent;
   }
   if (siblings === null) {
@@ -1868,12 +1807,12 @@ function isPinnedNarrowingGuard(node) {
     return false;
   }
   const previous = previousSibling(node);
-  if (previous === null || previous.type !== AST_NODE_TYPES7.ExpressionStatement) {
+  if (previous === null || previous.type !== AST_NODE_TYPES6.ExpressionStatement) {
     return false;
   }
   let matched = false;
   subtreeMatches(previous, (current) => {
-    if (current.type !== AST_NODE_TYPES7.CallExpression || !ASSERTION_ROOTS.has(calleeRootName(current) ?? "")) {
+    if (current.type !== AST_NODE_TYPES6.CallExpression || !ASSERTION_ROOTS.has(calleeRootName(current) ?? "")) {
       return false;
     }
     const subject = current.arguments[0];
@@ -1893,12 +1832,12 @@ function isThrowingGuard(node) {
     return false;
   }
   const statements = branchStatements(node.consequent);
-  return statements.length === 1 && statements[0]?.type === AST_NODE_TYPES7.ThrowStatement;
+  return statements.length === 1 && statements[0]?.type === AST_NODE_TYPES6.ThrowStatement;
 }
 function isTypeAssertionBranch(branch) {
   const statements = branchStatements(branch);
   return statements.length > 0 && statements.every(
-    (statement) => statement.type === AST_NODE_TYPES7.ExpressionStatement && isTypeAssertionCall(statement.expression)
+    (statement) => statement.type === AST_NODE_TYPES6.ExpressionStatement && isTypeAssertionCall(statement.expression)
   );
 }
 function isTypeLevelNarrowing(node) {
@@ -1906,17 +1845,17 @@ function isTypeLevelNarrowing(node) {
 }
 var isInertBranch = (branch) => !containsAssertion(branch) && !containsEscape(branch) && !containsSkipCall(branch);
 function isNormalizationStatement(statement) {
-  if (statement.type === AST_NODE_TYPES7.VariableDeclaration) {
+  if (statement.type === AST_NODE_TYPES6.VariableDeclaration) {
     return true;
   }
-  if (statement.type === AST_NODE_TYPES7.BlockStatement) {
+  if (statement.type === AST_NODE_TYPES6.BlockStatement) {
     return statement.body.every(isNormalizationStatement);
   }
-  if (statement.type !== AST_NODE_TYPES7.ExpressionStatement) {
+  if (statement.type !== AST_NODE_TYPES6.ExpressionStatement) {
     return false;
   }
   const { expression } = statement;
-  return expression.type === AST_NODE_TYPES7.AssignmentExpression || expression.type === AST_NODE_TYPES7.UpdateExpression || expression.type === AST_NODE_TYPES7.UnaryExpression && expression.operator === "delete";
+  return expression.type === AST_NODE_TYPES6.AssignmentExpression || expression.type === AST_NODE_TYPES6.UpdateExpression || expression.type === AST_NODE_TYPES6.UnaryExpression && expression.operator === "delete";
 }
 function isInertNormalization(node) {
   const branches = [node.consequent, node.alternate].filter(
@@ -1954,7 +1893,7 @@ function conditionalSkipsAssertion(node) {
   return consequent !== alternate;
 }
 function isShortCircuitedAssertion(node) {
-  return node.operator !== "??" && node.parent.type === AST_NODE_TYPES7.ExpressionStatement && containsAssertion(node.right);
+  return node.operator !== "??" && node.parent.type === AST_NODE_TYPES6.ExpressionStatement && containsAssertion(node.right);
 }
 var no_conditional_in_test_default = createRule({
   name: "no-conditional-in-test",
@@ -2005,7 +1944,10 @@ var no_conditional_in_test_default = createRule({
 });
 
 // src/rules/no-cors-wildcard-with-credentials.ts
-import "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES7,
+  ASTUtils as ASTUtils2
+} from "@typescript-eslint/utils";
 var noCorsWildcardWithCredentialsDocumentation = {
   summary: "Disallow wildcard CORS origins when credentials are enabled.",
   rationale: "Reflecting every origin while allowing credentials can let an untrusted site read authenticated cross-origin responses.",
@@ -2192,12 +2134,44 @@ var no_cors_wildcard_with_credentials_default = createRule({
   defaultOptions: [],
   create(context) {
     const scopeHeaderSets = /* @__PURE__ */ new Map();
+    const variableIds = /* @__PURE__ */ new WeakMap();
+    let nextVariableId = 0;
+    function variableId(variable) {
+      const existing = variableIds.get(variable);
+      if (existing !== void 0) return existing;
+      const value = nextVariableId++;
+      variableIds.set(variable, value);
+      return value;
+    }
+    function receiverIdentity(node) {
+      if (node.type === AST_NODE_TYPES7.Identifier) {
+        const variable = ASTUtils2.findVariable(
+          context.sourceCode.getScope(node),
+          node.name
+        );
+        return variable === null ? `global:${node.name}` : `variable:${variableId(variable)}`;
+      }
+      if (node.type === AST_NODE_TYPES7.ThisExpression) return "this";
+      if (node.type === AST_NODE_TYPES7.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES7.Identifier) {
+        const owner = receiverIdentity(node.object);
+        return owner === null ? null : `${owner}.${node.property.name}`;
+      }
+      return null;
+    }
     function recordHeaderSet(node, kind) {
+      if (node.callee.type !== AST_NODE_TYPES7.MemberExpression) return;
+      const receiver = receiverIdentity(node.callee.object);
+      if (receiver === null) return;
       const key = enclosingScope(node) ?? "module";
-      let entry = scopeHeaderSets.get(key);
+      let receivers = scopeHeaderSets.get(key);
+      if (receivers === void 0) {
+        receivers = /* @__PURE__ */ new Map();
+        scopeHeaderSets.set(key, receivers);
+      }
+      let entry = receivers.get(receiver);
       if (entry === void 0) {
         entry = { originNodes: [], credentialsNodes: [] };
-        scopeHeaderSets.set(key, entry);
+        receivers.set(receiver, entry);
       }
       if (kind === "origin") {
         entry.originNodes.push(node);
@@ -2227,13 +2201,15 @@ var no_cors_wildcard_with_credentials_default = createRule({
         }
       },
       "Program:exit"() {
-        for (const { originNodes, credentialsNodes } of scopeHeaderSets.values()) {
-          if (originNodes.length > 0 && credentialsNodes.length > 0) {
-            for (const node of originNodes) {
-              context.report({
-                node,
-                messageId: "corsWildcardWithCredentials"
-              });
+        for (const receivers of scopeHeaderSets.values()) {
+          for (const { originNodes, credentialsNodes } of receivers.values()) {
+            if (originNodes.length > 0 && credentialsNodes.length > 0) {
+              for (const node of originNodes) {
+                context.report({
+                  node,
+                  messageId: "corsWildcardWithCredentials"
+                });
+              }
             }
           }
         }
@@ -3255,7 +3231,7 @@ var noHandRolledSpinnerDocumentation = {
 };
 var DESIGN_SYSTEM_PATH = /(?:^|[/\\])components[/\\]ui[/\\]/u;
 var BORDER_WIDTH = /^border(?:-[0-9]+)?$/u;
-var TRANSPARENT_EDGE = /^border-[trbl]-transparent$/u;
+var CONTRASTING_EDGE = /^border-[trbl]-(?!0$|[0-9]+$).+/u;
 function staticClassName(attribute) {
   const value = attribute.value;
   if (value?.type === AST_NODE_TYPES12.Literal && typeof value.value === "string") {
@@ -3264,6 +3240,9 @@ function staticClassName(attribute) {
   if (value?.type === AST_NODE_TYPES12.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES12.Literal && typeof value.expression.value === "string") {
     return value.expression.value;
   }
+  if (value?.type === AST_NODE_TYPES12.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES12.TemplateLiteral && value.expression.expressions.length === 0) {
+    return value.expression.quasis[0]?.value.cooked ?? null;
+  }
   return null;
 }
 var no_hand_rolled_spinner_default = createRule({
@@ -3296,7 +3275,7 @@ var no_hand_rolled_spinner_default = createRule({
         const className = staticClassName(classNameAttribute);
         if (className === null) return;
         const classes = className.split(/\s+/u);
-        if (classes.includes("animate-spin") && classes.includes("rounded-full") && classes.some((token) => BORDER_WIDTH.test(token)) && classes.some((token) => TRANSPARENT_EDGE.test(token))) {
+        if (classes.includes("animate-spin") && classes.includes("rounded-full") && classes.some((token) => BORDER_WIDTH.test(token)) && classes.some((token) => CONTRASTING_EDGE.test(token))) {
           context.report({ node, messageId: "handRolledSpinner" });
         }
       }
@@ -3318,7 +3297,7 @@ var noInsecureRandomIdDocumentation = {
   ]
 };
 var STRONG_SECURITY_PATTERN = /token|secret|csrf|password|passwd|apikey|api[-_]?key|nonce|salt|uuid|authid/i;
-var NON_SECURITY_ID_PATTERN = /temp|tmp|cache|correlation|request|req|trace|execution|dev|hmr|mock|test|perf|marker/i;
+var NON_SECURITY_ID_PATTERN = /temp|tmp|cache|correlation|request|req|trace|execution|dev|hmr|mock|test|perf|marker|dialog|select|menu|tab|field|input|form|element|dom|aria|component/i;
 var PATH_OR_DOM_MARKER = /[\\/#]|\.[A-Za-z0-9]/;
 function isMathRandomCall(node) {
   if (node.type !== "CallExpression") {
@@ -4005,7 +3984,7 @@ var no_impossible_zod_literal_bounds_default = createRule({
 });
 
 // src/rules/no-log-only-catch.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14, ASTUtils as ASTUtils2 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES14, ASTUtils as ASTUtils3 } from "@typescript-eslint/utils";
 
 // src/rules/_logging.ts
 import "@typescript-eslint/utils";
@@ -4177,7 +4156,7 @@ function seededFallbackHandled(tryStatement, scope) {
   if (previous.declarations.length !== 1 || declarator === void 0) return false;
   if (declarator.id.type !== AST_NODE_TYPES14.Identifier) return false;
   if (declarator.init == null || !isSeedValue(declarator.init)) return false;
-  const variable = ASTUtils2.findVariable(scope, declarator.id.name);
+  const variable = ASTUtils3.findVariable(scope, declarator.id.name);
   if (variable === null) return false;
   const [tryStart, tryEnd] = tryStatement.block.range;
   let writtenInTry = false;
@@ -4391,11 +4370,11 @@ function typedFunction(node) {
 
 // src/rules/no-long-comment.ts
 var noLongCommentDocumentation = {
-  summary: "Flag unusually large unstructured prose blocks in implementation code.",
+  summary: "Flag unusually large unstructured JSDoc blocks in implementation code.",
   rationale: "Large narrative comments become stale and obscure the local facts that belong beside the code.",
   remediation: "Keep only durable local constraints and express the remaining behavior in code.",
   category: "maintainability",
-  limitations: ["Structured API docs, tests, scripts, generated files, and versioned dependencies are excluded."],
+  limitations: ["Only JSDoc blocks are inspected; structured API docs, tests, scripts, generated files, and versioned dependencies are excluded."],
   examples: [
     { id: "local-fact", title: "Keep a concise local fact", outcome: "no-match", files: [{ path: "src/cache.ts", source: "// The cache is process local.\nconst cache = new Map();" }], focusPath: "src/cache.ts", expectedCount: 0, public: true },
     { id: "prose-wall", title: "Avoid an unstructured prose wall", outcome: "match", files: [{ path: "src/chart.ts", source: "/** One. Two. Three. Four. Five. Six. Seven. Eight. */\nconst chart = createChart();" }], focusPath: "src/chart.ts", expectedCount: 1, public: true }
@@ -4423,7 +4402,7 @@ var no_long_comment_default = createRule({
   documentation: noLongCommentDocumentation,
   meta: {
     type: "suggestion",
-    docs: { description: "Flag unusually large unstructured prose blocks in implementation code." },
+    docs: { description: "Flag unusually large unstructured JSDoc blocks in implementation code." },
     schema: [],
     messages: {
       tooLong: "Comment is an unusually large prose block \u2014 keep the local facts and clarify the code itself."
@@ -4445,7 +4424,7 @@ var no_long_comment_default = createRule({
 });
 
 // src/rules/no-generic-single-export-module.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES17, ASTUtils as ASTUtils3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES17, ASTUtils as ASTUtils4 } from "@typescript-eslint/utils";
 var noGenericSingleExportModuleDocumentation = {
   summary: "Disallow generic module stems when one runtime export already names the responsibility.",
   rationale: "A generic filename hides the sole exported responsibility and makes navigation less descriptive.",
@@ -4606,7 +4585,7 @@ function kebabCase(name) {
   return name.replaceAll(/oauth/giu, "Oauth").replaceAll(/graphql/giu, "Graphql").replaceAll(/grpc/giu, "Grpc").replaceAll(/([a-z\d])([A-Z])/gu, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/gu, "$1-$2").replaceAll(/[_\s]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/^-|-$/gu, "").toLowerCase();
 }
 function isGlobalIdentifier(context, node) {
-  const variable = ASTUtils3.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = ASTUtils4.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isConventionalFrameworkUtility(filename, exported) {
@@ -5134,7 +5113,7 @@ var no_raw_env_default = createRule({
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES19 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES19, ASTUtils as ASTUtils5 } from "@typescript-eslint/utils";
 var noRawFetchOutsideClientsDocumentation = {
   summary: "Disallow calling the global `fetch` outside the client layer; route outbound HTTP through a client module that owns retry, timeout and status handling.",
   rationale: "Scattered fetch calls bypass shared transport policy and are harder to stub and observe consistently.",
@@ -5166,19 +5145,75 @@ var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set([
   "self"
 ]);
 var PRESIGNED_URL_NAME_RE = /(?:pre-?signed|signed|upload|download)Url$/i;
-function isGlobalFetchCall(node) {
+var INTERNAL_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH"
+]);
+var ANALYTICS_SEGMENTS2 = /* @__PURE__ */ new Set([
+  "analytics",
+  "telemetry",
+  "track",
+  "log",
+  "ping",
+  "beacon",
+  "metrics",
+  "event"
+]);
+var SERVER_ACTION_SKIP_FILE_RE = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
+var NON_REACT_FRAMEWORK_RE = /^(?:@angular\/|@nestjs\/|vue$|vue\/|svelte$|svelte\/|solid-js$|solid-js\/|@ember\/|rxjs$|rxjs\/)/;
+function isGlobalFetchCall(node, resolvesToGlobal) {
   const callee = node.callee;
   if (callee.type === "Identifier") {
-    return callee.name === "fetch";
+    return callee.name === "fetch" && resolvesToGlobal(callee);
   }
   if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === "fetch" && callee.object.type === "Identifier") {
-    return GLOBAL_RECEIVERS.has(callee.object.name);
+    return GLOBAL_RECEIVERS.has(callee.object.name) && resolvesToGlobal(callee.object);
   }
   return false;
 }
-function isConstructedArgumentHandoff(node) {
+function isConstructedArgumentHandoff(node, resolvesToGlobal) {
   const [first] = node.arguments;
-  return node.arguments.length === 1 && first !== void 0 && first.type === AST_NODE_TYPES19.NewExpression;
+  return node.arguments.length === 1 && first !== void 0 && first.type === AST_NODE_TYPES19.NewExpression && first.callee.type === AST_NODE_TYPES19.Identifier && (first.callee.name === "URL" || first.callee.name === "Request") && resolvesToGlobal(first.callee);
+}
+function effectOwns(node) {
+  if (node.callee.type !== AST_NODE_TYPES19.Identifier) return false;
+  const method = readDirectMethod(node);
+  if (method !== null && method !== "GET") return false;
+  const first = node.arguments[0];
+  let url = "";
+  if (first?.type === AST_NODE_TYPES19.Literal && typeof first.value === "string") {
+    url = first.value;
+  } else if (first?.type === AST_NODE_TYPES19.TemplateLiteral) {
+    url = first.quasis.map((quasi) => quasi.value.cooked).join("");
+  } else if (first?.type === AST_NODE_TYPES19.Identifier) {
+    url = first.name;
+  }
+  if (url !== "" && url.toLowerCase().split(/[/.]/).some((segment) => ANALYTICS_SEGMENTS2.has(segment))) {
+    return false;
+  }
+  for (let current = node.parent; current != null; current = current.parent) {
+    if (current.type !== AST_NODE_TYPES19.CallExpression) continue;
+    const callee = current.callee;
+    const isEffect = callee.type === AST_NODE_TYPES19.Identifier && (callee.name === "useEffect" || callee.name === "useLayoutEffect") || callee.type === AST_NODE_TYPES19.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES19.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES19.Identifier && (callee.property.name === "useEffect" || callee.property.name === "useLayoutEffect");
+    if (!isEffect) continue;
+    const callback = current.arguments[0];
+    return callback !== void 0 && callback.type !== AST_NODE_TYPES19.SpreadElement && node.range[0] >= callback.range[0] && node.range[1] <= callback.range[1];
+  }
+  return false;
+}
+function readDirectMethod(node) {
+  const init = node.arguments[1];
+  if (init?.type !== AST_NODE_TYPES19.ObjectExpression) return null;
+  for (const property of init.properties) {
+    if (property.type !== AST_NODE_TYPES19.Property || property.computed) continue;
+    const key = property.key;
+    const isMethod = key.type === AST_NODE_TYPES19.Identifier && key.name === "method" || key.type === AST_NODE_TYPES19.Literal && key.value === "method";
+    if (!isMethod) continue;
+    return property.value.type === AST_NODE_TYPES19.Literal && typeof property.value.value === "string" ? property.value.value.toUpperCase() : null;
+  }
+  return null;
 }
 function isPresignedUrlTransfer(node) {
   const first = node.arguments[0];
@@ -5240,24 +5275,93 @@ var no_raw_fetch_outside_clients_default = createRule({
     }
     const patterns = options?.allow ?? DEFAULT_ALLOW;
     const allowed = compile(patterns);
+    const nonReactFramework = context.sourceCode.ast.body.some(
+      (statement) => statement.type === AST_NODE_TYPES19.ImportDeclaration && typeof statement.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(statement.source.value)
+    );
+    function resolvesToGlobal(identifier) {
+      const variable = ASTUtils5.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+      return variable === null || variable.defs.length === 0;
+    }
+    function resolveNode2(node) {
+      if (node === void 0) return null;
+      if (node.type !== AST_NODE_TYPES19.Identifier) return node;
+      const variable = ASTUtils5.findVariable(
+        context.sourceCode.getScope(node),
+        node.name
+      );
+      if (variable?.defs.length !== 1) return node;
+      const definition = variable.defs[0];
+      return definition?.type === "Variable" && definition.node.init !== null ? definition.node.init : node;
+    }
+    function propertyValue(node, name) {
+      if (node?.type !== AST_NODE_TYPES19.ObjectExpression) return null;
+      for (const property of node.properties) {
+        if (property.type !== AST_NODE_TYPES19.Property || property.computed) continue;
+        const key = property.key;
+        const keyName = key.type === AST_NODE_TYPES19.Identifier ? key.name : key.type === AST_NODE_TYPES19.Literal && typeof key.value === "string" ? key.value : null;
+        if (keyName !== name) continue;
+        return property.value.type === AST_NODE_TYPES19.AssignmentPattern || property.value.type === AST_NODE_TYPES19.ArrayPattern || property.value.type === AST_NODE_TYPES19.ObjectPattern ? null : property.value;
+      }
+      return null;
+    }
+    function isInternalApiUrl(node) {
+      const resolved = resolveNode2(node ?? void 0);
+      if (resolved?.type === AST_NODE_TYPES19.Literal) {
+        return typeof resolved.value === "string" && resolved.value.startsWith("/api/");
+      }
+      if (resolved?.type === AST_NODE_TYPES19.TemplateLiteral) {
+        return resolved.quasis[0]?.value.cooked?.startsWith("/api/") === true;
+      }
+      return resolved?.type === AST_NODE_TYPES19.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
+    }
+    function isMutationMethod2(node) {
+      const resolved = resolveNode2(node ?? void 0);
+      if (resolved?.type === AST_NODE_TYPES19.Literal) {
+        return typeof resolved.value === "string" && INTERNAL_MUTATION_METHODS.has(resolved.value.toUpperCase());
+      }
+      if (resolved?.type === AST_NODE_TYPES19.TemplateLiteral && resolved.expressions.length === 0) {
+        return INTERNAL_MUTATION_METHODS.has(
+          resolved.quasis.map((quasi) => quasi.value.cooked).join("").toUpperCase()
+        );
+      }
+      if (resolved?.type === AST_NODE_TYPES19.ConditionalExpression) {
+        return isMutationMethod2(resolved.consequent) || isMutationMethod2(resolved.alternate);
+      }
+      return resolved?.type === AST_NODE_TYPES19.LogicalExpression && resolved.operator === "||" && (isMutationMethod2(resolved.left) || isMutationMethod2(resolved.right));
+    }
+    function serverActionOwns(node) {
+      if (node.callee.type !== AST_NODE_TYPES19.Identifier || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+        return false;
+      }
+      const url = node.arguments[0];
+      const init = node.arguments[1];
+      if (url === void 0 || url.type === AST_NODE_TYPES19.SpreadElement || init === void 0 || init.type === AST_NODE_TYPES19.SpreadElement || !isInternalApiUrl(url)) {
+        return false;
+      }
+      return isMutationMethod2(propertyValue(resolveNode2(init), "method"));
+    }
     if (allowed.some((re) => re.test(filename))) {
       return {};
     }
     return {
       CallExpression(node) {
-        if (isPresignedUrlTransfer(node) || isConstructedArgumentHandoff(node)) {
+        if (!isGlobalFetchCall(node, resolvesToGlobal)) {
           return;
         }
-        if (isGlobalFetchCall(node)) {
-          context.report({ node, messageId: "rawFetch" });
+        if (isPresignedUrlTransfer(node) || isConstructedArgumentHandoff(node, resolvesToGlobal) || effectOwns(node) || serverActionOwns(node)) {
+          return;
         }
+        context.report({ node, messageId: "rawFetch" });
       }
     };
   }
 });
 
 // src/rules/no-restricted-library-load.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES20, ASTUtils as ASTUtils4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES20, ASTUtils as ASTUtils6 } from "@typescript-eslint/utils";
 var noRestrictedLibraryLoadDocumentation = {
   summary: "Apply a configured library-replacement policy to literal dynamic imports, CommonJS loads, and TypeScript import-equals declarations.",
   rationale: "Runtime module loads can bypass the replacement policy enforced for static imports.",
@@ -5330,7 +5434,7 @@ var no_restricted_library_load_default = createRule({
       });
     }
     function isUnshadowedRequire(node) {
-      const variable = ASTUtils4.findVariable(
+      const variable = ASTUtils6.findVariable(
         context.sourceCode.getScope(node),
         node.name
       );
@@ -5368,6 +5472,7 @@ 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 URL_PATH_RE = /^\/(?=[^\s]*[A-Za-z0-9])[A-Za-z0-9._~!$&'()*+,;=:@%/?#{}\u005B\u005D-]+$/;
 var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
   AST_NODE_TYPES21.FunctionDeclaration,
   AST_NODE_TYPES21.FunctionExpression,
@@ -5375,7 +5480,7 @@ var FUNCTION_TYPES4 = /* @__PURE__ */ new Set([
 ]);
 var noRepeatedStringLiteralDocumentation = {
   summary: "Disallow a long structured string literal repeated across functions; the copies drift when one is edited. Extract a module-level constant.",
-  rationale: "Independent copies of a structured value can diverge and silently change behavior.",
+  rationale: "Independent copies of a query, route template, or identifier can diverge and silently change behavior.",
   remediation: "Extract the repeated value to one module-level constant and reference it from each function.",
   category: "maintainability",
   limitations: ["Test files, short strings, prose, substitutions, module sources, JSX attributes, and repetition within one function are excluded."],
@@ -5385,7 +5490,7 @@ var noRepeatedStringLiteralDocumentation = {
   ]
 };
 function isStructured(value) {
-  return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value);
+  return value.includes("\n") || SQL_KEYWORD_RE.test(value) || IDENTIFIER_RE.test(value) || URL_PATH_RE.test(value);
 }
 function preview(value) {
   const oneLine = value.replaceAll("\n", " ").trim();
@@ -5404,8 +5509,9 @@ function isScaffolding(node) {
   if (parent === void 0) {
     return true;
   }
+  const isNonComputedPropertyKey = (parent.type === AST_NODE_TYPES21.Property || parent.type === AST_NODE_TYPES21.PropertyDefinition || parent.type === AST_NODE_TYPES21.MethodDefinition || parent.type === AST_NODE_TYPES21.AccessorProperty) && parent.key === node && !parent.computed;
   const isRequireSource = parent.type === AST_NODE_TYPES21.CallExpression && parent.callee.type === AST_NODE_TYPES21.Identifier && parent.callee.name === "require";
-  return parent.type === AST_NODE_TYPES21.ImportDeclaration || parent.type === AST_NODE_TYPES21.ImportExpression || parent.type === AST_NODE_TYPES21.ExportNamedDeclaration || parent.type === AST_NODE_TYPES21.ExportAllDeclaration || parent.type === AST_NODE_TYPES21.TSImportType || parent.type === AST_NODE_TYPES21.JSXAttribute || parent.type === AST_NODE_TYPES21.TSLiteralType || isRequireSource;
+  return parent.type === AST_NODE_TYPES21.ImportDeclaration || parent.type === AST_NODE_TYPES21.ImportExpression || parent.type === AST_NODE_TYPES21.ExportNamedDeclaration || parent.type === AST_NODE_TYPES21.ExportAllDeclaration || parent.type === AST_NODE_TYPES21.TSImportType || parent.type === AST_NODE_TYPES21.JSXAttribute || parent.type === AST_NODE_TYPES21.TSLiteralType || isNonComputedPropertyKey || isRequireSource;
 }
 var no_repeated_string_literal_default = createRule({
   name: "no-repeated-string-literal",
@@ -5422,7 +5528,7 @@ var no_repeated_string_literal_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename)) {
+    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     const occurrences = /* @__PURE__ */ new Map();
@@ -5742,10 +5848,14 @@ 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_RE4.test(description)) continue;
+          const describedText = [
+            description,
+            ...tags.filter((tag) => tag.name === "description").map((tag) => tag.text)
+          ].filter((text) => text.length > 0).join("\n");
+          if (DIRECTIVE_RE4.test(describedText)) continue;
           const tagNames = new Set(tags.map((tag) => tag.name));
           if ([...tagNames].some((name) => !MODELLED_TAGS.has(name))) continue;
-          if (isProtected(description)) continue;
+          if (isProtected(describedText)) continue;
           const token = sourceCode.getTokenAfter(comment, { includeComments: false });
           if (token === null || token.loc.start.line !== comment.loc.end.line + 1) continue;
           let node = sourceCode.getNodeByRangeIndex(token.range[0]);
@@ -5758,13 +5868,14 @@ var no_restated_jsdoc_default = createRule({
           if (declaration === null) continue;
           const paramTags = tags.filter((tag) => PARAM_TAGS.has(tag.name));
           const returnTags = tags.filter((tag) => RETURN_TAGS.has(tag.name));
-          if (description.length === 0 && paramTags.length === 0 && returnTags.length === 0) {
+          if (describedText.length === 0 && paramTags.length === 0 && returnTags.length === 0) {
             continue;
           }
+          if ((paramTags.length > 0 || returnTags.length > 0) && documentsTypedFunction(sourceCode, comment)) continue;
           const nameTokens = tokensOf([declaration.name]);
           const paramTokens = tokensOf(declaration.params);
           const known = /* @__PURE__ */ new Set([...nameTokens, ...paramTokens]);
-          let addsNothing = covered(description, known);
+          let addsNothing = covered(describedText, known);
           for (const tag of paramTags) {
             const text = tag.text.replace(/^\{[^}]*\}\s*/, "");
             const match = /^\[?([A-Za-z_$][\w.$]*)\]?\s*-?\s*([\s\S]*)$/.exec(text);
@@ -5772,7 +5883,13 @@ var no_restated_jsdoc_default = createRule({
               addsNothing = false;
               break;
             }
-            const own = /* @__PURE__ */ new Set([...splitIdentifier(match[1]?.split(".").pop() ?? ""), ...nameTokens]);
+            const path = match[1] ?? "";
+            const root = path.split(".")[0] ?? "";
+            if (!declaration.params.includes(root)) {
+              addsNothing = false;
+              break;
+            }
+            const own = /* @__PURE__ */ new Set([...splitIdentifier(path.split(".").pop() ?? ""), ...nameTokens]);
             if (!covered(match[2] ?? "", own)) {
               addsNothing = false;
               break;
@@ -6597,10 +6714,10 @@ var no_sentinel_return_on_catch_default = createRule({
           return false;
         }
         if (matcher.isLoggingCall(current)) {
-          return true;
+          return caughtName === null || argsIncludeBinding(current.arguments, caughtName);
         }
         const name = calleeName2(current.callee);
-        return name !== null && REPORT_NAME_RE.test(name) && argsIncludeBinding(current.arguments, caughtName);
+        return name !== null && REPORT_NAME_RE.test(name) && (caughtName === null || argsIncludeBinding(current.arguments, caughtName));
       });
     }
     return {
@@ -6661,8 +6778,16 @@ var noSilentPromiseCatchDocumentation = {
     { id: "silent-rejection", title: "Do not swallow the rejection", outcome: "match", files: [{ path: "src/load.ts", source: "load().catch(() => null);" }], focusPath: "src/load.ts", expectedCount: 1, public: true }
   ]
 };
+var BODY_PARSE_METHODS = /* @__PURE__ */ new Set([
+  "arrayBuffer",
+  "blob",
+  "bytes",
+  "formData",
+  "json",
+  "text"
+]);
 function isBodyParseCall(node) {
-  return node.type === AST_NODE_TYPES25.CallExpression && node.arguments.length === 0 && node.callee.type === AST_NODE_TYPES25.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES25.Identifier && (node.callee.property.name === "json" || node.callee.property.name === "text");
+  return node.type === AST_NODE_TYPES25.CallExpression && node.arguments.length === 0 && node.callee.type === AST_NODE_TYPES25.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES25.Identifier && BODY_PARSE_METHODS.has(node.callee.property.name);
 }
 var TEARDOWN_METHODS = /* @__PURE__ */ new Set([
   "cancel",
@@ -8069,7 +8194,7 @@ var no_type_member_comment_wall_default = createRule({
         claimed.add(comment);
         commented += 1;
         const body2 = commentBody(comment);
-        if (body2.length === 0 || carriesValue(body2)) continue;
+        if (body2.length === 0 || carriesValue(body2) || isTagsOnly(body2)) continue;
         if (novelWords(body2, knownTokens(sourceCode.getText(member))) <= options.maxNovelWords) {
           restated += 1;
         }
@@ -8315,7 +8440,7 @@ var no_unnecessary_use_client_default = createRule({
 // src/rules/no-unsafe-mock-casting.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES34,
-  ASTUtils as ASTUtils5
+  ASTUtils as ASTUtils7
 } from "@typescript-eslint/utils";
 var MOCK_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Mock",
@@ -8377,7 +8502,7 @@ var no_unsafe_mock_casting_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils5.findVariable(
+      return ASTUtils7.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -8638,7 +8763,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/test-loops-over-literal-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES36, ASTUtils as ASTUtils6 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES36, ASTUtils as ASTUtils8 } from "@typescript-eslint/utils";
 var testLoopsOverLiteralCasesDocumentation = {
   summary: "Disallow assertions over an inline literal case loop in a test; parameterization reports and names every case independently.",
   rationale: "A loop is reported as one test, so failures hide the individual case name and may stop later cases from running.",
@@ -8801,7 +8926,7 @@ var test_loops_over_literal_cases_default = createRule({
       return {};
     }
     const isFrameworkIdentifier = (identifier, modules) => {
-      const variable = ASTUtils6.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils8.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable === null || variable.defs.length === 0) return true;
       return variable.defs.some((definition) => {
         let current = definition.node;
@@ -9216,7 +9341,7 @@ var prefer_input_group_search_default = createRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES40, ASTUtils as ASTUtils7 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES40, ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
 var preferImmutableModuleConstantDocumentation = {
   summary: "Require module-level constant collections to expose readonly state.",
   rationale: "A const binding prevents reassignment but does not stop callers from mutating its array, object, Set, or Map contents.",
@@ -9369,7 +9494,7 @@ var prefer_immutable_module_constant_default = createRule({
   create(context) {
     const sourceCode = context.sourceCode;
     const isUnshadowedGlobal = (identifier) => {
-      const variable = ASTUtils7.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils9.findVariable(sourceCode.getScope(identifier), identifier.name);
       return variable === null || variable.defs.length === 0;
     };
     if (JAVASCRIPT_FILE_RE.test(context.filename) || isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
@@ -10247,7 +10372,7 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44, ASTUtils as ASTUtils8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES44, ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
 var preferNativeRandomUuidDocumentation = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
@@ -10283,7 +10408,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils8.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils10.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -10346,7 +10471,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES45, ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES45, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
 var preferNonNullableCollectionDocumentation = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -10476,14 +10601,14 @@ function directlyCoalesced(node) {
   return parent?.type === AST_NODE_TYPES45.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = ASTUtils9.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = ASTUtils11.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = ASTUtils9.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = ASTUtils11.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
@@ -11489,7 +11614,7 @@ var preferServerActionsDocumentation = {
 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\/)/;
-var NON_REACT_FRAMEWORK_RE = /^(?:@angular\/|@nestjs\/|vue$|vue\/|svelte$|svelte\/|solid-js$|solid-js\/|@ember\/|rxjs$|rxjs\/)/;
+var NON_REACT_FRAMEWORK_RE2 = /^(?:@angular\/|@nestjs\/|vue$|vue\/|svelte$|svelte\/|solid-js$|solid-js\/|@ember\/|rxjs$|rxjs\/)/;
 function getScope(context, node) {
   return context.sourceCode.getScope(node);
 }
@@ -11601,7 +11726,7 @@ var prefer_server_actions_default = createRule({
       return {};
     }
     const isNonReactFramework = context.sourceCode.ast.body.some(
-      (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && NON_REACT_FRAMEWORK_RE.test(node.source.value)
+      (node) => node.type === "ImportDeclaration" && typeof node.source.value === "string" && NON_REACT_FRAMEWORK_RE2.test(node.source.value)
     );
     return {
       CallExpression(node) {
@@ -12419,7 +12544,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES51, ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES51, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
 var requireFetchTimeoutDocumentation = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -12500,7 +12625,7 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils10.findVariable(scope, identifier.name);
+      const variable = ASTUtils12.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
@@ -13313,7 +13438,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES55, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES55, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
 var stepdownDocumentation = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -13506,7 +13631,7 @@ function methodName(node) {
   return !node.computed && node.key.type === AST_NODE_TYPES55.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES55.Identifier ? ASTUtils11.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES55.Identifier ? ASTUtils13.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
   if (node.object.type !== AST_NODE_TYPES55.ThisExpression && !isClassReference) return null;
   if (node.property.type === AST_NODE_TYPES55.PrivateIdentifier) return `#${node.property.name}`;
@@ -13559,11 +13684,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils11.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils13.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
   if (node.type === AST_NODE_TYPES55.ClassExpression && node.parent.type === AST_NODE_TYPES55.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES55.Identifier) {
-    const outer = ASTUtils11.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    const outer = ASTUtils13.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -13599,7 +13724,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (binding.type !== AST_NODE_TYPES55.Identifier) return;
-      const variable = ASTUtils11.findVariable(context.sourceCode.getScope(binding), binding.name);
+      const variable = ASTUtils13.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -13629,7 +13754,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES55.Identifier ? ASTUtils11.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES55.Identifier ? ASTUtils13.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
@@ -13713,7 +13838,7 @@ var stepdown_default = createRule({
 // src/rules/zod-naming-convention.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES56,
-  ASTUtils as ASTUtils12
+  ASTUtils as ASTUtils14
 } from "@typescript-eslint/utils";
 var zodNamingConventionDocumentation = {
   summary: "Enforce a consistent Zod schema naming convention \u2014 a `Z` prefix (`ZUser`) or a `Schema` suffix (`userSchema`); both are accepted by default.",
@@ -13800,7 +13925,7 @@ var zod_naming_convention_default = createRule({
     const acceptsSchemaWord = convention !== "prefix";
     const zodBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils12.findVariable(
+      return ASTUtils14.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -13851,7 +13976,6 @@ var zod_naming_convention_default = createRule({
 // src/rules/_renames.ts
 var renamedRules = {
   "jsdoc-restates-signature": "no-restated-jsdoc",
-  "no-async-callback-in-waitfor": "no-async-callback-in-wait-for",
   "require-interface-for-injected-service": "require-port-for-service",
   "strict-test-assertions": "prefer-whole-object-assertion",
   "trailing-value-narration": "no-trailing-value-narration"
@@ -13867,6 +13991,14 @@ var retiredRules = {
     removedIn: "5.0.0",
     reason: "Delete the config entry and suppressions; there is no replacement."
   },
+  "no-async-callback-in-wait-for": {
+    removedIn: "14.0.0",
+    reason: "Delete the entry; Testing Library supports async waitFor callbacks and retries when their promises reject."
+  },
+  "no-async-callback-in-waitfor": {
+    removedIn: "14.0.0",
+    reason: "Delete the stale alias; the replacement was also retired because Testing Library supports async waitFor callbacks."
+  },
   "no-sequential-await": {
     removedIn: "3.0.0",
     reason: "Delete the entry; core `no-await-in-loop` covers it."
@@ -13921,7 +14053,6 @@ var retiredRules = {
 var rules = {
   "duplicate-test-body": duplicate_test_body_default,
   "enforce-file-structure": enforce_file_structure_default,
-  "no-async-callback-in-wait-for": no_async_callback_in_wait_for_default,
   "no-client-side-data-fetching": no_client_side_data_fetching_default,
   "no-comment-cruft": no_comment_cruft_default,
   "no-conditional-in-test": no_conditional_in_test_default,
@@ -13987,7 +14118,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "13.0.0"
+  version: "14.0.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",
@@ -13997,7 +14128,6 @@ var applicationOnlyRules = [
 var recommendedRules = {
   "@sarj/duplicate-test-body": "error",
   "@sarj/enforce-file-structure": "error",
-  "@sarj/no-async-callback-in-wait-for": "error",
   "@sarj/no-client-side-data-fetching": "error",
   "@sarj/no-comment-cruft": "error",
   "@sarj/no-conditional-in-test": "error",
@@ -14057,7 +14187,6 @@ var recommendedRules = {
 var strictRules = {
   "@sarj/duplicate-test-body": "error",
   "@sarj/enforce-file-structure": "error",
-  "@sarj/no-async-callback-in-wait-for": "error",
   "@sarj/no-client-side-data-fetching": "error",
   "@sarj/no-comment-cruft": "error",
   "@sarj/no-conditional-in-test": "error",