@sarj/eslint-plugin 11.0.1 → 11.1.0

package/dist/index.cjs

@@ -2941,6 +2941,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 +3065,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 +3131,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({
@@ -5160,50 +5205,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 +5455,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 +5585,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 +5666,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 +5696,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 +5711,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 +5978,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 +7535,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 +7584,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 +7634,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);
       }
     };
   }
@@ -8960,7 +9060,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 +9084,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 +9165,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 +9269,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 +9295,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 +9353,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 +9396,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 +9439,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 +9447,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 +9458,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 +11228,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 +11281,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 +11298,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 +11762,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 +12641,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "11.0.1"
+  version: "11.1.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",

package/dist/index.d.cts

@@ -453,7 +453,7 @@ type FlatPreset = {
 declare const plugin: {
     readonly meta: {
         readonly name: "@sarj/eslint-plugin";
-        readonly version: "11.0.1";
+        readonly version: "11.1.0";
     };
     readonly rules: {
         readonly "duplicate-test-body": _typescript_eslint_utils_ts_eslint.RuleModule<"duplicateTestBody", readonly [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {