@sarj/eslint-plugin 11.0.1 → 11.2.0

package/dist/index.cjs

@@ -869,6 +869,7 @@ var BANNER_RUN_RE = /={4,}|-{4,}|#{4,}|\*{4,}|~{4,}|[\u2500-\u257f]{4,}/;
 var REGION_MARKER_RE = /^#?(?:end)?region\b(.*)$/i;
 var REGION_TITLE_RE = /^[\s:\-\u2013\u2014]*\w[\w \-/&+]*$/;
 var REGION_TITLE_MAX_WORDS = 5;
+var REGION_PROSE_VERB_RE = /^(?:is|are|was|were|comes?|defaults?|derives?|inherits?|depends?|uses?|maps?|resolves?)\b/i;
 function stripCommentMarker(line) {
   return line.replace(/^\s*\/{1,2}/, "").replace(/^\s*\*+/, "").trim();
 }
@@ -930,7 +931,9 @@ var CALL_RE = /^[A-Za-z_$][\w.$]*\([^)]*\)\s*;?\s*$/;
 var ASSERTION_CODE_RE = /^(?:await\s+)?(?:expect(?:TypeOf)?|assert(?:\.\w+)?)\s*\(/;
 var HTTP_CONTRACT_RE = /\b(?:GET|HEAD|OPTIONS|PATCH|POST|PUT|DELETE)\s+(?:https?:\/\/|\/|\{[A-Za-z_$])/;
 var PROSE_ASSIGNMENT_RE = /^[A-Za-z_$][\w.$[\]]*\s*=\s*[A-Za-z][A-Za-z '-]{2,}\s+\((?:how|what|when|where|which|who|why)\b[^)]*\)[.!]?$/i;
-var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|…|\.\.\./;
+var PSEUDOCODE_RE = /%\w+%|\[opt\]|(?:^|\s)<[A-Za-z]\w*>|\b[A-Za-z_$][\w$]*\s+x\d+\b|…|\.\.\./;
+var CALL_LABEL_RE = /^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\([^;{}]*\)$/;
+var MULTIPLIER_PSEUDOCODE_RE = /\b[A-Za-z_$][\w$]*\s+x\d+\b/;
 function isBanner(text) {
   const t = text.trim();
   if (!t) return false;
@@ -942,6 +945,7 @@ function isRegionMarker(text) {
   if (match === null) return false;
   const title = (match[1] ?? "").trim();
   if (title.length === 0) return true;
+  if (REGION_PROSE_VERB_RE.test(title)) return false;
   if (!REGION_TITLE_RE.test(title)) return false;
   return title.split(/\s+/).length <= REGION_TITLE_MAX_WORDS;
 }
@@ -957,6 +961,15 @@ function looksLikeCode(text, allowCall = true) {
 function hasPseudocode(text) {
   return PSEUDOCODE_RE.test(text);
 }
+function testCallMatrixStems(comments) {
+  const stems = /* @__PURE__ */ new Set();
+  for (const comment of comments) {
+    const body2 = stripCommentMarker(comment.value);
+    const stem3 = CALL_LABEL_RE.exec(body2)?.[1];
+    if (stem3 !== void 0 && MULTIPLIER_PSEUDOCODE_RE.test(body2)) stems.add(stem3);
+  }
+  return stems;
+}
 function isEnumeratedProseItem(text) {
   const t = text.trim();
   return ENUMERATED_ITEM_RE.test(t) && t.split(/\s+/).length >= ENUMERATED_ITEM_MIN_WORDS;
@@ -1245,6 +1258,7 @@ var no_comment_cruft_default = createRule({
     return {
       Program() {
         const comments = sourceCode.getAllComments();
+        const callMatrixStems = isTestFile(context.filename) ? testCallMatrixStems(comments) : /* @__PURE__ */ new Set();
         const walls = findCommentWalls(comments);
         const wallByLeader = new Map(walls.map((wall) => [wall.leader, wall]));
         const wallMembers = new Set(walls.flatMap((wall) => [...wall.members]));
@@ -1282,6 +1296,8 @@ var no_comment_cruft_default = createRule({
             continue;
           }
           const firstText = texts[0];
+          const firstTextStem = firstText === void 0 ? void 0 : CALL_LABEL_RE.exec(firstText)?.[1];
+          if (firstTextStem !== void 0 && texts.length === 1 && callMatrixStems.has(firstTextStem)) continue;
           if (firstText !== void 0 && /^(?:todo|fixme)\b/i.test(firstText)) {
             if (!runCitesAReference(comments, i)) {
               context.report({
@@ -2211,6 +2227,20 @@ var PURE_METHODS = /* @__PURE__ */ new Set([
   "startsWith",
   "endsWith"
 ]);
+var SYNC_CALLBACK_METHODS = /* @__PURE__ */ new Set([
+  "every",
+  "filter",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "flatMap",
+  "forEach",
+  "map",
+  "reduce",
+  "reduceRight",
+  "some",
+  "sort"
+]);
 var PURE_NAMESPACES = /* @__PURE__ */ new Set([
   "Object",
   "Array",
@@ -2260,7 +2290,17 @@ function isPureCall(node) {
   if (callee.object.type === import_utils13.AST_NODE_TYPES.Identifier && PURE_NAMESPACES.has(callee.object.name)) {
     return !IMPURE_NAMESPACE_METHODS.has(`${callee.object.name}.${property.name}`);
   }
-  return PURE_METHODS.has(property.name);
+  return PURE_METHODS.has(property.name) && (!SYNC_CALLBACK_METHODS.has(property.name) || !synchronousCallbackCanThrow(node));
+}
+function synchronousCallbackCanThrow(node) {
+  return node.arguments.some((argument) => {
+    if (argument.type !== import_utils13.AST_NODE_TYPES.ArrowFunctionExpression && argument.type !== import_utils13.AST_NODE_TYPES.FunctionExpression) return false;
+    if (argument.async) return false;
+    return subtreeMatches2(
+      argument.body,
+      (current) => current.type === import_utils13.AST_NODE_TYPES.ThrowStatement || current.type === import_utils13.AST_NODE_TYPES.CallExpression && current.callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.object.type === import_utils13.AST_NODE_TYPES.Identifier && current.callee.object.name === "JSON" && current.callee.property.type === import_utils13.AST_NODE_TYPES.Identifier && current.callee.property.name === "parse"
+    );
+  });
 }
 function isPureNew(node) {
   return node.callee.type === import_utils13.AST_NODE_TYPES.Identifier && PURE_CONSTRUCTORS.has(node.callee.name);
@@ -2941,6 +2981,16 @@ var PAYLOAD_PROPS = /* @__PURE__ */ new Set([
   "metadata",
   "context"
 ]);
+var BUILTIN_ERROR_CONSTRUCTORS = /* @__PURE__ */ new Set([
+  "AggregateError",
+  "Error",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError"
+]);
 function isCatchBinding(scope, name) {
   let current = scope;
   while (current) {
@@ -3055,6 +3105,48 @@ function nodeWithin(node, container) {
 function isJsonStringify(callee) {
   return callee.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "JSON" && callee.property.type === "Identifier" && callee.property.name === "stringify";
 }
+function directLiteralValues(argument) {
+  if (argument.type === "ObjectExpression") {
+    return argument.properties.flatMap((property) => {
+      if (property.type !== "Property" || property.computed) return [];
+      const value = property.value;
+      if (value.type === "AssignmentPattern" || value.type === "ArrayPattern" || value.type === "ObjectPattern" || value.type === "TSEmptyBodyFunctionExpression") {
+        return [];
+      }
+      return [value];
+    });
+  }
+  if (argument.type === "ArrayExpression") {
+    return argument.elements.flatMap(
+      (element) => element !== null && element.type !== "SpreadElement" ? [element] : []
+    );
+  }
+  return argument.type === "SpreadElement" ? [] : [argument];
+}
+function expressionSuggestsError(expression, scope) {
+  if (expression.type === "Identifier") {
+    return ERROR_NAME_PATTERN.test(expression.name) || isCatchBinding(scope, expression.name);
+  }
+  return expression.type === "MemberExpression" && memberSuggestsError(expression, scope);
+}
+function nestedExpressionSuggestsError(expression, scope) {
+  if (expression.type === "Identifier") {
+    if (isCatchBinding(scope, expression.name)) return true;
+    let current = scope;
+    while (current !== null && !current.set.has(expression.name)) {
+      current = current.upper;
+    }
+    const variable = current?.set.get(expression.name);
+    if (variable === void 0 || variable.defs.length !== 1) return false;
+    const definition = variable.defs[0];
+    if (definition?.type !== "Variable") return false;
+    const initializer = definition.node.init;
+    return initializer?.type === "NewExpression" && initializer.callee.type === "Identifier" && BUILTIN_ERROR_CONSTRUCTORS.has(initializer.callee.name) && variable.references.every(
+      (reference) => !reference.isWrite() || reference.init === true
+    );
+  }
+  return expression.type === "MemberExpression" && memberSuggestsError(expression, scope);
+}
 var no_json_stringify_error_default = createRule({
   name: "no-json-stringify-error",
   meta: {
@@ -3079,18 +3171,11 @@ var no_json_stringify_error_default = createRule({
           return;
         }
         const scope = context.sourceCode.getScope(firstArg);
-        let suggestsError;
-        if (firstArg.type === "Identifier") {
-          suggestsError = ERROR_NAME_PATTERN.test(firstArg.name) || isCatchBinding(scope, firstArg.name);
-        } else if (firstArg.type === "MemberExpression") {
-          suggestsError = memberSuggestsError(firstArg, scope);
-        } else {
-          return;
-        }
-        if (!suggestsError) {
-          return;
-        }
-        if (isGuardedByInstanceofError(node, firstArg, context.sourceCode) || isNarrowedByEarlyReturn(node, firstArg, context.sourceCode)) {
+        const isNestedLiteral = firstArg.type === "ObjectExpression" || firstArg.type === "ArrayExpression";
+        const unsafeValue = directLiteralValues(firstArg).find(
+          (value) => (isNestedLiteral ? nestedExpressionSuggestsError(value, scope) : expressionSuggestsError(value, scope)) && !isGuardedByInstanceofError(node, value, context.sourceCode) && !isNarrowedByEarlyReturn(node, value, context.sourceCode)
+        );
+        if (unsafeValue === void 0) {
           return;
         }
         context.report({
@@ -3477,6 +3562,8 @@ function typedFunction(node) {
 
 // src/rules/no-long-comment.ts
 var EXCESSIVE_SENTENCE_COUNT = 8;
+var EXCESSIVE_WORD_COUNT = 120;
+var PROSE_WORD_RE = /[\p{L}\p{N}][\p{L}\p{N}'’-]*/gu;
 var VERSIONED_DEPENDENCY_TREE_RE = /(?:^|\/)lib\/[^/]*-?v?\d+\.\d+(?:\.\d+)?[^/]*\//iu;
 function documentsTypeOrMember(sourceCode, comment) {
   const token = sourceCode.getTokenAfter(comment, { includeComments: false });
@@ -3488,6 +3575,9 @@ function documentsTypeOrMember(sourceCode, comment) {
   }
   return false;
 }
+function wordUnits(text) {
+  return text.match(PROSE_WORD_RE)?.length ?? 0;
+}
 var no_long_comment_default = createRule({
   name: "no-long-comment",
   meta: {
@@ -3505,7 +3595,7 @@ var no_long_comment_default = createRule({
     return {
       Program() {
         for (const group of proseGroups(context.filename, context.sourceCode)) {
-          if (group.comment.type !== "Block" || !group.comment.value.startsWith("*") || group.hasTypedTags || hasDocumentationStructure(group.text) || hasTechnicalAnchor(group.text) || documentsTypedFunction(context.sourceCode, group.comment) || documentsTypeOrMember(context.sourceCode, group.comment) || sentenceUnits(group.text) < EXCESSIVE_SENTENCE_COUNT) continue;
+          if (group.comment.type !== "Block" || !group.comment.value.startsWith("*") || group.hasTypedTags || hasDocumentationStructure(group.text) || hasTechnicalAnchor(group.text) || documentsTypedFunction(context.sourceCode, group.comment) || documentsTypeOrMember(context.sourceCode, group.comment) || sentenceUnits(group.text) < EXCESSIVE_SENTENCE_COUNT && wordUnits(group.text) < EXCESSIVE_WORD_COUNT) continue;
           context.report({ node: group.comment, messageId: "tooLong" });
         }
       }
@@ -5160,50 +5250,59 @@ var no_select_star_default = createRule({
 
 // src/rules/no-sentinel-return-on-catch.ts
 var import_utils33 = require("@typescript-eslint/utils");
+function unwrapSentinelExpression(arg) {
+  let current = arg;
+  while (current?.type === import_utils33.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils33.AST_NODE_TYPES.TSTypeAssertion || current?.type === import_utils33.AST_NODE_TYPES.TSSatisfiesExpression) {
+    current = current.expression;
+  }
+  return current;
+}
 function sentinelKind(arg) {
-  if (arg === null) {
+  const value = unwrapSentinelExpression(arg);
+  if (value === null) {
     return null;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.Literal) {
-    if (arg.value === null) {
+  if (value.type === import_utils33.AST_NODE_TYPES.Literal) {
+    if (value.value === null) {
       return "nullish";
     }
-    if (typeof arg.value === "boolean") {
+    if (typeof value.value === "boolean") {
       return "boolean";
     }
-    if (typeof arg.value === "string") {
+    if (typeof value.value === "string") {
       return "string";
     }
     return null;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (value.type === import_utils33.AST_NODE_TYPES.Identifier && value.name === "undefined") {
     return "nullish";
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.ArrayExpression) {
+  if (value.type === import_utils33.AST_NODE_TYPES.ArrayExpression) {
     return "array";
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.ObjectExpression) {
+  if (value.type === import_utils33.AST_NODE_TYPES.ObjectExpression) {
     return "object";
   }
   return null;
 }
 function isSentinelArgument(arg) {
-  if (arg === null) {
+  const value = unwrapSentinelExpression(arg);
+  if (value === null) {
     return false;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.Literal && arg.value === null) {
+  if (value.type === import_utils33.AST_NODE_TYPES.Literal && value.value === null) {
     return true;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.Literal && arg.value === false) {
+  if (value.type === import_utils33.AST_NODE_TYPES.Literal && value.value === false) {
     return true;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.Identifier && arg.name === "undefined") {
+  if (value.type === import_utils33.AST_NODE_TYPES.Identifier && value.name === "undefined") {
     return true;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.ArrayExpression && arg.elements.length === 0) {
+  if (value.type === import_utils33.AST_NODE_TYPES.ArrayExpression && value.elements.length === 0) {
     return true;
   }
-  if (arg.type === import_utils33.AST_NODE_TYPES.ObjectExpression && arg.properties.length === 0) {
+  if (value.type === import_utils33.AST_NODE_TYPES.ObjectExpression && value.properties.length === 0) {
     return true;
   }
   return false;
@@ -5401,6 +5500,16 @@ function tryReturnsSafeParse(catchNode) {
   const only = tryBlock.body.length === 1 ? tryBlock.body[0] : void 0;
   return only !== void 0 && returnsMatching(only, isBodyDecodeNode);
 }
+function isIntentionalStackCapture(catchNode, caughtName) {
+  if (caughtName === null) return false;
+  const tryBody = tryBlockOf(catchNode).body;
+  const only = tryBody.length === 1 ? tryBody[0] : void 0;
+  if (only?.type !== import_utils33.AST_NODE_TYPES.ThrowStatement) return false;
+  const thrown = unwrapSentinelExpression(only.argument);
+  const constructsError = (thrown?.type === import_utils33.AST_NODE_TYPES.CallExpression || thrown?.type === import_utils33.AST_NODE_TYPES.NewExpression) && thrown.callee.type === import_utils33.AST_NODE_TYPES.Identifier && thrown.callee.name === "Error";
+  if (!constructsError) return false;
+  return catchNode.body.body.slice(0, -1).some((statement) => subtreeReadsName(statement, caughtName));
+}
 function tryBlockOf(catchNode) {
   return catchNode.parent.block;
 }
@@ -5521,6 +5630,9 @@ var no_sentinel_return_on_catch_default = createRule({
         if (tryReturnsSafeParse(node)) {
           return;
         }
+        if (isIntentionalStackCapture(node, caughtName)) {
+          return;
+        }
         const kind = sentinelKind(last.argument);
         if (kind !== null && isNamedBooleanPredicate(node, kind)) {
           return;
@@ -5599,11 +5711,11 @@ var no_silent_promise_catch_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow `.catch()` handlers that silently swallow the rejection (e.g. `.catch(() => null)`); log, rethrow, or handle the error."
+      description: "Disallow `.catch()` and second-argument `.then()` handlers that silently swallow a rejection; log, rethrow, or handle the error."
     },
     schema: [],
     messages: {
-      silentCatch: "This `.catch()` swallows the rejection without logging, rethrowing, or handling it \u2014 failures become invisible and callers get an indistinguishable sentinel. Log the error (and only then map to a fallback), or let it propagate."
+      silentCatch: "This rejection handler swallows the error without logging, rethrowing, or handling it \u2014 failures become invisible and callers get an indistinguishable sentinel. Log the error (and only then map to a fallback), or let it propagate."
     }
   },
   defaultOptions: [],
@@ -5629,9 +5741,12 @@ var no_silent_promise_catch_default = createRule({
     };
     return {
       CallExpression(node) {
-        if (node.callee.type !== import_utils34.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils34.AST_NODE_TYPES.Identifier || node.callee.property.name !== "catch") {
+        if (node.callee.type !== import_utils34.AST_NODE_TYPES.MemberExpression || node.callee.computed || node.callee.property.type !== import_utils34.AST_NODE_TYPES.Identifier) {
           return;
         }
+        const method = node.callee.property.name;
+        const handlerIndex = method === "catch" ? 0 : method === "then" ? 1 : null;
+        if (handlerIndex === null) return;
         if (isBodyParseCall(node.callee.object)) {
           return;
         }
@@ -5641,10 +5756,11 @@ var no_silent_promise_catch_default = createRule({
         if (node.parent.type === import_utils34.AST_NODE_TYPES.MemberExpression && node.parent.object === node) {
           return;
         }
-        if (node.arguments.length !== 1) {
+        const expectedArguments = method === "catch" ? 1 : 2;
+        if (node.arguments.length !== expectedArguments) {
           return;
         }
-        const handler = node.arguments[0];
+        const handler = node.arguments[handlerIndex];
         if (handler === void 0 || handler.type !== import_utils34.AST_NODE_TYPES.ArrowFunctionExpression && handler.type !== import_utils34.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
@@ -5907,6 +6023,11 @@ function isStringLiteralInit(node) {
   return false;
 }
 function isConcatOntoTarget(rhs, target) {
+  if (rhs.type === "TemplateLiteral") {
+    return rhs.expressions.some(
+      (expression) => expression.type === "Identifier" && expression.name === target
+    );
+  }
   if (rhs.type !== "BinaryExpression" || rhs.operator !== "+") {
     return false;
   }
@@ -7459,6 +7580,15 @@ var SUCCESS_PAYLOAD_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "value"
 ]);
 var REQUIRED_STATUS_MEMBER_COUNT = 1;
+var FUNCTION_RETURN_OWNER_TYPES = /* @__PURE__ */ new Set([
+  import_utils51.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils51.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils51.AST_NODE_TYPES.FunctionExpression,
+  import_utils51.AST_NODE_TYPES.TSDeclareFunction,
+  import_utils51.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+  import_utils51.AST_NODE_TYPES.TSFunctionType,
+  import_utils51.AST_NODE_TYPES.TSMethodSignature
+]);
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let statusMemberCount = 0;
   let hasFailurePayload = false;
@@ -7499,6 +7629,17 @@ function getMemberName(member) {
 function isBooleanTyped(member) {
   return member.typeAnnotation?.typeAnnotation.type === import_utils51.AST_NODE_TYPES.TSBooleanKeyword;
 }
+function inlineReturnTypeLiteral(node) {
+  let annotation = null;
+  if (node.parent.type === import_utils51.AST_NODE_TYPES.TSTypeAnnotation) {
+    annotation = node.parent;
+  } else if (node.parent.type === import_utils51.AST_NODE_TYPES.TSTypeParameterInstantiation && node.parent.params.length === 1 && node.parent.params[0] === node && node.parent.parent.type === import_utils51.AST_NODE_TYPES.TSTypeReference && node.parent.parent.typeName.type === import_utils51.AST_NODE_TYPES.Identifier && node.parent.parent.typeName.name === "Promise" && node.parent.parent.parent.type === import_utils51.AST_NODE_TYPES.TSTypeAnnotation) {
+    annotation = node.parent.parent.parent;
+  }
+  if (annotation === null) return null;
+  const owner = annotation.parent;
+  return FUNCTION_RETURN_OWNER_TYPES.has(owner.type) && "returnType" in owner && owner.returnType === annotation ? annotation : null;
+}
 var prefer_discriminated_union_default = createRule({
   name: "prefer-discriminated-union",
   meta: {
@@ -7538,6 +7679,10 @@ var prefer_discriminated_union_default = createRule({
       },
       "TSTypeAliasDeclaration > TSTypeLiteral"(node) {
         checkTypeLiteral(node, node.parent);
+      },
+      TSTypeLiteral(node) {
+        const annotation = inlineReturnTypeLiteral(node);
+        if (annotation !== null) checkTypeLiteral(node, annotation);
       }
     };
   }
@@ -8454,6 +8599,11 @@ var prefer_module_level_schema_default = createRule({
             type: "boolean",
             description: "Skip test files, where a fixture schema belongs next to its assertion."
           },
+          memoCallees: {
+            type: "array",
+            items: { type: "string" },
+            description: "Wrappers that construct their callback at most once. Defaults to lazy, memo, once, and useMemo."
+          },
           minProperties: {
             type: "number",
             minimum: 0,
@@ -8471,6 +8621,7 @@ var prefer_module_level_schema_default = createRule({
   create(context, [options]) {
     const factories = new Set(options?.factories ?? DEFAULT_FACTORIES);
     const ignoreTestFiles = options?.ignoreTestFiles ?? true;
+    const memoCallees = new Set(options?.memoCallees ?? MEMO_CALLEES);
     const minProperties = options?.minProperties ?? DEFAULT_MIN_PROPERTIES;
     const sourceCode = context.sourceCode;
     const filename = context.filename;
@@ -8490,7 +8641,7 @@ var prefer_module_level_schema_default = createRule({
         if (current !== node && isZodCall(current) && current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === import_utils56.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils56.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === import_utils56.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils56.AST_NODE_TYPES.Identifier && memoCallees.has(current.callee.name) || current.callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && memoCallees.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -8540,6 +8691,9 @@ var prefer_module_level_schema_default = createRule({
           if (definition.type === "ImportBinding") {
             continue;
           }
+          if (definition.node.type === import_utils56.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils56.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const") {
+            return false;
+          }
           const [defStart, defEnd] = definition.node.range;
           if (defStart >= schemaStart && defEnd <= schemaEnd) {
             continue;
@@ -8774,7 +8928,7 @@ function sameAccess(node, access) {
   return node.type === import_utils58.AST_NODE_TYPES.MemberExpression && !node.computed && node.object.type === import_utils58.AST_NODE_TYPES.Identifier && node.object.name === access.object && node.property.type === import_utils58.AST_NODE_TYPES.Identifier && node.property.name === access.property;
 }
 function isNullGuard(node, access) {
-  if (node.type === import_utils58.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && sameAccess(node.argument, access)) return true;
+  if (node.type === import_utils58.AST_NODE_TYPES.UnaryExpression && node.operator === "!" && (sameAccess(node.argument, access) || optionalMemberLengthOf(node.argument, access))) return true;
   if (node.type !== import_utils58.AST_NODE_TYPES.BinaryExpression || !["==", "==="].includes(node.operator)) {
     return false;
   }
@@ -8790,7 +8944,11 @@ function isEmptyGuard(node, access) {
   return memberLengthOf(node.left, access) && zero(node.right) || memberLengthOf(node.right, access) && zero(node.left);
 }
 function memberLengthOf(node, access) {
-  return node.type === import_utils58.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils58.AST_NODE_TYPES.Identifier && node.property.name === "length" && sameAccess(node.object, access);
+  const target = node.type === import_utils58.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+  return target.type === import_utils58.AST_NODE_TYPES.MemberExpression && !target.computed && target.property.type === import_utils58.AST_NODE_TYPES.Identifier && target.property.name === "length" && sameAccess(target.object, access);
+}
+function optionalMemberLengthOf(node, access) {
+  return node.type === import_utils58.AST_NODE_TYPES.ChainExpression && node.expression.type === import_utils58.AST_NODE_TYPES.MemberExpression && node.expression.optional && memberLengthOf(node, access);
 }
 function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
   if (fn.body.type !== import_utils58.AST_NODE_TYPES.BlockStatement) return false;
@@ -8798,6 +8956,7 @@ function hasEquivalentLeadingGuard(fn, access, visitorKeys) {
   if (first?.type !== import_utils58.AST_NODE_TYPES.IfStatement) return false;
   const terminating = first.consequent.type === import_utils58.AST_NODE_TYPES.ReturnStatement || first.consequent.type === import_utils58.AST_NODE_TYPES.ThrowStatement || first.consequent.type === import_utils58.AST_NODE_TYPES.BlockStatement && first.consequent.body.length === 1 && (first.consequent.body[0]?.type === import_utils58.AST_NODE_TYPES.ReturnStatement || first.consequent.body[0]?.type === import_utils58.AST_NODE_TYPES.ThrowStatement);
   if (!terminating) return false;
+  if (contains(first.consequent, visitorKeys, (node) => sameAccess(node, access))) return false;
   return contains(first.test, visitorKeys, (node) => isNullGuard(node, access)) && contains(first.test, visitorKeys, (node) => isEmptyGuard(node, access));
 }
 function contains(node, visitorKeys, predicate) {
@@ -8960,7 +9119,7 @@ var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
   return inner !== null && inner.type === import_utils59.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils59.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
-var isRawPayloadSource = (node) => {
+var isRawPayloadSource = (node, isKnownLocalText) => {
   let current = unwrap4(node);
   if (current === null) return false;
   if (current.type === import_utils59.AST_NODE_TYPES.AwaitExpression) {
@@ -8984,20 +9143,26 @@ var isRawPayloadSource = (node) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils59.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]);
+  return property.name === "parse" && object !== null && object.type === import_utils59.AST_NODE_TYPES.Identifier && object.name === "JSON" && !isLocalFileRead(current.arguments[0]) && isKnownLocalText?.(current.arguments[0]) !== true;
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
+var isDirectLocalFileRead = (node) => {
+  let current = unwrap4(node);
+  if (current?.type === import_utils59.AST_NODE_TYPES.AwaitExpression) {
+    current = unwrap4(current.argument);
+  }
+  if (current?.type !== import_utils59.AST_NODE_TYPES.CallExpression) return false;
+  const callee = unwrap4(current.callee);
+  const name = callee?.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils59.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+  return name !== null && FILE_READ_RE.test(name);
+};
 var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils59.AST_NODE_TYPES.CallExpression) {
-      const callee = unwrap4(current.callee);
-      const name = callee?.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils59.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-      if (name !== null && FILE_READ_RE.test(name)) {
-        found = true;
-        return;
-      }
+    if (isDirectLocalFileRead(current)) {
+      found = true;
+      return;
     }
     for (const key of Object.keys(current)) {
       if (key === "parent") continue;
@@ -9059,6 +9224,87 @@ var isValidationRead = (node) => {
   }
   return callee.type === import_utils59.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
+var PRIMITIVE_TYPEOF_RESULTS = /* @__PURE__ */ new Set([
+  "bigint",
+  "boolean",
+  "number",
+  "string",
+  "symbol",
+  "undefined"
+]);
+var bindingValidationPolarity = (test, bindingName) => {
+  if (test.type === import_utils59.AST_NODE_TYPES.UnaryExpression && test.operator === "!") {
+    const inner = bindingValidationPolarity(test.argument, bindingName);
+    return inner === "valid-when-true" ? "valid-when-false" : inner === "valid-when-false" ? "valid-when-true" : null;
+  }
+  if (test.type === import_utils59.AST_NODE_TYPES.BinaryExpression) {
+    const typeofName = (node) => node.type === import_utils59.AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === import_utils59.AST_NODE_TYPES.Identifier ? node.argument.name : null;
+    const literalType = (node) => node.type === import_utils59.AST_NODE_TYPES.Literal && typeof node.value === "string" && PRIMITIVE_TYPEOF_RESULTS.has(node.value) ? node.value : null;
+    const matches = typeofName(test.left) === bindingName && literalType(test.right) !== null || typeofName(test.right) === bindingName && literalType(test.left) !== null;
+    if (!matches) return null;
+    if (test.operator === "===" || test.operator === "==") {
+      return "valid-when-true";
+    }
+    return test.operator === "!==" || test.operator === "!=" ? "valid-when-false" : null;
+  }
+  return test.type === import_utils59.AST_NODE_TYPES.CallExpression && test.arguments.length === 1 && test.arguments[0]?.type === import_utils59.AST_NODE_TYPES.Identifier && test.arguments[0].name === bindingName && test.callee.type === import_utils59.AST_NODE_TYPES.MemberExpression && !test.callee.computed && test.callee.object.type === import_utils59.AST_NODE_TYPES.Identifier && test.callee.object.name === "Array" && test.callee.property.type === import_utils59.AST_NODE_TYPES.Identifier && test.callee.property.name === "isArray" ? "valid-when-true" : null;
+};
+var nodeWithin2 = (node, container) => node.range[0] >= container.range[0] && node.range[1] <= container.range[1];
+var isFullyValidatedExtractedBinding = (member, source, context) => {
+  const isValidationReference = (identifier) => {
+    for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
+      if ((current.type === import_utils59.AST_NODE_TYPES.BinaryExpression || current.type === import_utils59.AST_NODE_TYPES.CallExpression || current.type === import_utils59.AST_NODE_TYPES.UnaryExpression) && bindingValidationPolarity(current, identifier.name) !== null) {
+        return true;
+      }
+      if (current.type !== import_utils59.AST_NODE_TYPES.UnaryExpression && current.type !== import_utils59.AST_NODE_TYPES.MemberExpression && current.type !== import_utils59.AST_NODE_TYPES.CallExpression) {
+        return false;
+      }
+    }
+    return false;
+  };
+  const isGuardedUse = (identifier) => {
+    for (let current = identifier.parent; current !== void 0 && current !== null; current = current.parent) {
+      if (current.type === import_utils59.AST_NODE_TYPES.ConditionalExpression) {
+        const polarity = bindingValidationPolarity(current.test, identifier.name);
+        if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
+          return true;
+        }
+        if (polarity === "valid-when-false" && nodeWithin2(identifier, current.alternate)) {
+          return true;
+        }
+      }
+      if (current.type === import_utils59.AST_NODE_TYPES.IfStatement) {
+        const polarity = bindingValidationPolarity(current.test, identifier.name);
+        if (polarity === "valid-when-true" && nodeWithin2(identifier, current.consequent)) {
+          return true;
+        }
+        if (polarity === "valid-when-false" && current.alternate !== null && nodeWithin2(identifier, current.alternate)) {
+          return true;
+        }
+      }
+      if (current.type === import_utils59.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils59.AST_NODE_TYPES.FunctionExpression || current.type === import_utils59.AST_NODE_TYPES.ArrowFunctionExpression) {
+        return false;
+      }
+    }
+    return false;
+  };
+  const declarator = member.parent;
+  if (declarator.type !== import_utils59.AST_NODE_TYPES.VariableDeclarator || declarator.init !== member || declarator.id.type !== import_utils59.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils59.AST_NODE_TYPES.VariableDeclaration || declarator.parent.kind !== "const") {
+    return false;
+  }
+  const extracted = context.sourceCode.getDeclaredVariables(declarator)[0];
+  if (extracted === void 0 || extracted.scope !== source.scope) return false;
+  let hasValueUse = false;
+  for (const reference of extracted.references) {
+    const identifier = reference.identifier;
+    if (identifier.type !== import_utils59.AST_NODE_TYPES.Identifier) return false;
+    if (nodeWithin2(identifier, declarator)) continue;
+    if (isValidationReference(identifier)) continue;
+    hasValueUse = true;
+    if (!isGuardedUse(identifier)) return false;
+  }
+  return hasValueUse;
+};
 var isGuardTestPosition = (node) => {
   let current = node;
   let parent = current.parent;
@@ -9082,13 +9328,13 @@ var isGuardTestPosition = (node) => {
   }
   return false;
 };
-var isUnvalidatedVariableRef = (node, scope, tracked) => {
+var unvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
   if (unwrapped === null || unwrapped.type !== import_utils59.AST_NODE_TYPES.Identifier) {
-    return false;
+    return null;
   }
   const variable = findVariable2(scope, unwrapped.name);
-  return variable !== null && tracked.has(variable);
+  return variable !== null && tracked.has(variable) ? variable : null;
 };
 var prefer_schema_for_api_payload_default = createRule({
   name: "prefer-schema-for-api-payload",
@@ -9108,6 +9354,56 @@ var prefer_schema_for_api_payload_default = createRule({
       return {};
     }
     const unvalidatedVariables = /* @__PURE__ */ new Set();
+    const aliasGroups = /* @__PURE__ */ new Map();
+    const localFileTextVariables = /* @__PURE__ */ new Set();
+    const localFileTextRef = (node, scope) => {
+      const unwrapped = unwrap4(node);
+      if (unwrapped?.type !== import_utils59.AST_NODE_TYPES.Identifier) return null;
+      const variable = findVariable2(scope, unwrapped.name);
+      return variable !== null && localFileTextVariables.has(variable) ? variable : null;
+    };
+    const updateLocalFileText = (target, value, scope) => {
+      const source = localFileTextRef(value, scope);
+      if (isDirectLocalFileRead(value) || source !== null && source.scope === target.scope) {
+        localFileTextVariables.add(target);
+      } else {
+        localFileTextVariables.delete(target);
+      }
+    };
+    const clearBinding = (variable) => {
+      unvalidatedVariables.delete(variable);
+      const group = aliasGroups.get(variable);
+      aliasGroups.delete(variable);
+      group?.delete(variable);
+    };
+    const clearAliasGroup = (variable) => {
+      const group = aliasGroups.get(variable);
+      if (group === void 0) {
+        unvalidatedVariables.delete(variable);
+        return;
+      }
+      for (const alias of group) {
+        unvalidatedVariables.delete(alias);
+        aliasGroups.delete(alias);
+      }
+      group.clear();
+    };
+    const trackRawBinding = (variable) => {
+      clearBinding(variable);
+      const group = /* @__PURE__ */ new Set([variable]);
+      unvalidatedVariables.add(variable);
+      aliasGroups.set(variable, group);
+    };
+    const trackAlias = (target, source) => {
+      if (target === source) return;
+      const group = aliasGroups.get(source) ?? /* @__PURE__ */ new Set([source]);
+      if (aliasGroups.get(target) === group) return;
+      clearBinding(target);
+      unvalidatedVariables.add(target);
+      group.add(target);
+      aliasGroups.set(source, group);
+      aliasGroups.set(target, group);
+    };
     const isFullyNarrowedPattern = (declarator) => {
       const declared = context.sourceCode.getDeclaredVariables(declarator);
       return declared.length > 0 && declared.every(
@@ -9116,29 +9412,40 @@ var prefer_schema_for_api_payload_default = createRule({
         )
       );
     };
-    const trackInitializer = (declarator) => {
-      if (!isRawPayloadSource(declarator.init)) return;
+    const trackInitializer = (declarator, scope) => {
       const declaredVars = context.sourceCode.getDeclaredVariables(declarator);
       const variable = declaredVars[0];
-      if (variable !== void 0) {
-        unvalidatedVariables.add(variable);
+      if (variable === void 0) return;
+      const localText = (candidate) => localFileTextRef(candidate, scope) !== null;
+      if (isRawPayloadSource(declarator.init, localText)) {
+        trackRawBinding(variable);
+        return;
       }
+      const source = unvalidatedVariableRef(declarator.init, scope, unvalidatedVariables);
+      if (source !== null) trackAlias(variable, source);
     };
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
         if (node.id.type === import_utils59.AST_NODE_TYPES.Identifier) {
-          trackInitializer(node);
+          const variable = context.sourceCode.getDeclaredVariables(node)[0];
+          if (variable !== void 0) {
+            updateLocalFileText(variable, node.init, scope);
+          }
+          trackInitializer(node, scope);
           return;
         }
         if (node.id.type === import_utils59.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils59.AST_NODE_TYPES.ArrayPattern) {
-          if (isRawPayloadSource(node.init)) {
+          if (isRawPayloadSource(
+            node.init,
+            (candidate) => localFileTextRef(candidate, scope) !== null
+          )) {
             if (!isFullyNarrowedPattern(node)) {
               context.report({ node: node.id, messageId: "unparsedJsonAccess" });
             }
             return;
           }
-          if (isUnvalidatedVariableRef(node.init, scope, unvalidatedVariables)) {
+          if (unvalidatedVariableRef(node.init, scope, unvalidatedVariables) !== null) {
             context.report({ node: node.id, messageId: "unparsedJsonAccess" });
           }
         }
@@ -9148,22 +9455,29 @@ var prefer_schema_for_api_payload_default = createRule({
         if (node.left.type === import_utils59.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
-          if (isRawPayloadSource(node.right)) {
-            unvalidatedVariables.add(variable);
+          const isLocalText = (candidate) => localFileTextRef(candidate, scope) !== null;
+          updateLocalFileText(variable, node.right, scope);
+          if (isRawPayloadSource(node.right, isLocalText)) {
+            trackRawBinding(variable);
           } else {
-            unvalidatedVariables.delete(variable);
+            const source = unvalidatedVariableRef(node.right, scope, unvalidatedVariables);
+            if (source === null) clearBinding(variable);
+            else trackAlias(variable, source);
           }
           return;
         }
         if (node.left.type === import_utils59.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils59.AST_NODE_TYPES.ArrayPattern) {
-          if (isRawPayloadSource(node.right)) {
+          if (isRawPayloadSource(
+            node.right,
+            (candidate) => localFileTextRef(candidate, scope) !== null
+          )) {
             context.report({
               node: node.left,
               messageId: "unparsedJsonAccess"
             });
             return;
           }
-          if (isUnvalidatedVariableRef(node.right, scope, unvalidatedVariables)) {
+          if (unvalidatedVariableRef(node.right, scope, unvalidatedVariables) !== null) {
             context.report({
               node: node.left,
               messageId: "unparsedJsonAccess"
@@ -9184,7 +9498,7 @@ var prefer_schema_for_api_payload_default = createRule({
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
-          if (variable !== null) unvalidatedVariables.delete(variable);
+          if (variable !== null) clearAliasGroup(variable);
         }
       },
       MemberExpression(node) {
@@ -9192,7 +9506,10 @@ var prefer_schema_for_api_payload_default = createRule({
         if (isValidationRead(node)) return;
         const scope = context.sourceCode.getScope(node);
         const obj = unwrap4(node.object);
-        if (isRawPayloadSource(obj)) {
+        if (isRawPayloadSource(
+          obj,
+          (candidate) => localFileTextRef(candidate, scope) !== null
+        )) {
           const parent = node.parent;
           if (parent.type === import_utils59.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils59.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
@@ -9200,12 +9517,13 @@ var prefer_schema_for_api_payload_default = createRule({
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils59.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
-          context.report({ node, messageId: "unparsedJsonAccess" });
-          const variable = findVariable2(scope, obj.name);
-          if (variable !== null) {
-            unvalidatedVariables.delete(variable);
+        const variable = obj?.type === import_utils59.AST_NODE_TYPES.Identifier ? unvalidatedVariableRef(obj, scope, unvalidatedVariables) : null;
+        if (variable !== null) {
+          if (isFullyValidatedExtractedBinding(node, variable, context)) {
+            return;
           }
+          context.report({ node, messageId: "unparsedJsonAccess" });
+          clearAliasGroup(variable);
         }
       }
     };
@@ -10969,8 +11287,8 @@ function initProvablyLacksSignal(init) {
   }
   return true;
 }
-function isStringish(node) {
-  return node.type === import_utils67.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils67.AST_NODE_TYPES.TemplateLiteral;
+function isInlineUrl(node, resolvesToGlobal) {
+  return node.type === import_utils67.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils67.AST_NODE_TYPES.TemplateLiteral || node.type === import_utils67.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils67.AST_NODE_TYPES.Identifier && node.callee.name === "URL" && resolvesToGlobal(node.callee);
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -11022,7 +11340,7 @@ var require_fetch_timeout_default = createRule({
           return;
         }
         const [first, init] = node.arguments;
-        if (node.arguments.length === 1 && first !== void 0 && !isStringish(first)) {
+        if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
         if (init === void 0 || initProvablyLacksSignal(init)) {
@@ -11039,7 +11357,7 @@ var CONFIGISH_TYPE_RE = /(?:Options|Opts|Config|Configuration|Settings|Params|Pr
 var CONFIGISH_NAME_RE = /^(?:options|opts|config|configuration|settings|params|props|args|env|environment|callbacks|flags|logger|log|clock)$/i;
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
 var BUILTIN_CONTAINER_TYPE_RE = /^(?:Record|Map|WeakMap|Set|WeakSet|Array|ReadonlyArray|ReadonlyMap|ReadonlySet|Promise|Partial|Required|Readonly|Pick|Omit|Exclude|Extract|NonNullable|Awaited|Parameters|ReturnType|InstanceType)$/;
-var VALUE_TYPE_RE = /^(?:ArrayBuffer|Blob|Buffer|Date|RegExp|URL|URLSearchParams)$/;
+var VALUE_TYPE_RE = /^(?:ArrayBuffer|Blob|Buffer|Date|NodePath|RegExp|URL|URLSearchParams)$/;
 var TRANSPORT_WRAPPER_NAME_RE = /(?:Client$|^Http[A-Z])/;
 var ERROR_VALUE_NAME_RE = /Error$/;
 var FLUENT_BUILDER_NAME_RE = /Builder$/;
@@ -11503,7 +11821,7 @@ var require_interface_for_injected_service_default = createRule({
         if (node.abstract === true) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils68.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils68.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor" && member.value.body !== null && member.value.body !== void 0
         );
         if (ctor === void 0) return;
         const constructorFacts = readConstructor(
@@ -12382,7 +12700,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "11.0.1"
+  version: "11.2.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",