@sarj/eslint-plugin 15.8.1 → 15.9.0

package/dist/index.js

@@ -4679,11 +4679,11 @@ var no_offset_pagination_default = createRule({
 // src/rules/no-positional-tuple-return.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES18 } from "@typescript-eslint/utils";
 var noPositionalTupleReturnDocumentation = {
-  summary: "Disallow returning a multi-field tuple from an exported function; return a named object so call sites cannot mismatch slots.",
-  rationale: "Public tuple fields are identified only by position, so reordering can preserve types while changing meaning.",
+  summary: "Disallow returning a multi-field tuple from a named function; return a named object so call sites cannot mismatch slots.",
+  rationale: "Tuple fields are identified only by position, so reordering can preserve types while changing meaning.",
   remediation: "Return an object whose property names describe each value.",
   category: "maintainability",
-  limitations: ["Only declared multi-field tuple returns on public TypeScript surfaces are inspected."],
+  limitations: ["Declared or syntax-proven multi-field tuple returns on named functions and public type surfaces are inspected; anonymous inline callbacks and syntax-proven TanStack Query key factories are excluded."],
   examples: [
     { id: "named-object-return", title: "Return named fields", outcome: "no-match", files: [{ path: "src/download.ts", source: "export function download(): { body: string; status: number } { return impl(); }" }], focusPath: "src/download.ts", expectedCount: 0, public: true },
     { id: "tuple-return", title: "Do not expose positional fields", outcome: "match", files: [{ path: "src/download.ts", source: "export function download(): [string, number] { return impl(); }" }], focusPath: "src/download.ts", expectedCount: 1, public: true }
@@ -4721,6 +4721,16 @@ function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
   }
   return null;
 }
+function tupleExpression(node, aliases) {
+  if (node.type !== AST_NODE_TYPES18.TSAsExpression && node.type !== AST_NODE_TYPES18.TSSatisfiesExpression) {
+    return null;
+  }
+  if (node.expression.type !== AST_NODE_TYPES18.ArrayExpression || node.expression.elements.length < MIN_ELEMENTS) {
+    return null;
+  }
+  if (node.type === AST_NODE_TYPES18.TSAsExpression && node.typeAnnotation.type === AST_NODE_TYPES18.TSTypeReference && node.typeAnnotation.typeName.type === AST_NODE_TYPES18.Identifier && node.typeAnnotation.typeName.name === "const") return node.expression;
+  return tupleReturnType(node.typeAnnotation, aliases) === null ? null : node.expression;
+}
 function functionName(node) {
   if (node.type === AST_NODE_TYPES18.FunctionDeclaration) {
     if (node.id !== null) return node.id.name;
@@ -4736,60 +4746,25 @@ function functionName(node) {
     return parent.id.name;
   }
   if ((parent?.type === AST_NODE_TYPES18.MethodDefinition || parent?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || parent?.type === AST_NODE_TYPES18.PropertyDefinition || parent?.type === AST_NODE_TYPES18.Property) && parent.key.type === AST_NODE_TYPES18.Identifier) {
-    if ((parent.type === AST_NODE_TYPES18.MethodDefinition || parent.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || parent.type === AST_NODE_TYPES18.PropertyDefinition) && (parent.accessibility === "private" || parent.accessibility === "protected")) return null;
     return parent.key.name;
   }
   return null;
 }
-function isInlineExported(node) {
-  if (moduleScopeBindingName(node) === null) return false;
-  for (let current = node; current != null; current = current.parent) {
-    const parent = current.parent;
-    if (parent?.type === AST_NODE_TYPES18.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-      return true;
-    }
-  }
-  return false;
-}
-function moduleScopeBindingName(node) {
-  let current = node;
-  while (current.parent != null && current.parent.type !== AST_NODE_TYPES18.Program) {
-    current = current.parent;
-  }
-  if (current.parent?.type !== AST_NODE_TYPES18.Program) {
-    return null;
-  }
-  let topLevel = current;
-  if (current.type === AST_NODE_TYPES18.ExportNamedDeclaration || current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-    topLevel = current.declaration;
-  }
-  if (topLevel === null) return null;
-  if (topLevel.type === AST_NODE_TYPES18.FunctionDeclaration) {
-    if (topLevel !== node) return null;
-    return topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null);
-  }
-  if ((topLevel.type === AST_NODE_TYPES18.ArrowFunctionExpression || topLevel.type === AST_NODE_TYPES18.FunctionExpression) && topLevel === node && current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
-    return "default";
-  }
-  if (topLevel.type === AST_NODE_TYPES18.ClassDeclaration) {
-    let owner = node.parent;
-    while (owner != null && owner.parent !== topLevel.body) owner = owner.parent;
-    return (owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null) : null;
-  }
-  if (topLevel.type === AST_NODE_TYPES18.VariableDeclaration) {
-    for (const declarator of topLevel.declarations) {
-      let initializer = declarator.init;
-      while (initializer?.type === AST_NODE_TYPES18.TSAsExpression || initializer?.type === AST_NODE_TYPES18.TSSatisfiesExpression || initializer?.type === AST_NODE_TYPES18.TSNonNullExpression) initializer = initializer.expression;
-      if (declarator.id.type === AST_NODE_TYPES18.Identifier && initializer === node) return declarator.id.name;
-      if (declarator.id.type === AST_NODE_TYPES18.Identifier && (initializer?.type === AST_NODE_TYPES18.ClassExpression || initializer?.type === AST_NODE_TYPES18.ObjectExpression)) {
-        let owner = node.parent;
-        const container = initializer.type === AST_NODE_TYPES18.ClassExpression ? initializer.body : initializer;
-        while (owner != null && owner.parent !== container) owner = owner.parent;
-        if ((owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition || owner?.type === AST_NODE_TYPES18.Property) && owner.value === node) return declarator.id.name;
-      }
-    }
-  }
-  return null;
+function isQueryKeyFactory(node) {
+  let wrapped = node;
+  while ((wrapped.parent?.type === AST_NODE_TYPES18.TSAsExpression || wrapped.parent?.type === AST_NODE_TYPES18.TSSatisfiesExpression || wrapped.parent?.type === AST_NODE_TYPES18.TSNonNullExpression) && wrapped.parent.expression === wrapped) wrapped = wrapped.parent;
+  const property = wrapped.parent;
+  if (property?.type !== AST_NODE_TYPES18.Property || property.value !== wrapped) return false;
+  const object = property.parent;
+  if (object.type !== AST_NODE_TYPES18.ObjectExpression) return false;
+  const assertion = object.parent;
+  if (assertion.type !== AST_NODE_TYPES18.TSAsExpression || assertion.expression !== object || assertion.typeAnnotation.type !== AST_NODE_TYPES18.TSTypeReference || assertion.typeAnnotation.typeName.type !== AST_NODE_TYPES18.Identifier || assertion.typeAnnotation.typeName.name !== "const") return false;
+  const declarator = assertion.parent;
+  if (declarator.type !== AST_NODE_TYPES18.VariableDeclarator || declarator.id.type !== AST_NODE_TYPES18.Identifier || !/Keys$/i.test(declarator.id.name) || declarator.parent.type !== AST_NODE_TYPES18.VariableDeclaration || declarator.parent.kind !== "const") return false;
+  return object.properties.some((candidate) => {
+    if (candidate.type !== AST_NODE_TYPES18.Property || staticMemberName3(candidate.key) !== "all") return false;
+    return candidate.value.type === AST_NODE_TYPES18.TSAsExpression && candidate.value.expression.type === AST_NODE_TYPES18.ArrayExpression && candidate.value.typeAnnotation.type === AST_NODE_TYPES18.TSTypeReference && candidate.value.typeAnnotation.typeName.type === AST_NODE_TYPES18.Identifier && candidate.value.typeAnnotation.typeName.name === "const";
+  });
 }
 function specifierExportedNames(program) {
   const names = /* @__PURE__ */ new Set();
@@ -4898,18 +4873,52 @@ function isExportedClass(node, specifierExports) {
   if (node.parent.type === AST_NODE_TYPES18.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES18.Identifier) return specifierExports.has(node.parent.id.name) || isInlineExported(node);
   return false;
 }
-function isExportedInterface(node, exports) {
-  return node.parent.type === AST_NODE_TYPES18.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES18.ExportDefaultDeclaration || node.parent.type === AST_NODE_TYPES18.Program && exports.has(node.id.name);
+function isInlineExported(node) {
+  if (moduleScopeBindingName(node) === null) return false;
+  for (let current = node; current != null; current = current.parent) {
+    const parent = current.parent;
+    if (parent?.type === AST_NODE_TYPES18.ExportNamedDeclaration || parent?.type === AST_NODE_TYPES18.ExportDefaultDeclaration) {
+      return true;
+    }
+  }
+  return false;
 }
-function isExported(node, specifierExports) {
-  if (isInlineExported(node)) {
-    return true;
+function moduleScopeBindingName(node) {
+  let current = node;
+  while (current.parent != null && current.parent.type !== AST_NODE_TYPES18.Program) {
+    current = current.parent;
   }
-  if (specifierExports.size === 0) {
-    return false;
+  if (current.parent?.type !== AST_NODE_TYPES18.Program) return null;
+  let topLevel = current;
+  if (current.type === AST_NODE_TYPES18.ExportNamedDeclaration || current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) topLevel = current.declaration;
+  if (topLevel === null) return null;
+  if (topLevel.type === AST_NODE_TYPES18.FunctionDeclaration) {
+    if (topLevel !== node) return null;
+    return topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null);
   }
-  const binding = moduleScopeBindingName(node);
-  return binding !== null && specifierExports.has(binding);
+  if ((topLevel.type === AST_NODE_TYPES18.ArrowFunctionExpression || topLevel.type === AST_NODE_TYPES18.FunctionExpression) && topLevel === node && current.type === AST_NODE_TYPES18.ExportDefaultDeclaration) return "default";
+  if (topLevel.type === AST_NODE_TYPES18.ClassDeclaration) {
+    let owner = node.parent;
+    while (owner != null && owner.parent !== topLevel.body) owner = owner.parent;
+    return (owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.TSAbstractMethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition) && owner.value === node ? topLevel.id?.name ?? (current.type === AST_NODE_TYPES18.ExportDefaultDeclaration ? "default" : null) : null;
+  }
+  if (topLevel.type === AST_NODE_TYPES18.VariableDeclaration) {
+    for (const declarator of topLevel.declarations) {
+      let initializer = declarator.init;
+      while (initializer?.type === AST_NODE_TYPES18.TSAsExpression || initializer?.type === AST_NODE_TYPES18.TSSatisfiesExpression || initializer?.type === AST_NODE_TYPES18.TSNonNullExpression) initializer = initializer.expression;
+      if (declarator.id.type === AST_NODE_TYPES18.Identifier && initializer === node) return declarator.id.name;
+      if (declarator.id.type === AST_NODE_TYPES18.Identifier && (initializer?.type === AST_NODE_TYPES18.ClassExpression || initializer?.type === AST_NODE_TYPES18.ObjectExpression)) {
+        let owner = node.parent;
+        const container = initializer.type === AST_NODE_TYPES18.ClassExpression ? initializer.body : initializer;
+        while (owner != null && owner.parent !== container) owner = owner.parent;
+        if ((owner?.type === AST_NODE_TYPES18.MethodDefinition || owner?.type === AST_NODE_TYPES18.PropertyDefinition || owner?.type === AST_NODE_TYPES18.Property) && owner.value === node) return declarator.id.name;
+      }
+    }
+  }
+  return null;
+}
+function isExportedInterface(node, exports) {
+  return node.parent.type === AST_NODE_TYPES18.ExportNamedDeclaration || node.parent.type === AST_NODE_TYPES18.ExportDefaultDeclaration || node.parent.type === AST_NODE_TYPES18.Program && exports.has(node.id.name);
 }
 var no_positional_tuple_return_default = createRule({
   name: "no-positional-tuple-return",
@@ -4917,11 +4926,11 @@ var no_positional_tuple_return_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow returning a multi-field tuple from an exported function; return a named object so call sites cannot mismatch slots."
+      description: "Disallow returning a multi-field tuple from a named function; return a named object so call sites cannot mismatch slots."
     },
     schema: [],
     messages: {
-      noPositionalTupleReturn: "Exported `{{name}}` returns a {{count}}-field tuple, so consumers depend on positional slots that can be reordered silently. Return a named object instead."
+      noPositionalTupleReturn: "`{{name}}` returns a {{count}}-field tuple, so callers depend on positional slots that can be reordered silently. Return a named object instead."
     }
   },
   defaultOptions: [],
@@ -4933,6 +4942,8 @@ var no_positional_tuple_return_default = createRule({
       exportedTypeNames(context.sourceCode.ast)
     );
     const aliases = typeAliases(context.sourceCode.ast);
+    const reportedFunctions = /* @__PURE__ */ new WeakSet();
+    const functionStack = [];
     const report = (annotation, name) => {
       const tuple = tupleReturnType(annotation, aliases);
       if (tuple === null || tuple.elementTypes.length < MIN_ELEMENTS) return;
@@ -4942,25 +4953,54 @@ var no_positional_tuple_return_default = createRule({
         data: { name, count: String(tuple.elementTypes.length) }
       });
     };
+    const reportExpression = (node, expression) => {
+      if (reportedFunctions.has(node)) return;
+      const tuple = tupleExpression(expression, aliases);
+      const name = functionName(node);
+      if (tuple === null || name === null) return;
+      reportedFunctions.add(node);
+      context.report({
+        node: tuple,
+        messageId: "noPositionalTupleReturn",
+        data: { name, count: String(tuple.elements.length) }
+      });
+    };
     const check = (node) => {
+      if (isQueryKeyFactory(node)) return;
       const annotation = node.returnType?.typeAnnotation;
       if (annotation === void 0) {
+        if (node.type === AST_NODE_TYPES18.ArrowFunctionExpression && node.expression) {
+          reportExpression(node, node.body);
+        }
         return;
       }
       const name = functionName(node);
       if (name === null) {
         return;
       }
-      if (!isExported(node, specifierExports)) {
-        return;
-      }
       report(annotation, name);
     };
+    const enterFunction = (node) => {
+      functionStack.push(node);
+      check(node);
+    };
+    const exitFunction = () => {
+      functionStack.pop();
+    };
     return {
-      FunctionDeclaration: check,
-      FunctionExpression: check,
-      ArrowFunctionExpression: check,
-      TSEmptyBodyFunctionExpression: check,
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      TSEmptyBodyFunctionExpression: enterFunction,
+      "TSEmptyBodyFunctionExpression:exit": exitFunction,
+      ReturnStatement(node) {
+        const owner = functionStack.at(-1);
+        if (owner === void 0 || owner.returnType !== void 0 || node.argument === null) return;
+        reportExpression(owner, node.argument);
+      },
       TSDeclareFunction(node) {
         if (node.id === null || node.returnType === void 0 || node.parent.type !== AST_NODE_TYPES18.ExportNamedDeclaration && node.parent.type !== AST_NODE_TYPES18.ExportDefaultDeclaration && !specifierExports.has(node.id.name)) return;
         report(node.returnType.typeAnnotation, node.id.name);
@@ -5586,6 +5626,38 @@ var no_repeated_string_literal_default = createRule({
 
 // src/rules/no-restated-comment.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES22 } from "@typescript-eslint/utils";
+
+// src/rules/_comment-edits.ts
+import "@typescript-eslint/utils";
+function physicalLineEnd(text, offset) {
+  const newline = text.indexOf("\n", offset);
+  return newline < 0 ? text.length : newline;
+}
+function contentLineEnd(text, offset) {
+  const end = physicalLineEnd(text, offset);
+  return end > offset && text[end - 1] === "\r" ? end - 1 : end;
+}
+function wholeLineRemovalRange(text, comment) {
+  if (comment.loc.start.line !== comment.loc.end.line) return null;
+  const lineStart = text.lastIndexOf("\n", Math.max(0, comment.range[0] - 1)) + 1;
+  if (!/^[\t ]*$/u.test(text.slice(lineStart, comment.range[0]))) return null;
+  const contentEnd = contentLineEnd(text, comment.range[1]);
+  if (!/^[\t ]*$/u.test(text.slice(comment.range[1], contentEnd))) return null;
+  const physicalEnd = physicalLineEnd(text, comment.range[1]);
+  return { range: [lineStart, physicalEnd < text.length ? physicalEnd + 1 : physicalEnd] };
+}
+function trailingCommentRemovalRange(text, comment) {
+  if (comment.loc.start.line !== comment.loc.end.line) return null;
+  const contentEnd = contentLineEnd(text, comment.range[1]);
+  if (!/^[\t ]*$/u.test(text.slice(comment.range[1], contentEnd))) return null;
+  let start = comment.range[0];
+  while (start > 0 && (text[start - 1] === " " || text[start - 1] === "	")) {
+    start -= 1;
+  }
+  return { range: [start, contentEnd] };
+}
+
+// src/rules/no-restated-comment.ts
 var MAX_WORDS = 8;
 var MIN_CONTENT_TOKENS = 2;
 var DIRECTIVE_RE3 = /^(eslint\b|eslint-|sarj-noqa\b|@ts-|prettier-ignore|prettier\b|biome-|c8\b|v8\b|istanbul\b|@type\b|@vite|webpack|<reference|<amd|global\b|noinspection|todo\b|fixme\b|hack\b|xxx\b)/i;
@@ -5605,6 +5677,7 @@ var noRestatedCommentDocumentation = {
   rationale: "A comment that only repeats code adds no context and can become stale independently.",
   remediation: "Delete the comment or replace it with the reason, constraint, or consequence absent from the code.",
   category: "maintainability",
+  autofix: "suggestion",
   limitations: ["Directives, protected references, questions, multi-line prose, comments with novel content, and generated files are excluded."],
   examples: [
     { id: "reason-comment", title: "Keep the reason the code cannot express", outcome: "no-match", files: [{ path: "src/cache.ts", source: "// Serialize because the cache key is stable across deploys.\nconst key = serialize(input);" }], focusPath: "src/cache.ts", expectedCount: 0, public: true },
@@ -5628,11 +5701,13 @@ var no_restated_comment_default = createRule({
   documentation: noRestatedCommentDocumentation,
   meta: {
     type: "suggestion",
+    hasSuggestions: true,
     docs: {
       description: "Flag a single-line comment whose every word already appears on the statement below it."
     },
     schema: [],
     messages: {
+      deleteComment: "Delete the redundant comment.",
       restatesLineBelow: "Comment restates the statement below it \u2014 delete it, or replace it with the *why*; the code already carries the *what*."
     }
   },
@@ -5701,7 +5776,17 @@ var no_restated_comment_default = createRule({
           if (!ACTION_STMT_RE.test(line)) continue;
           if (labelsASiblingRun(comment)) continue;
           if (restates(tokens, codeTokens(line))) {
-            context.report({ node: comment, messageId: "restatesLineBelow" });
+            const removal = wholeLineRemovalRange(sourceCode.text, comment);
+            context.report({
+              node: comment,
+              messageId: "restatesLineBelow",
+              suggest: removal === null ? null : [
+                {
+                  messageId: "deleteComment",
+                  fix: (fixer) => fixer.removeRange(removal.range)
+                }
+              ]
+            });
           }
         }
       }
@@ -7729,6 +7814,7 @@ var noTrailingValueNarrationDocumentation = {
   rationale: "A repeated value can disagree with the expression after either the code or comment changes.",
   remediation: "Put the unit in the identifier and keep comments only when they explain a constraint or non-obvious conversion.",
   category: "maintainability",
+  autofix: "suggestion",
   aliases: ["trailing-value-narration"],
   limitations: ["Only trailing comments with numeric values and recognized unit words are inspected."],
   examples: [
@@ -7845,13 +7931,15 @@ var no_trailing_value_narration_default = createRule({
   documentation: noTrailingValueNarrationDocumentation,
   meta: {
     type: "suggestion",
+    hasSuggestions: true,
     docs: {
       description: "Flag a trailing comment that repeats the line's numeric value only to name its unit."
     },
     schema: [],
     messages: {
       deleteNarration: "Trailing comment restates the literal and the identifier already names its unit \u2014 delete the comment so it cannot drift.",
-      narratesValue: "Trailing comment restates the literal on this line \u2014 put the unit in the name (STALE_TIME_MS) so it cannot drift."
+      narratesValue: "Trailing comment restates the literal on this line \u2014 put the unit in the name (STALE_TIME_MS) so it cannot drift.",
+      removeNarration: "Delete the redundant trailing narration."
     }
   },
   defaultOptions: [],
@@ -7883,9 +7971,17 @@ var no_trailing_value_narration_default = createRule({
           const code = line.slice(0, comment.loc.start.column);
           const body2 = comment.value.replace(/^\*+/, "").replace(/\*+$/, "").trim();
           if (narratesValue(body2, code)) {
+            const canDelete = nameAlreadyCarriesUnit(code);
+            const removal = canDelete ? trailingCommentRemovalRange(sourceCode.text, comment) : null;
             context.report({
               node: comment,
-              messageId: nameAlreadyCarriesUnit(code) ? "deleteNarration" : "narratesValue"
+              messageId: canDelete ? "deleteNarration" : "narratesValue",
+              suggest: removal === null ? null : [
+                {
+                  messageId: "removeNarration",
+                  fix: (fixer) => fixer.removeRange(removal.range)
+                }
+              ]
             });
           }
         }
@@ -11083,6 +11179,7 @@ var prefer_non_nullable_collection_default = createRule({
 
 // src/rules/prefer-await-in-async-return.ts
 import {
+  ASTUtils as ASTUtils14,
   ESLintUtils as ESLintUtils3,
   AST_NODE_TYPES as AST_NODE_TYPES46
 } from "@typescript-eslint/utils";
@@ -11095,7 +11192,8 @@ var preferAwaitInAsyncReturnDocumentation = {
   since: "15.6.3",
   limitations: [
     "Only a single directly returned `.then` call with an inline callback is checked.",
-    "The receiver must be proven Promise-like by TypeScript; untyped files and larger chains are intentionally ignored."
+    "The receiver must be proven Promise-like by TypeScript; untyped files and larger chains are intentionally ignored.",
+    "Direct loader callbacks passed to resolved `React.lazy` and `next/dynamic` imports are excluded because returning the module Promise is their framework contract."
   ],
   examples: [
     {
@@ -11124,19 +11222,19 @@ var preferAwaitInAsyncReturnDocumentation = {
     }
   ]
 };
-function isDirectAsyncReturn(node) {
+function directAsyncReturnOwner(node) {
   const parent = node.parent;
   if (parent.type === AST_NODE_TYPES46.ArrowFunctionExpression && parent.body === node) {
-    return parent.async && !parent.generator;
+    return parent.async && !parent.generator ? parent : null;
   }
   if (parent.type !== AST_NODE_TYPES46.ReturnStatement || parent.argument !== node) {
-    return false;
+    return null;
   }
   let owner = parent.parent;
   while (owner !== void 0 && !isRuntimeFunction(owner)) {
     owner = owner.parent;
   }
-  return owner !== void 0 && owner.async && !owner.generator;
+  return owner !== void 0 && owner.async && !owner.generator ? owner : null;
 }
 function isRuntimeFunction(node) {
   return node.type === AST_NODE_TYPES46.ArrowFunctionExpression || node.type === AST_NODE_TYPES46.FunctionDeclaration || node.type === AST_NODE_TYPES46.FunctionExpression;
@@ -11193,9 +11291,33 @@ var prefer_await_in_async_return_default = createRule({
       services = null;
     }
     if (services === null) return {};
+    const frameworkLoaders = /* @__PURE__ */ new Set();
+    const rememberFrameworkLoader = (identifier) => {
+      const variable = ASTUtils14.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      if (variable !== null) frameworkLoaders.add(variable);
+    };
+    const isFrameworkLoaderCallback = (owner) => {
+      const parent = owner.parent;
+      if (parent.type !== AST_NODE_TYPES46.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES46.Identifier) return false;
+      const variable = ASTUtils14.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      return variable !== null && frameworkLoaders.has(variable);
+    };
     return {
+      ImportDeclaration(node) {
+        if (node.source.value === "react") {
+          for (const specifier of node.specifiers) {
+            if (specifier.type === AST_NODE_TYPES46.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES46.Identifier ? specifier.imported.name : specifier.imported.value) === "lazy") rememberFrameworkLoader(specifier.local);
+          }
+        }
+        if (node.source.value === "next/dynamic") {
+          for (const specifier of node.specifiers) {
+            if (specifier.type === AST_NODE_TYPES46.ImportDefaultSpecifier) rememberFrameworkLoader(specifier.local);
+          }
+        }
+      },
       CallExpression(node) {
-        if (!isDirectAsyncReturn(node)) return;
+        const owner = directAsyncReturnOwner(node);
+        if (owner === null || isFrameworkLoaderCallback(owner)) return;
         const receiver = promiseThenReceiver(node);
         if (receiver === null || !isProvenPromiseLike(receiver, services)) {
           return;
@@ -12404,6 +12526,16 @@ function literalIndex(node) {
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
 }
+function propertyAccess(node) {
+  const path = [];
+  let current = node;
+  while (current.type === AST_NODE_TYPES49.MemberExpression && !current.computed && !current.optional) {
+    if (current.property.type !== AST_NODE_TYPES49.Identifier || COLLECTION_PROPERTIES.has(current.property.name) || LITERAL_KEY_HAZARDS.has(current.property.name)) return null;
+    path.unshift(current.property.name);
+    current = current.object;
+  }
+  return path.length > 0 && isPureReceiver(current) ? { receiver: current, path } : null;
+}
 var prefer_whole_object_assertion_default = createRule({
   name: "prefer-whole-object-assertion",
   documentation: preferWholeObjectAssertionDocumentation,
@@ -12450,21 +12582,23 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       let key;
+      let receiver;
       if (actual.computed) {
         const index = literalIndex(actual.property);
         if (index === null) {
           return null;
         }
         key = { kind: "index", index };
+        receiver = actual.object;
       } else {
-        if (actual.property.type !== AST_NODE_TYPES49.Identifier || COLLECTION_PROPERTIES.has(actual.property.name) || LITERAL_KEY_HAZARDS.has(actual.property.name)) {
-          return null;
-        }
-        key = { kind: "property", name: actual.property.name };
+        const access = propertyAccess(actual);
+        if (access === null) return null;
+        key = { kind: "property", path: access.path };
+        receiver = access.receiver;
       }
       const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
       if (synthetic !== void 0 && call.arguments.length === 0) {
-        return { statement, receiver: actual.object, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
+        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
       }
       if (!MERGEABLE_MATCHERS.has(matcher)) {
         return null;
@@ -12476,7 +12610,7 @@ var prefer_whole_object_assertion_default = createRule({
       const literal = literalText(expected, (node) => sourceCode.getText(node));
       return {
         statement,
-        receiver: actual.object,
+        receiver,
         key,
         matcher,
         expectedText: literal ?? sourceCode.getText(expected),
@@ -12489,7 +12623,8 @@ var prefer_whole_object_assertion_default = createRule({
       );
     }
     function reportPropertyRun(run) {
-      const names = /* @__PURE__ */ new Set();
+      const tree = /* @__PURE__ */ new Map();
+      const paths = [];
       for (const assertion of run) {
         if (assertion.key.kind !== "property" || !assertion.expectedIsLiteral) {
           return;
@@ -12497,19 +12632,44 @@ var prefer_whole_object_assertion_default = createRule({
         if (!MERGEABLE_MATCHERS.has(assertion.matcher) && !SYNTHETIC_LITERAL_MATCHERS.has(assertion.matcher)) {
           return;
         }
-        if (names.has(assertion.key.name)) {
-          return;
+        paths.push([...assertion.key.path]);
+      }
+      const commonPrefix = [];
+      for (let index = 0; ; index += 1) {
+        const candidate = paths[0]?.[index];
+        if (candidate === void 0 || paths.some((path) => path[index] !== candidate || path.length === index + 1)) {
+          break;
+        }
+        commonPrefix.push(candidate);
+      }
+      for (const [assertionIndex, assertion] of run.entries()) {
+        if (assertion.key.kind !== "property") return;
+        let branch = tree;
+        const relativePath = paths[assertionIndex]?.slice(commonPrefix.length) ?? [];
+        for (const [index, name] of relativePath.entries()) {
+          const leaf = index === relativePath.length - 1;
+          const existing = branch.get(name);
+          if (leaf) {
+            if (existing !== void 0) return;
+            branch.set(name, assertion.expectedText);
+          } else if (existing === void 0) {
+            const nested = /* @__PURE__ */ new Map();
+            branch.set(name, nested);
+            branch = nested;
+          } else if (existing instanceof Map) {
+            branch = existing;
+          } else {
+            return;
+          }
         }
-        names.add(assertion.key.name);
       }
       const first = run[0];
       if (first === void 0) {
         return;
       }
-      const receiverText = sourceCode.getText(first.receiver);
-      const properties = run.map(
-        (assertion) => assertion.key.kind === "property" ? `${assertion.key.name}: ${assertion.expectedText}` : ""
-      ).join(", ");
+      const receiverText = `${sourceCode.getText(first.receiver)}${commonPrefix.map((name) => `.${name}`).join("")}`;
+      const renderTree = (value) => [...value.entries()].map(([name, child]) => `${name}: ${child instanceof Map ? `{ ${renderTree(child)} }` : child}`).join(", ");
+      const properties = renderTree(tree);
       context.report({
         node: first.statement,
         messageId: "combineAssertions",
@@ -12585,7 +12745,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50, ASTUtils as ASTUtils14 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES50, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
 var repeatedStaticCallCasesDocumentation = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -12611,7 +12771,7 @@ function staticMemberName5(node) {
   return null;
 }
 function importedName3(identifier, context, modules) {
-  const variable = ASTUtils14.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = ASTUtils15.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
     if (definition.node.type !== AST_NODE_TYPES50.ImportSpecifier) continue;
@@ -13612,7 +13772,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES53, ASTUtils as ASTUtils16 } from "@typescript-eslint/utils";
 var requireFetchTimeoutDocumentation = {
   summary: "Require an abort `signal` (e.g. `AbortSignal.timeout(ms)`) on global `fetch()` calls so stalled upstreams cannot hang the caller forever.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -13693,7 +13853,7 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils15.findVariable(scope, identifier.name);
+      const variable = ASTUtils16.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
@@ -13703,7 +13863,7 @@ var require_fetch_timeout_default = createRule({
       return callee.type === AST_NODE_TYPES53.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES53.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES53.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = ASTUtils15.findVariable(
+      const variable = ASTUtils16.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -14347,7 +14507,7 @@ var require_static_next_matcher_default = createRule({
 // src/rules/require-zod-form-validation.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES56,
-  ASTUtils as ASTUtils16
+  ASTUtils as ASTUtils17
 } from "@typescript-eslint/utils";
 var requireZodFormValidationDocumentation = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
@@ -14415,7 +14575,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => ASTUtils16.findVariable(
+    const resolvedBinding = (identifier) => ASTUtils17.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -14712,7 +14872,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils17 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils18 } from "@typescript-eslint/utils";
 var stepdownDocumentation = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
@@ -14912,7 +15072,7 @@ function methodName(node) {
   return !node.computed && node.key.type === AST_NODE_TYPES57.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils17.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils18.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
   if (node.object.type !== AST_NODE_TYPES57.ThisExpression && !isClassReference) return null;
   if (node.property.type === AST_NODE_TYPES57.PrivateIdentifier) return `#${node.property.name}`;
@@ -14965,11 +15125,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils17.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils18.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
   if (node.type === AST_NODE_TYPES57.ClassExpression && node.parent.type === AST_NODE_TYPES57.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES57.Identifier) {
-    const outer = ASTUtils17.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    const outer = ASTUtils18.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -15005,7 +15165,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (binding.type !== AST_NODE_TYPES57.Identifier) return;
-      const variable = ASTUtils17.findVariable(context.sourceCode.getScope(binding), binding.name);
+      const variable = ASTUtils18.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -15035,7 +15195,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils17.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES57.Identifier ? ASTUtils18.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
@@ -15143,7 +15303,7 @@ var stepdown_default = createRule({
 
 // src/rules/source-coupled-test.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES58 } from "@typescript-eslint/utils";
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|py|[cm]?[jt]s)$/iu;
+var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
 var TEXT_TRANSFORMS = /* @__PURE__ */ new Set([
@@ -15338,6 +15498,13 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         if (receiver.type !== AST_NODE_TYPES58.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
         return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES58.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
+      const rawRegexExtractionOrigins = (node) => {
+        const callee = unwrap5(node.callee);
+        if (callee.type !== AST_NODE_TYPES58.MemberExpression || staticMemberName7(callee) !== "matchAll" || node.arguments.length !== 1) return /* @__PURE__ */ new Set();
+        const argument = node.arguments[0];
+        if (argument?.type !== AST_NODE_TYPES58.Literal || !(argument.value instanceof RegExp)) return /* @__PURE__ */ new Set();
+        return rawOrigins(callee.object);
+      };
       const declare = (name2, state) => {
         const scope = currentScope();
         scope.declared.add(name2);
@@ -15417,7 +15584,10 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (collection && left?.type === AST_NODE_TYPES58.Identifier) declare(left.name, { path: true });
         },
         CallExpression(node) {
-          const origins = rawAssertionOrigins(node);
+          const origins = /* @__PURE__ */ new Set([
+            ...rawAssertionOrigins(node),
+            ...rawRegexExtractionOrigins(node)
+          ]);
           if (origins.size === 0 || [...origins].every((origin) => reportedOrigins.has(origin))) return;
           for (const origin of origins) reportedOrigins.add(origin);
           context.report({ node, messageId: "rawSourceOracle" });
@@ -15473,7 +15643,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 // src/rules/zod-naming-convention.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES59,
-  ASTUtils as ASTUtils18
+  ASTUtils as ASTUtils19
 } from "@typescript-eslint/utils";
 var zodNamingConventionDocumentation = {
   summary: "Enforce a consistent Zod schema naming convention \u2014 a `Z` prefix (`ZUser`) or a `Schema` suffix (`userSchema`); both are accepted by default.",
@@ -15566,7 +15736,7 @@ var zod_naming_convention_default = createRule({
     const acceptsSchemaWord = convention !== "prefix";
     const zodBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils18.findVariable(
+      return ASTUtils19.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -15768,7 +15938,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.8.1"
+  version: "15.9.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",