@sarj/eslint-plugin 15.0.0 → 15.2.0

package/dist/index.js

@@ -967,11 +967,11 @@ function isTrivialInitializer(node) {
 }
 function restatesStatementHead(body2, statement) {
   if (statement === null) return false;
-  const words = body2.match(/[A-Za-z][\w$]*/g) ?? [];
-  const opener = words[0];
-  if (opener === void 0 || words.length > NARRATION_MAX_WORDS) return false;
+  const words2 = body2.match(/[A-Za-z][\w$]*/g) ?? [];
+  const opener = words2[0];
+  if (opener === void 0 || words2.length > NARRATION_MAX_WORDS) return false;
   if (!NARRATION_VERB_RE.test(opener)) return false;
-  const content = words.slice(1).map(normalizeToken).filter((word) => !NARRATION_STOPWORDS.has(word));
+  const content = words2.slice(1).map(normalizeToken).filter((word) => !NARRATION_STOPWORDS.has(word));
   if (content.length < NARRATION_MIN_CONTENT) return false;
   const head = statement.split("(")[0] ?? statement;
   const code = headTokens(head);
@@ -1239,8 +1239,8 @@ function isRedundantNarration(body2, statementBelow, standalone, isolatedEnumera
     if (META_COMMENTARY_RE.test(t) && !justified) return true;
     if (isBareDeferral(t) && !justified) return true;
     if (HELPER_OPENER_RE.test(t) || LETS_RE.test(t)) return true;
-    const words = t.split(/\s+/);
-    if (words.length > 1 && words.length <= 4 && DUMMY_TRANSLATION_RE.test(t) && !/[():=]/.test(t)) {
+    const words2 = t.split(/\s+/);
+    if (words2.length > 1 && words2.length <= 4 && DUMMY_TRANSLATION_RE.test(t) && !/[():=]/.test(t)) {
       const lowerT = t.toLowerCase();
       if (!RATIONALE_WORDS.some((word) => lowerT.includes(word)) && restatesWholeStatement(t, statementBelow)) {
         return true;
@@ -1322,8 +1322,8 @@ function isWeakWalkthroughComment(body2, statement) {
   if (normalized.length === 0 || normalized.endsWith("?") || normalized.split(/\s+/).length > WALL_MAX_WORDS || isDirective(normalized) || isProtected(normalized) || !WALL_NARRATION_RE.test(normalized)) {
     return false;
   }
-  const words = contentTokens(normalized);
-  const described = words.slice(1);
+  const words2 = contentTokens(normalized);
+  const described = words2.slice(1);
   if (described.length === 0) return false;
   const code = codeTokens(statement);
   const matched = described.filter((word) => restates([word], code)).length;
@@ -2022,12 +2022,13 @@ function createSqlListener(handler) {
 
 // src/rules/no-dynamic-sql.ts
 var noDynamicSqlDocumentation = {
-  summary: "Disallow runtime interpolation or concatenation in SQL passed to statement-execution methods.",
+  summary: "Disallow runtime values embedded inside quoted SQL values passed to statement-execution methods.",
   rationale: "Embedding runtime values in SQL bypasses driver parameterization and can introduce injection defects or unstable query plans.",
   remediation: "Use SQL placeholders and pass runtime values through the driver's binding API.",
   category: "security",
   limitations: [
-    "The rule recognizes SQL by syntax and configured method names; static fragments and parameterizing tagged templates are exempt."
+    "The rule reports only visibly quoted runtime values; dynamic identifiers and unquoted fragments require provenance that syntax-only linting cannot prove.",
+    "Static fragments and parameterizing tagged templates are exempt."
   ],
   examples: [
     {
@@ -2062,27 +2063,48 @@ function isStaticFragment(expression) {
   if (expression.type === AST_NODE_TYPES8.Literal) {
     return typeof expression.value === "string";
   }
+  if (expression.type === AST_NODE_TYPES8.TemplateLiteral) {
+    return expression.expressions.length === 0;
+  }
   return false;
 }
 function runtimeInterpolations(template) {
   return template.expressions.filter(
-    (expression) => !isStaticFragment(expression)
+    (expression, index) => !isStaticFragment(expression) && endsWithSqlQuote(template.quasis[index]?.value.raw ?? "") && startsWithSqlQuote(template.quasis[index + 1]?.value.raw ?? "")
   );
 }
+function endsWithSqlQuote(text) {
+  return /['"]\s*$/u.test(text);
+}
+function startsWithSqlQuote(text) {
+  return /^\s*['"]/u.test(text);
+}
+function staticLiteralText(node) {
+  if (node.type === AST_NODE_TYPES8.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === AST_NODE_TYPES8.TemplateLiteral && node.expressions.length === 0) {
+    return node.quasis[0]?.value.raw;
+  }
+  return void 0;
+}
 function runtimeConcatOperands(node) {
   if (node.type !== AST_NODE_TYPES8.BinaryExpression || node.operator !== "+") {
     return [];
   }
   const operands = concatOperands(node);
   const hasStringLiteral = operands.some(
-    (operand) => operand.type === AST_NODE_TYPES8.Literal && typeof operand.value === "string"
+    (operand) => operand.type === AST_NODE_TYPES8.Literal && typeof operand.value === "string" || operand.type === AST_NODE_TYPES8.TemplateLiteral && operand.expressions.length === 0
   );
   if (!hasStringLiteral) {
     return [];
   }
-  return operands.filter(
-    (operand) => operand.type !== AST_NODE_TYPES8.Literal && !isStaticFragment(operand)
-  );
+  return operands.filter((operand, index) => {
+    if (isStaticFragment(operand)) return false;
+    const before = operands[index - 1];
+    const after = operands[index + 1];
+    return before !== void 0 && after !== void 0 && endsWithSqlQuote(staticLiteralText(before) ?? "") && startsWithSqlQuote(staticLiteralText(after) ?? "");
+  });
 }
 function concatOperands(node) {
   if (node.type === AST_NODE_TYPES8.BinaryExpression && node.operator === "+") {
@@ -2121,7 +2143,7 @@ var no_dynamic_sql_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow runtime interpolation or concatenation in SQL passed to statement-execution methods."
+      description: noDynamicSqlDocumentation.summary
     },
     schema: [
       {
@@ -2137,7 +2159,7 @@ var no_dynamic_sql_default = createRule({
       }
     ],
     messages: {
-      dynamicSql: "Runtime value built into a SQL statement passed to `{{method}}()`. Use a `?` placeholder and pass the value through `.bind(...)` so the driver parameterises it."
+      dynamicSql: "Runtime value embedded inside a quoted SQL value passed to `{{method}}()`. Replace the quoted interpolation with a placeholder and bind the value separately."
     }
   },
   defaultOptions: [{}],
@@ -2648,7 +2670,7 @@ var no_fat_try_blocks_default = createRule({
     const sourceCode = context.sourceCode;
     return {
       TryStatement(node) {
-        if (node.finalizer !== null) {
+        if (node.finalizer !== null && node.handler === null) {
           return;
         }
         if (handlerRethrows(node.handler)) {
@@ -2888,15 +2910,32 @@ var noHandRolledSpinnerDocumentation = {
   rationale: "One-off loading indicators duplicate a shared primitive and let accessibility and styling diverge.",
   remediation: "Render the design-system Spinner component instead.",
   category: "maintainability",
-  limitations: ["Only static className values on div and span elements are inspected."],
+  limitations: ["Only static className values on div and span elements are inspected; tests, stories, generated files, and the design-system implementation are excluded."],
   examples: [
     { id: "design-system-spinner", title: "Use the shared spinner", outcome: "no-match", files: [{ path: "src/loading-state.tsx", source: '<Spinner className="size-4" />' }], focusPath: "src/loading-state.tsx", expectedCount: 0, public: true },
     { id: "border-ring-spinner", title: "Do not rebuild a spinner", outcome: "match", files: [{ path: "src/loading-state.tsx", source: '<div className="size-4 animate-spin rounded-full border-2 border-t-transparent" />' }], focusPath: "src/loading-state.tsx", expectedCount: 1, public: true }
   ]
 };
 var DESIGN_SYSTEM_PATH = /(?:^|[/\\])components[/\\]ui[/\\]/u;
-var BORDER_WIDTH = /^border(?:-[0-9]+)?$/u;
-var CONTRASTING_EDGE = /^border-[trbl]-(?!0$|[0-9]+$).+/u;
+var DIRECTIONAL_BORDER = /^border-([trblsexy])-(.+)$/u;
+var CSS_LENGTH = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:cap|ch|cm|dvh|dvw|em|ex|ic|in|lh|lvh|lvw|mm|pc|pt|px|q|rcap|rch|rem|rex|ric|rlh|svh|svw|vb|vh|vi|vmax|vmin|vw|%)$/u;
+var ARBITRARY_LENGTH_FUNCTION = /^(?:calc|clamp|max|min)\(.+\)$/u;
+function isBorderWidthValue(value) {
+  if (/^\d+$/u.test(value)) return true;
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const arbitrary = value.slice(1, -1);
+    const length = arbitrary.startsWith("length:") ? arbitrary.slice("length:".length) : arbitrary;
+    return CSS_LENGTH.test(length) || ARBITRARY_LENGTH_FUNCTION.test(length) || arbitrary.startsWith("length:") && /^var\(.+\)$/u.test(length);
+  }
+  return value.startsWith("(length:") && value.endsWith(")") && value.length > "(length:)".length;
+}
+function isBorderWidth(token) {
+  return token === "border" || token.startsWith("border-") && isBorderWidthValue(token.slice("border-".length));
+}
+function isContrastingEdge(token) {
+  const match = DIRECTIONAL_BORDER.exec(token);
+  return match?.[2] !== void 0 && !isBorderWidthValue(match[2]);
+}
 function staticClassName(attribute) {
   const value = attribute.value;
   if (value?.type === AST_NODE_TYPES11.Literal && typeof value.value === "string") {
@@ -2925,7 +2964,7 @@ var no_hand_rolled_spinner_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (DESIGN_SYSTEM_PATH.test(context.filename)) {
+    if (DESIGN_SYSTEM_PATH.test(context.filename) || isTestFile(context.filename) || isStoryFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     return {
@@ -2940,7 +2979,7 @@ var no_hand_rolled_spinner_default = createRule({
         const className = staticClassName(classNameAttribute);
         if (className === null) return;
         const classes = className.split(/\s+/u);
-        if (classes.includes("animate-spin") && classes.includes("rounded-full") && classes.some((token) => BORDER_WIDTH.test(token)) && classes.some((token) => CONTRASTING_EDGE.test(token))) {
+        if (classes.includes("animate-spin") && classes.includes("rounded-full") && classes.some(isBorderWidth) && classes.some(isContrastingEdge)) {
           context.report({ node, messageId: "handRolledSpinner" });
         }
       }
@@ -2961,8 +3000,59 @@ var noInsecureRandomIdDocumentation = {
     { id: "predictable-token", title: "Do not derive a token from Math.random", outcome: "match", files: [{ path: "src/session.ts", source: "const sessionToken = Math.random();" }], focusPath: "src/session.ts", expectedCount: 1, public: true }
   ]
 };
-var STRONG_SECURITY_PATTERN = /token|secret|csrf|password|passwd|apikey|api[-_]?key|nonce|salt|uuid|authid/i;
-var NON_SECURITY_ID_PATTERN = /temp|tmp|cache|correlation|request|req|trace|execution|dev|hmr|mock|test|perf|marker|dialog|select|menu|tab|field|input|form|element|dom|aria|component/i;
+var STRONG_SECURITY_WORDS = /* @__PURE__ */ new Set([
+  "apikey",
+  "csrf",
+  "nonce",
+  "otp",
+  "password",
+  "passwd",
+  "pin",
+  "salt",
+  "secret",
+  "token",
+  "uuid",
+  "verificationcode"
+]);
+var NON_SECURITY_ID_WORDS = /* @__PURE__ */ new Set([
+  "aria",
+  "cache",
+  "component",
+  "correlation",
+  "dev",
+  "dialog",
+  "dom",
+  "element",
+  "execution",
+  "field",
+  "form",
+  "hmr",
+  "input",
+  "marker",
+  "menu",
+  "mock",
+  "perf",
+  "req",
+  "request",
+  "select",
+  "tab",
+  "temp",
+  "test",
+  "tmp",
+  "trace"
+]);
+function nameWords(name) {
+  return name.replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2").split(/[^A-Za-z0-9]+/u).filter(Boolean).map((word) => word.toLowerCase());
+}
+function isStrongSecurityName(name) {
+  const words2 = nameWords(name);
+  return words2.some((word) => STRONG_SECURITY_WORDS.has(word)) || words2.some(
+    (word, index) => word === "api" && words2[index + 1] === "key" || word === "auth" && words2[index + 1] === "id" || word === "verification" && words2[index + 1] === "code"
+  );
+}
+function isNonSecurityName(name) {
+  return nameWords(name).some((word) => NON_SECURITY_ID_WORDS.has(word));
+}
 var PATH_OR_DOM_MARKER = /[\\/#]|\.[A-Za-z0-9]/;
 function isMathRandomCall(node) {
   if (node.type !== "CallExpression") {
@@ -2975,70 +3065,57 @@ function isMathRandomCall(node) {
   const { object, property } = callee;
   return object.type === "Identifier" && object.name === "Math" && property.type === "Identifier" && property.name === "random";
 }
-function isPartOfToString36Chain(node) {
-  let current = node;
-  let parent = current.parent;
-  while (parent) {
-    if (parent.type === "MemberExpression" && parent.object === current && !parent.computed && parent.property.type === "Identifier" && parent.property.name === "toString") {
-      const grandparent = parent.parent;
-      if (grandparent && grandparent.type === "CallExpression" && grandparent.callee === parent) {
-        const firstArg = grandparent.arguments[0];
-        if (firstArg && firstArg.type === "Literal" && firstArg.value === 36) {
-          return true;
-        }
-      }
-    }
-    if (parent.type === "MemberExpression" && parent.object === current) {
-      current = parent;
-      parent = current.parent;
-      continue;
-    }
-    if (parent.type === "CallExpression" && parent.callee === current) {
-      current = parent;
-      parent = current.parent;
-      continue;
-    }
-    break;
-  }
-  return false;
-}
-function findEnclosingName(node) {
+function findEnclosingNames(node) {
+  const names = [];
+  let directBinding = true;
   let current = node;
   let parent = current.parent;
   while (parent) {
     if (parent.type === "VariableDeclarator" && parent.init === current) {
-      if (parent.id.type === "Identifier") {
-        return parent.id.name;
+      if (directBinding && parent.id.type === "Identifier") {
+        names.push(parent.id.name);
       }
-      return void 0;
     }
     if (parent.type === "Property" && parent.value === current) {
       const key = parent.key;
       if (!parent.computed && key.type === "Identifier") {
-        return key.name;
+        names.push(key.name);
       }
       if (key.type === "Literal" && typeof key.value === "string") {
-        return key.value;
+        names.push(key.value);
       }
-      return void 0;
+      directBinding = false;
     }
     if (parent.type === "PropertyDefinition" && parent.value === current) {
       const key = parent.key;
       if (!parent.computed && key.type === "Identifier") {
-        return key.name;
+        names.push(key.name);
       }
       if (key.type === "Literal" && typeof key.value === "string") {
-        return key.value;
+        names.push(key.value);
       }
-      return void 0;
+      directBinding = false;
     }
-    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression" || parent.type === "BlockStatement" || parent.type === "ReturnStatement" || parent.type === "ExpressionStatement") {
-      return void 0;
+    if (parent.type === "AssignmentExpression" && parent.right === current) {
+      if (directBinding && parent.left.type === "Identifier") names.push(parent.left.name);
+      if (directBinding && parent.left.type === "MemberExpression" && !parent.left.computed && parent.left.property.type === "Identifier") {
+        names.push(parent.left.property.name);
+      }
+    }
+    if (parent.type === "ObjectExpression" || parent.type === "ArrayExpression") {
+      directBinding = false;
+    }
+    if (parent.type === "FunctionDeclaration") {
+      if (directBinding && parent.id !== null) names.push(parent.id.name);
+      return names;
+    }
+    if (parent.type === "ExpressionStatement") {
+      return names;
     }
     current = parent;
     parent = current.parent;
   }
-  return void 0;
+  return names;
 }
 function isConcatenatedIntoPathOrDomId(node) {
   const valueNode = climbValueChain(node);
@@ -3124,20 +3201,17 @@ var no_insecure_random_id_default = createRule({
         if (!isMathRandomCall(node)) {
           return;
         }
-        const name = findEnclosingName(node);
-        if (name !== void 0 && STRONG_SECURITY_PATTERN.test(name)) {
+        const names = findEnclosingNames(node);
+        if (names.some(isStrongSecurityName)) {
           context.report({ node, messageId: "insecureRandomId" });
           return;
         }
-        if (name !== void 0 && NON_SECURITY_ID_PATTERN.test(name)) {
+        if (names.some(isNonSecurityName)) {
           return;
         }
         if (isConcatenatedIntoPathOrDomId(node)) {
           return;
         }
-        if (isPartOfToString36Chain(node)) {
-          context.report({ node, messageId: "insecureRandomId" });
-        }
       }
     };
   }
@@ -3937,7 +4011,7 @@ var VALUE_TAG_RE = /@(example|deprecated|see|remarks|throws|internal|public|alph
 var BOUNDARY_RE = /(?<=[.!?])["'`)\]]*\s+(?=[A-Z0-9`])/;
 var BULLET_RE = /^\s*(?:[-*+] |\d+[.)] )/;
 var HEADING_RE = /^[A-Za-z][A-Za-z ]+:$/;
-var TECHNICAL_ANCHOR_RE = /https?:\/\/|`[^`\n]+`|:[a-z][a-z0-9_-]*:|(["'])[^"'\n]+\1|\d|\b[a-z][a-z0-9]*[A-Z][A-Za-z0-9]*\b|\b[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9_]+\b|(?:^|\s)(?:[\w.-]+\/)+[\w.-]+|\b[\w.-]+\.(?:py|pyi|js|jsx|ts|tsx|json|ya?ml|toml|csv|parquet|md)\b|->|=>|==|!=|<=|>=|\|/mu;
+var TECHNICAL_ANCHOR_RE = /https?:\/\/|`[^`\n]+`|:[a-z][a-z0-9_-]*:|(["'])[^"'\n]+\1|\bv?\d+\.\d+(?:\.\d+)?\b|\b\d+(?:\.\d+)?\s?(?:ns|us|ms|s|sec|secs|seconds?|mins?|minutes?|hours?|days?|bytes?|kib|mib|gib|kb|mb|gb|hz|khz|mhz|px|%)\b|\b[a-z][a-z0-9]*[A-Z][A-Za-z0-9]*\b|\b[A-Za-z][A-Za-z0-9]*_[A-Za-z0-9_]+\b|(?:^|\s)(?:[\w.-]+\/)+[\w.-]+|\b[\w.-]+\.(?:py|pyi|js|jsx|ts|tsx|json|ya?ml|toml|csv|parquet|md)\b|->|=>|==|!=|<=|>=|\|/mu;
 function body(comment) {
   return comment.value.replace(/^\*/, "").split("\n").map((line) => line.replace(/^\s*\*?\s?/, "")).join("\n").trim();
 }
@@ -4801,7 +4875,8 @@ var DEFAULT_ALLOW = [
   "[\\\\/](connectors|providers|integrations|adapters|fetchers)[\\\\/]",
   "[\\\\/]notifications[\\\\/]",
   "[Ss]ervice\\.[cm]?[jt]sx?$",
-  "-(service|connector|adapter|sdk|fetcher)\\.[cm]?[jt]sx?$"
+  "-(service|connector|adapter|sdk|fetcher)\\.[cm]?[jt]sx?$",
+  "[\\\\/][^\\\\/]*(?:Client|client)\\.[cm]?[jt]sx?$"
 ];
 var NON_PRODUCTION_TREE_RE = /[\\/](playwright|cypress|__testfixtures__)[\\/]/;
 var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set([
@@ -4935,7 +5010,7 @@ var no_raw_fetch_outside_clients_default = createRule({
   defaultOptions: [{}],
   create(context, [options]) {
     const filename = context.filename;
-    if (isTestFile(filename) || NON_PRODUCTION_TREE_RE.test(filename)) {
+    if (isTestFile(filename) || isScriptFile(filename) || NON_PRODUCTION_TREE_RE.test(filename)) {
       return {};
     }
     const patterns = options?.allow ?? DEFAULT_ALLOW;
@@ -4975,10 +5050,15 @@ var no_raw_fetch_outside_clients_default = createRule({
     function isInternalApiUrl(node) {
       const resolved = resolveNode2(node ?? void 0);
       if (resolved?.type === AST_NODE_TYPES18.Literal) {
-        return typeof resolved.value === "string" && resolved.value.startsWith("/api/");
+        return typeof resolved.value === "string" && /^\/(?!\/)(?:[^/]+\/)*api(?:\/|$)/.test(resolved.value);
       }
       if (resolved?.type === AST_NODE_TYPES18.TemplateLiteral) {
-        return resolved.quasis[0]?.value.cooked?.startsWith("/api/") === true;
+        const prefix = resolved.quasis[0]?.value.cooked;
+        return typeof prefix === "string" && /^\/(?!\/)(?:[^/]+\/)*api(?:\/|$)/.test(prefix);
+      }
+      if (resolved?.type === AST_NODE_TYPES18.CallExpression && resolved.callee.type === AST_NODE_TYPES18.Identifier && resolved.callee.name === "withBase") {
+        const first = resolved.arguments[0];
+        return first !== void 0 && first.type !== AST_NODE_TYPES18.SpreadElement ? isInternalApiUrl(first) : false;
       }
       return resolved?.type === AST_NODE_TYPES18.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
     }
@@ -5822,12 +5902,17 @@ var BLOB_REDACTION_TOKENS = /* @__PURE__ */ new Set([
   "public"
 ]);
 function rawBlobValueName(value) {
+  if (value.type === "AwaitExpression") return rawBlobValueName(value.argument);
+  if (value.type === "ChainExpression") return rawBlobValueName(value.expression);
   if (value.type === "Identifier") {
     return isRawBlobName(value.name) ? value.name : null;
   }
   if (value.type === "MemberExpression" && !value.computed && value.property.type === "Identifier") {
     return isRawBlobName(value.property.name) ? value.property.name : null;
   }
+  if (value.type === "CallExpression" && value.arguments.length === 0 && value.callee.type === "MemberExpression" && !value.callee.computed && value.callee.object.type === "Identifier" && /^(?:res|response|\w+Response)$/.test(value.callee.object.name) && value.callee.property.type === "Identifier" && (value.callee.property.name === "json" || value.callee.property.name === "text")) {
+    return `${value.callee.object.name}.${value.callee.property.name}()`;
+  }
   return null;
 }
 function isRawBlobName(name) {
@@ -6492,6 +6577,9 @@ var isExplanatory = (comment) => !DIRECTIVE_COMMENT_RE.test(comment.value);
 function isTeardownCall(node) {
   return node.type === AST_NODE_TYPES24.CallExpression && node.callee.type === AST_NODE_TYPES24.MemberExpression && !node.callee.computed && node.callee.property.type === AST_NODE_TYPES24.Identifier && TEARDOWN_METHODS.has(node.callee.property.name);
 }
+function isCancelledWebShare(node) {
+  return node.type === AST_NODE_TYPES24.CallExpression && node.callee.type === AST_NODE_TYPES24.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES24.Identifier && node.callee.object.name === "navigator" && node.callee.property.type === AST_NODE_TYPES24.Identifier && node.callee.property.name === "share";
+}
 function isSilentHandler(handler) {
   const body2 = handler.body;
   if (body2.type !== AST_NODE_TYPES24.BlockStatement) {
@@ -6541,7 +6629,7 @@ var no_silent_promise_catch_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename)) {
+    if (isTestFile(context.filename) || isScriptFile(context.filename)) {
       return {};
     }
     const hasExplanatoryComment = (call, handler) => {
@@ -6574,7 +6662,10 @@ var no_silent_promise_catch_default = createRule({
         if (isTeardownCall(node.callee.object)) {
           return;
         }
-        if (node.parent.type === AST_NODE_TYPES24.MemberExpression && node.parent.object === node) {
+        if (isCancelledWebShare(node.callee.object)) {
+          return;
+        }
+        if (node.parent.type === AST_NODE_TYPES24.MemberExpression && node.parent.object === node && !node.parent.computed && node.parent.property.type === AST_NODE_TYPES24.Identifier && node.parent.property.name === "then") {
           return;
         }
         const expectedArguments = method === "catch" ? 1 : 2;
@@ -6736,22 +6827,25 @@ var noStorageInStatelessModulesDocumentation = {
   rationale: "Private storage in a stateless workflow creates another source of truth that can silently diverge.",
   remediation: "Read from the system of record or derive state from an artifact the workflow already produces.",
   category: "architecture",
-  limitations: ["The rule is disabled until module path patterns are configured and recognizes only configured storage method names."],
+  limitations: ["The rule is disabled until module path patterns are configured, recognizes only configured storage method names, and requires storage-like receiver evidence for the overloaded `put` method."],
   examples: [
     { id: "system-of-record", title: "Read from the system of record", outcome: "no-match", files: [{ path: "src/engineer-digest/post.ts", source: "const issues = await linear.listIssues();" }], focusPath: "src/engineer-digest/post.ts", expectedCount: 0, public: true },
     { id: "private-storage", title: "Do not write private state in a stateless module", outcome: "match", files: [{ path: "src/engineer-digest/post.ts", source: "await kv.put('digest:last', timestamp);" }], focusPath: "src/engineer-digest/post.ts", expectedCount: 1, public: true }
   ]
 };
 function compile2(patterns) {
-  const compiled = [];
-  for (const pattern of patterns) {
-    try {
-      compiled.push(new RegExp(pattern));
-    } catch {
-    }
-  }
-  return compiled;
+  return patterns.map((pattern) => new RegExp(pattern));
 }
+var STORAGE_RECEIVER_WORDS = /* @__PURE__ */ new Set([
+  "bucket",
+  "cache",
+  "kv",
+  "namespace",
+  "r2",
+  "redis",
+  "storage",
+  "store"
+]);
 function storageMethodName(node, methods) {
   const callee = node.callee;
   if (callee.type !== AST_NODE_TYPES26.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES26.Identifier) {
@@ -6764,8 +6858,31 @@ function storageMethodName(node, methods) {
   if (node.arguments.length < (MIN_ARGUMENTS.get(name) ?? 1)) {
     return null;
   }
+  if (name === "put" && !isStorageLikeReceiver(callee.object)) {
+    return null;
+  }
   return name;
 }
+function isStorageLikeReceiver(node) {
+  if (node.type === AST_NODE_TYPES26.Identifier) {
+    return isStorageIdentifier(node.name);
+  }
+  if (node.type !== AST_NODE_TYPES26.MemberExpression) {
+    return false;
+  }
+  if (!node.computed && node.property.type === AST_NODE_TYPES26.Identifier && isStorageIdentifier(node.property.name)) {
+    return true;
+  }
+  return isStorageLikeReceiver(node.object);
+}
+function isStorageIdentifier(name) {
+  return identifierWords(name).some(
+    (word) => STORAGE_RECEIVER_WORDS.has(word.toLowerCase())
+  );
+}
+function identifierWords(name) {
+  return name.match(/[A-Z]?[a-z]+|[A-Z]+(?=[A-Z]|$)|\d+/gu) ?? [name];
+}
 var no_storage_in_stateless_modules_default = createRule({
   name: "no-storage-in-stateless-modules",
   documentation: noStorageInStatelessModulesDocumentation,
@@ -6886,7 +7003,20 @@ function isStringInitializedVariable(variable) {
   if (declarator.type !== "VariableDeclarator") {
     return false;
   }
-  return isStringLiteralInit(declarator.init);
+  if (isStringLiteralInit(declarator.init)) return true;
+  if (declarator.id.type === "Identifier" && declarator.id.typeAnnotation?.typeAnnotation.type === "TSStringKeyword") {
+    return true;
+  }
+  return isTemplateStringsArrayElement(declarator.init, variable.scope);
+}
+function isTemplateStringsArrayElement(node, scope) {
+  if (node?.type !== "MemberExpression" || !node.computed || node.object.type !== "Identifier") {
+    return false;
+  }
+  const source = findVariable(scope, node.object.name);
+  if (source?.defs.length !== 1) return false;
+  const name = source.defs[0]?.name;
+  return name?.type === "Identifier" && name.typeAnnotation?.typeAnnotation.type === "TSTypeReference" && name.typeAnnotation.typeAnnotation.typeName.type === "Identifier" && name.typeAnnotation.typeAnnotation.typeName.name === "TemplateStringsArray";
 }
 function isStringLiteralInit(node) {
   if (node === null) {
@@ -6920,12 +7050,13 @@ function isConcatOperand(node, target) {
   }
   return false;
 }
-function isDeclaredInsideLoop(variable, loop) {
+function isDeclaredInsideLoop(variable, repetition) {
   const def = variable.defs[0];
   if (def === void 0) {
     return false;
   }
-  const body2 = loop.body;
+  const body2 = repetition.type === "CallExpression" ? repetition.arguments[0] : repetition.body;
+  if (body2 === void 0 || body2.type === "SpreadElement") return false;
   const [declStart, declEnd] = def.node.range;
   const [bodyStart, bodyEnd] = body2.range;
   return declStart >= bodyStart && declEnd <= bodyEnd;
@@ -6934,6 +7065,9 @@ function enclosingLoop(node) {
   let child = node;
   let parent = node.parent;
   while (parent !== void 0 && parent !== null) {
+    if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") && parent.parent.type === "CallExpression" && parent.parent.arguments[0] === parent && parent.parent.callee.type === "MemberExpression" && !parent.parent.callee.computed && parent.parent.callee.property.type === "Identifier" && parent.parent.callee.property.name === "forEach") {
+      return parent.parent;
+    }
     if (LOOP_NODE_TYPES.has(parent.type)) {
       const loop = parent;
       if (loop.body === child) {
@@ -6945,6 +7079,17 @@ function enclosingLoop(node) {
   }
   return null;
 }
+function isSmallStaticForLoop(node) {
+  if (node.type !== "ForStatement" || node.init?.type !== "VariableDeclaration" || node.init.declarations.length !== 1 || node.test?.type !== "BinaryExpression" || node.test.operator !== "<" && node.test.operator !== "<=" || node.update?.type !== "UpdateExpression" || node.update.operator !== "++") {
+    return false;
+  }
+  const declaration = node.init.declarations[0];
+  if (declaration?.id.type !== "Identifier" || declaration.init?.type !== "Literal" || typeof declaration.init.value !== "number" || !Number.isInteger(declaration.init.value) || node.test.left.type !== "Identifier" || node.test.left.name !== declaration.id.name || node.test.right.type !== "Literal" || typeof node.test.right.value !== "number" || !Number.isInteger(node.test.right.value) || node.update.argument.type !== "Identifier" || node.update.argument.name !== declaration.id.name) {
+    return false;
+  }
+  const iterations = node.test.right.value - declaration.init.value + (node.test.operator === "<=" ? 1 : 0);
+  return iterations >= 0 && iterations <= 8;
+}
 var no_string_concat_in_loop_default = createRule({
   name: "no-string-concat-in-loop",
   documentation: noStringConcatInLoopDocumentation,
@@ -6977,6 +7122,9 @@ var no_string_concat_in_loop_default = createRule({
         if (loop === null) {
           return;
         }
+        if (isSmallStaticForLoop(loop)) {
+          return;
+        }
         const scope = context.sourceCode.getScope(node);
         const variable = findVariable(scope, node.left.name);
         if (variable === void 0) {
@@ -7136,12 +7284,86 @@ var no_tautological_expect_default = createRule({
 });
 
 // src/rules/no-typed-doc-sections.ts
+var TYPED_TAG_RE2 = /^\s*@(arg|argument|param|return|returns|yield|yields)\b(.*)$/iu;
+var PARAM_TAGS2 = /* @__PURE__ */ new Set(["arg", "argument", "param"]);
+var PARAMETER_FILLER = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "argument",
+  "given",
+  "input",
+  "parameter",
+  "passed",
+  "provided",
+  "the",
+  "value"
+]);
+var RESULT_FILLER = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "array",
+  "boolean",
+  "generator",
+  "number",
+  "object",
+  "output",
+  "promise",
+  "result",
+  "return",
+  "returned",
+  "returns",
+  "string",
+  "the",
+  "value"
+]);
+function hasVacuousTypedTag(text) {
+  const tags = typedTags(text);
+  return tags.length > 0 && tags.some(isVacuousTag);
+}
+function typedTags(text) {
+  const tags = [];
+  for (const raw of text.split("\n")) {
+    const match = TYPED_TAG_RE2.exec(raw);
+    if (match !== null) {
+      tags.push({ kind: (match[1] ?? "").toLowerCase(), payload: (match[2] ?? "").trim() });
+    } else if (tags.length > 0 && raw.trim().length > 0 && !raw.trim().startsWith("@")) {
+      const last = tags.at(-1);
+      last.payload = `${last.payload} ${raw.trim()}`.trim();
+    }
+  }
+  return tags.map(({ kind, payload }) => {
+    let rest = payload.replace(/^\{[^}\n]+\}\s*/u, "").trim();
+    if (!PARAM_TAGS2.has(kind)) {
+      return { kind, name: null, description: rest.replace(/^-\s*/u, "").trim() };
+    }
+    const match = /^(\[[^\]]+\]|[A-Za-z_$][\w$.[\]-]*)(?:\s+-\s*|\s+)?(.*)$/u.exec(rest);
+    if (match === null) return { kind, name: null, description: "" };
+    const rawName = (match[1] ?? "").replace(/^\[/u, "").replace(/\]$/u, "").split("=")[0] ?? "";
+    rest = (match[2] ?? "").trim();
+    return { kind, name: rawName, description: rest };
+  });
+}
+function isVacuousTag(tag) {
+  const description = words(tag.description).map(canonicalWord);
+  if (description.length === 0) return true;
+  if (tag.name === null) return description.every((word) => RESULT_FILLER.has(word));
+  const nameWords2 = new Set(words(tag.name).map(canonicalWord));
+  return description.every((word) => PARAMETER_FILLER.has(word) || nameWords2.has(word));
+}
+function words(text) {
+  return text.replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2").toLowerCase().match(/[a-z][a-z0-9]*/gu) ?? [];
+}
+function canonicalWord(word) {
+  if (["identifier", "identifiers", "ids"].includes(word)) return "id";
+  if (word.endsWith("s") && word.length > 3) return word.slice(0, -1);
+  return word;
+}
 var noTypedDocSectionsDocumentation = {
   summary: "Reject typed-signature repetition while preserving behavior that types cannot express.",
   rationale: "Parameter and return tags repeat typed signatures and can drift without adding runtime behavior or constraints.",
   remediation: "Remove repeated parameter and return tags; retain documentation for behavior, failures, and external contracts.",
   category: "maintainability",
-  limitations: ["Parameter and return tags are reported only when the documented function has corresponding explicit TypeScript types."],
+  limitations: ["Description-free or name-restating parameter and return tags are reported only when the documented function has corresponding explicit TypeScript types."],
   examples: [
     {
       id: "behavioral-documentation",
@@ -7179,7 +7401,7 @@ var no_typed_doc_sections_default = createRule({
     return {
       Program() {
         for (const group of proseGroups(context.filename, context.sourceCode, true)) {
-          if (group.hasTypedTags && documentsTypedFunction(context.sourceCode, group.comment)) {
+          if (group.hasTypedTags && hasVacuousTypedTag(group.text) && documentsTypedFunction(context.sourceCode, group.comment)) {
             context.report({ node: group.comment, messageId: "typedSection" });
           }
         }
@@ -7280,28 +7502,32 @@ var STOPWORDS3 = /* @__PURE__ */ new Set([
   "with"
 ]);
 var DIRECTIVE_RE5 = /^\s*(?:eslint\b|eslint-|sarj-noqa\b|@ts-|prettier|biome-|c8\b|v8\b|istanbul\b|todo\b|fixme\b|hack\b|xxx\b)/i;
+var UNIT_NAME_SUFFIX_RE = /(?:_(?:NS|US|MS|S|SEC|SECS|SECOND|SECONDS|MIN|MINS|MINUTE|MINUTES|HOUR|HOURS|DAY|DAYS|BYTE|BYTES|KB|MB|GB|HZ|KHZ|MHZ|PX)|(?:Ns|Us|Ms|Sec|Secs|Second|Seconds|Min|Mins|Minute|Minutes|Hour|Hours|Day|Days|Byte|Bytes|Kb|Mb|Gb|Hz|Khz|Mhz|Px))$/u;
 function narratesValue(body2, code) {
   if (body2.length === 0 || DIRECTIVE_RE5.test(body2) || hasExternalReference(body2)) return false;
   const codeNumbers = numbersIn(code);
   if (codeNumbers.size === 0) return false;
-  const words = (body2.match(WORD_RE3) ?? []).map((word) => word.toLowerCase());
-  if (words.length === 0) return false;
+  const words2 = (body2.match(WORD_RE3) ?? []).map((word) => word.toLowerCase());
+  if (words2.length === 0) return false;
   const commentNumbers = numbersIn(body2);
   if (commentNumbers.size === 0) return false;
   for (const number of commentNumbers) {
     if (!codeNumbers.has(number)) return false;
   }
-  if (!words.some((word) => UNIT_WORDS.has(word))) return false;
+  if (!words2.some((word) => UNIT_WORDS.has(word))) return false;
   const identifiers = codeTokens(code);
   const stems = /* @__PURE__ */ new Set();
   for (const token of identifiers) stems.add(stem(token));
-  return words.every(
+  return words2.every(
     (word) => STOPWORDS3.has(word) || UNIT_WORDS.has(word) || commentNumbers.has(word) || identifiers.has(word) || stems.has(stem(word))
   );
 }
 function numbersIn(text) {
   return new Set(text.match(NUMBER_RE) ?? []);
 }
+function nameAlreadyCarriesUnit(code) {
+  return (code.match(/[A-Za-z_$][\w$]*/gu) ?? []).some((identifier) => UNIT_NAME_SUFFIX_RE.test(identifier));
+}
 var no_trailing_value_narration_default = createRule({
   name: "no-trailing-value-narration",
   documentation: noTrailingValueNarrationDocumentation,
@@ -7312,6 +7538,7 @@ var no_trailing_value_narration_default = createRule({
     },
     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."
     }
   },
@@ -7344,7 +7571,10 @@ 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)) {
-            context.report({ node: comment, messageId: "narratesValue" });
+            context.report({
+              node: comment,
+              messageId: nameAlreadyCarriesUnit(code) ? "deleteNarration" : "narratesValue"
+            });
           }
         }
       }
@@ -8262,7 +8492,8 @@ var no_unsafe_mock_casting_default = createRule({
 // src/rules/no-zod-native-enum.ts
 import {
   ESLintUtils as ESLintUtils2,
-  AST_NODE_TYPES as AST_NODE_TYPES34
+  AST_NODE_TYPES as AST_NODE_TYPES34,
+  ASTUtils as ASTUtils8
 } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 var noZodNativeEnumDocumentation = {
@@ -8391,15 +8622,23 @@ var no_zod_native_enum_default = createRule({
     } catch {
       services = null;
     }
-    const zodImportedNames = /* @__PURE__ */ new Map();
-    const zodNamespaces = /* @__PURE__ */ new Set();
+    const zodImportedBindings = /* @__PURE__ */ new Map();
+    const zodNamespaceBindings = /* @__PURE__ */ new Set();
+    function resolvedBinding(identifier) {
+      return ASTUtils8.findVariable(
+        sourceCode.getScope(identifier),
+        identifier.name
+      );
+    }
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === AST_NODE_TYPES34.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES34.Identifier && zodNamespaces.has(callee.object.name) && callee.property.type === AST_NODE_TYPES34.Identifier) {
-        return callee.property.name === api;
+      if (callee.type === AST_NODE_TYPES34.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES34.Identifier && callee.property.type === AST_NODE_TYPES34.Identifier) {
+        const binding = resolvedBinding(callee.object);
+        return binding !== null && zodNamespaceBindings.has(binding) && callee.property.name === api;
       }
       if (callee.type === AST_NODE_TYPES34.Identifier) {
-        return zodImportedNames.get(callee.name) === api;
+        const binding = resolvedBinding(callee);
+        return binding !== null && zodImportedBindings.get(binding) === api;
       }
       return false;
     }
@@ -8434,10 +8673,14 @@ var no_zod_native_enum_default = createRule({
         }
         for (const spec of node.specifiers) {
           if (spec.type === AST_NODE_TYPES34.ImportNamespaceSpecifier || spec.type === AST_NODE_TYPES34.ImportDefaultSpecifier || spec.type === AST_NODE_TYPES34.ImportSpecifier && (spec.imported.type === AST_NODE_TYPES34.Identifier ? spec.imported.name === "z" : spec.imported.value === "z")) {
-            zodNamespaces.add(spec.local.name);
+            const binding = resolvedBinding(spec.local);
+            if (binding !== null) zodNamespaceBindings.add(binding);
           }
           if (spec.type === AST_NODE_TYPES34.ImportSpecifier && spec.imported.type === AST_NODE_TYPES34.Identifier) {
-            zodImportedNames.set(spec.local.name, spec.imported.name);
+            const binding = resolvedBinding(spec.local);
+            if (binding !== null) {
+              zodImportedBindings.set(binding, spec.imported.name);
+            }
           }
         }
       },
@@ -8474,7 +8717,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/test-loops-over-literal-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES35, ASTUtils as ASTUtils8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES35, ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
 var testLoopsOverLiteralCasesDocumentation = {
   summary: "Disallow assertions over an inline literal case loop in a test; parameterization reports and names every case independently.",
   rationale: "A loop is reported as one test, so failures hide the individual case name and may stop later cases from running.",
@@ -8637,7 +8880,7 @@ var test_loops_over_literal_cases_default = createRule({
       return {};
     }
     const isFrameworkIdentifier = (identifier, modules) => {
-      const variable = ASTUtils8.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils9.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable === null || variable.defs.length === 0) return true;
       return variable.defs.some((definition) => {
         let current = definition.node;
@@ -8830,8 +9073,10 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   let statusMemberCount = 0;
   let hasFailurePayload = false;
   let hasSuccessPayload = false;
+  let hasUnrecognizedMember = false;
   for (const member of typeLiteral.members) {
     if (member.type !== AST_NODE_TYPES37.TSPropertySignature) {
+      hasUnrecognizedMember = true;
       continue;
     }
     const name = getMemberName(member);
@@ -8840,15 +9085,18 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
       continue;
     }
     if (!member.optional || isBooleanTyped(member) || name === null) {
+      hasUnrecognizedMember = true;
       continue;
     }
     if (FAILURE_MEMBER_NAMES.has(name)) {
       hasFailurePayload = true;
     } else if (SUCCESS_PAYLOAD_MEMBER_NAMES.has(name)) {
       hasSuccessPayload = true;
+    } else {
+      hasUnrecognizedMember = true;
     }
   }
-  return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && hasSuccessPayload;
+  return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
 }
 function getMemberName(member) {
   if (member.type !== AST_NODE_TYPES37.TSPropertySignature) {
@@ -9069,7 +9317,7 @@ var prefer_input_group_search_default = createRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES39, ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES39, ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
 var preferImmutableModuleConstantDocumentation = {
   summary: "Require module-level constant collections to expose readonly state.",
   rationale: "A const binding prevents reassignment but does not stop callers from mutating its array, object, Set, or Map contents.",
@@ -9222,7 +9470,7 @@ var prefer_immutable_module_constant_default = createRule({
   create(context) {
     const sourceCode = context.sourceCode;
     const isUnshadowedGlobal = (identifier) => {
-      const variable = ASTUtils9.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils10.findVariable(sourceCode.getScope(identifier), identifier.name);
       return variable === null || variable.defs.length === 0;
     };
     if (JAVASCRIPT_FILE_RE.test(context.filename) || isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
@@ -10139,7 +10387,7 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES43, ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES43, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
 var preferNativeRandomUuidDocumentation = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
@@ -10175,7 +10423,7 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve(identifier) {
-      return ASTUtils10.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils11.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve(identifier);
@@ -10238,7 +10486,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES44, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES44, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
 var preferNonNullableCollectionDocumentation = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -10368,14 +10616,14 @@ function directlyCoalesced(node) {
   return parent?.type === AST_NODE_TYPES44.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = ASTUtils11.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = ASTUtils12.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = ASTUtils11.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = ASTUtils12.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
@@ -10749,7 +10997,7 @@ var prefer_schema_for_api_payload_default = createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
+    if (isTestFile(context.filename) || isScriptFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
     const unvalidatedVariables = /* @__PURE__ */ new Set();
@@ -12217,6 +12465,9 @@ var requireAssertNeverDocumentation = {
 };
 var isRuntimeHandlingStatement = (statement) => {
   if (statement.type === AST_NODE_TYPES49.EmptyStatement) return false;
+  if (statement.type === AST_NODE_TYPES49.BreakStatement) {
+    return statement.label !== null;
+  }
   if (statement.type === AST_NODE_TYPES49.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES49.TSInterfaceDeclaration) {
     return false;
   }
@@ -12246,7 +12497,12 @@ function isExhaustiveFiniteSwitch(node, services) {
   const discriminant = services.esTreeNodeToTSNodeMap.get(node.discriminant);
   const discriminantType = checker.getTypeAtLocation(discriminant);
   const constituents = discriminantType.isUnion() ? discriminantType.types : [discriminantType];
-  if (constituents.length === 0) return false;
+  if (!discriminantType.isUnion() || constituents.length < 2) return false;
+  if (constituents.every(
+    (constituent) => (constituent.flags & ts2.TypeFlags.BooleanLiteral) !== 0
+  )) {
+    return false;
+  }
   const expected = /* @__PURE__ */ new Set();
   for (const constituent of constituents) {
     const key = finiteTypeKey(constituent, checker);
@@ -12314,7 +12570,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES50, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES50, ASTUtils as ASTUtils13 } 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.",
@@ -12395,7 +12651,7 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils12.findVariable(scope, identifier.name);
+      const variable = ASTUtils13.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
@@ -12404,6 +12660,26 @@ var require_fetch_timeout_default = createRule({
       }
       return callee.type === AST_NODE_TYPES50.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES50.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES50.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
+    function localConstInitProvablyLacksSignal(identifier) {
+      const variable = ASTUtils13.findVariable(
+        context.sourceCode.getScope(identifier),
+        identifier.name
+      );
+      if (variable?.defs.length !== 1) return false;
+      const definition = variable.defs[0];
+      if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init?.type !== AST_NODE_TYPES50.ObjectExpression || !initProvablyLacksSignal(definition.node.init)) {
+        return false;
+      }
+      for (const reference of variable.references) {
+        const ref = reference.identifier;
+        if (ref === identifier || ref === definition.name) continue;
+        const member = ref.parent;
+        if (member.type !== AST_NODE_TYPES50.MemberExpression || member.object !== ref || member.computed || member.property.type !== AST_NODE_TYPES50.Identifier || member.property.name === "signal" || member.parent.type !== AST_NODE_TYPES50.AssignmentExpression || member.parent.left !== member) {
+          return false;
+        }
+      }
+      return true;
+    }
     return {
       CallExpression(node) {
         if (!isGlobalFetchCall2(node.callee)) {
@@ -12413,7 +12689,7 @@ var require_fetch_timeout_default = createRule({
         if (node.arguments.length === 1 && first !== void 0 && !isInlineUrl(first, resolvesToGlobal)) {
           return;
         }
-        if (init === void 0 || initProvablyLacksSignal(init)) {
+        if (init === void 0 || initProvablyLacksSignal(init) || init.type === AST_NODE_TYPES50.Identifier && localConstInitProvablyLacksSignal(init)) {
           context.report({ node, messageId: "missingSignal" });
         }
       }
@@ -13027,34 +13303,35 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES53 } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES53,
+  ASTUtils as ASTUtils14
+} from "@typescript-eslint/utils";
 var requireZodFormValidationDocumentation = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
   rationale: "FormData values are untrusted strings or files and need runtime validation before use.",
   remediation: "Read the value inside a Zod schema's `parse` or `safeParse` input.",
   category: "security",
+  limitations: [
+    "Tests are excluded; imported schema-shaped names are trusted when their implementation is outside the linted file.",
+    "Delayed raw-value use is accepted only after an unconditional successful parse in the same block; safeParse remains valid when the raw binding has no unvalidated consumer."
+  ],
   examples: [
     { id: "validated-form-value", title: "Validate the form value", outcome: "no-match", files: [{ path: "src/action.ts", source: "const input = UserSchema.parse({ name: formData.get('name') });" }], focusPath: "src/action.ts", expectedCount: 0, public: true },
     { id: "raw-form-value", title: "Do not use a raw form value", outcome: "match", files: [{ path: "src/action.ts", source: "const name = formData.get('name');" }], focusPath: "src/action.ts", expectedCount: 1, public: true }
   ]
 };
-var isZodParseCall = (node) => {
-  if (node.type !== AST_NODE_TYPES53.CallExpression) return false;
-  const callee = node.callee;
-  if (callee.type !== AST_NODE_TYPES53.MemberExpression) return false;
-  if (callee.computed) return false;
-  if (callee.property.type !== AST_NODE_TYPES53.Identifier) return false;
-  const method = callee.property.name;
-  if (method !== "parse" && method !== "safeParse" && method !== "parseAsync" && method !== "safeParseAsync") {
-    return false;
-  }
-  return looksLikeZodSchema(callee.object);
-};
-var looksLikeZodSchema = (node) => {
+var ZOD_PARSE_METHODS = /* @__PURE__ */ new Set([
+  "parse",
+  "safeParse",
+  "parseAsync",
+  "safeParseAsync"
+]);
+var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
     if (current.type === AST_NODE_TYPES53.Identifier) {
-      return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
+      return current;
     }
     if (current.type === AST_NODE_TYPES53.CallExpression) {
       current = current.callee;
@@ -13064,7 +13341,7 @@ var looksLikeZodSchema = (node) => {
       current = current.object;
       continue;
     }
-    return false;
+    return null;
   }
 };
 var isFormDataMethodCall = (node) => {
@@ -13094,6 +13371,34 @@ var require_zod_form_validation_default = createRule({
     if (isTestFile(context.filename)) {
       return {};
     }
+    const zodBindings = /* @__PURE__ */ new Set();
+    const resolvedBinding = (identifier) => ASTUtils14.findVariable(
+      context.sourceCode.getScope(identifier),
+      identifier.name
+    );
+    const isProvablyNonZodLocal = (identifier) => {
+      const binding = resolvedBinding(identifier);
+      if (binding === null || zodBindings.has(binding) || binding.defs.length !== 1) {
+        return false;
+      }
+      const definition = binding.defs[0];
+      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES53.VariableDeclarator) {
+        return false;
+      }
+      const init = definition.node.init;
+      return init?.type === AST_NODE_TYPES53.ObjectExpression || init?.type === AST_NODE_TYPES53.ArrayExpression || init?.type === AST_NODE_TYPES53.Literal || init?.type === AST_NODE_TYPES53.ArrowFunctionExpression || init?.type === AST_NODE_TYPES53.FunctionExpression;
+    };
+    const isZodParseCall = (node) => {
+      if (node.type !== AST_NODE_TYPES53.CallExpression) return false;
+      const callee = node.callee;
+      if (callee.type !== AST_NODE_TYPES53.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES53.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+        return false;
+      }
+      const root = zodReceiverRoot(callee.object);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
+    };
     const isFormSourceIdentifier = (node) => {
       if (node.type !== AST_NODE_TYPES53.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
@@ -13119,14 +13424,15 @@ var require_zod_form_validation_default = createRule({
       }
       return isFormSourceIdentifier(callee.object);
     };
-    const hasZodParseAncestor = (node) => {
+    const zodParseAncestor = (node) => {
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
-        if (isZodParseCall(parent)) return true;
+        if (isZodParseCall(parent)) return parent;
         parent = parent.parent;
       }
-      return false;
+      return null;
     };
+    const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
       return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES53.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES53.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
@@ -13143,14 +13449,111 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
+    const containingStatement = (node) => {
+      let current = node;
+      while (current.parent !== void 0) {
+        const parent = current.parent;
+        if (parent.type === AST_NODE_TYPES53.BlockStatement || parent.type === AST_NODE_TYPES53.Program) {
+          return current;
+        }
+        current = parent;
+      }
+      return null;
+    };
+    const zodParseMethod = (call) => {
+      const callee = call.callee;
+      return callee.type === AST_NODE_TYPES53.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES53.Identifier ? callee.property.name : null;
+    };
+    const hasConditionalAncestorBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === AST_NODE_TYPES53.LogicalExpression || current.type === AST_NODE_TYPES53.ConditionalExpression) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    };
+    const isAwaitedBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === AST_NODE_TYPES53.AwaitExpression) return true;
+        current = current.parent;
+      }
+      return false;
+    };
+    const guaranteedValidationStatement = (declarator, reference) => {
+      const parse2 = zodParseAncestor(reference);
+      if (parse2 === null) return null;
+      const declarationStatement = containingStatement(declarator);
+      const validationStatement = containingStatement(parse2);
+      if (declarationStatement === null || validationStatement === null || declarationStatement.parent !== validationStatement.parent || validationStatement.range[0] <= declarationStatement.range[1] || hasConditionalAncestorBeforeStatement(parse2, validationStatement)) {
+        return null;
+      }
+      if (validationStatement.type !== AST_NODE_TYPES53.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES53.ExpressionStatement) {
+        return null;
+      }
+      const method = zodParseMethod(parse2);
+      if (method === "parse") return validationStatement;
+      if (method === "parseAsync" && isAwaitedBeforeStatement(parse2, validationStatement)) {
+        return validationStatement;
+      }
+      return null;
+    };
+    const isSafePrevalidationInspection = (identifier) => {
+      const parent = identifier.parent;
+      if (parent.type === AST_NODE_TYPES53.UnaryExpression && parent.operator === "typeof") {
+        return true;
+      }
+      if (parent.type !== AST_NODE_TYPES53.BinaryExpression || parent.left !== identifier) {
+        return false;
+      }
+      if (parent.operator === "instanceof") {
+        return parent.right.type === AST_NODE_TYPES53.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      }
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES53.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES53.Identifier && parent.right.name === "undefined");
+    };
+    const statementWithinBlock = (node, block) => {
+      let current = node;
+      while (current.parent !== void 0 && current.parent !== block) {
+        current = current.parent;
+      }
+      return current.parent === block ? current : null;
+    };
     const bindingIsValidated = (declarator) => {
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
-      return variable.references.some(
-        (ref) => hasZodParseAncestor(ref.identifier) || isInstanceofNarrowing(ref.identifier)
+      const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
+        (identifier) => identifier.type === AST_NODE_TYPES53.Identifier
+      );
+      if (references.length === 0) return false;
+      if (references.some(isInstanceofNarrowing)) return true;
+      const validationStatements = references.map((reference) => guaranteedValidationStatement(declarator, reference)).filter(
+        (statement) => statement !== null
       );
+      const declarationStatement = containingStatement(declarator);
+      const declarationBlock = declarationStatement?.parent;
+      return references.every((reference) => {
+        if (zodParseAncestor(reference) !== null || isSafePrevalidationInspection(reference)) {
+          return true;
+        }
+        if (declarationBlock === void 0) return false;
+        const useStatement = statementWithinBlock(reference, declarationBlock);
+        return useStatement !== null && validationStatements.some(
+          (statement) => statement.range[1] < useStatement.range[0]
+        );
+      });
     };
     return {
+      ImportDeclaration(node) {
+        if (!isZodModule(node.source.value)) return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === AST_NODE_TYPES53.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES53.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES53.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES53.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+            const binding = resolvedBinding(specifier.local);
+            if (binding !== null) zodBindings.add(binding);
+          }
+        }
+      },
       CallExpression(node) {
         if (!isFormDataGetCall(node)) return;
         if (hasZodParseAncestor(node) || isInstanceofNarrowing(node)) return;
@@ -13168,8 +13571,8 @@ var require_zod_form_validation_default = createRule({
 // src/rules/store-insert-requires-on-conflict.ts
 import "@typescript-eslint/utils";
 var storeInsertRequiresOnConflictDocumentation = {
-  summary: "Require an embedded SQL INSERT to carry ON CONFLICT; store writes replay under cron re-runs and queue redelivery and must be idempotent upserts.",
-  rationale: "A replayed bare insert can duplicate data or fail on a uniqueness constraint.",
+  summary: "Require embedded inserts in explicitly replayable callables to carry conflict handling.",
+  rationale: "A callable named as an enqueue, seed, migration, schedule, ensure, or upsert promises replay safety.",
   remediation: "Add an appropriate `ON CONFLICT` action or supported replay-safe insert form.",
   category: "correctness",
   examples: [
@@ -13178,7 +13581,25 @@ var storeInsertRequiresOnConflictDocumentation = {
   ]
 };
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
-var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b/i;
+var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b|\bINSERT\b[\s\S]*?\bSELECT\b[\s\S]*?\bWHERE\s+NOT\s+EXISTS\b/i;
+var REPLAY_CONTRACT_NAME = /(?:enqueue|ensure|migrate|recordOnce|schedule|seed|upsert|getOrCreate|createIfAbsent|insertIfAbsent)/i;
+function owningCallableName(node) {
+  for (let current = node.parent; current !== null && current !== void 0; current = current.parent) {
+    if (current.type === "FunctionDeclaration") {
+      return current.id?.name ?? null;
+    }
+    if (current.type === "MethodDefinition") {
+      return current.key.type === "Identifier" ? current.key.name : null;
+    }
+    if ((current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") && current.parent.type === "VariableDeclarator" && current.parent.id.type === "Identifier") {
+      return current.parent.id.name;
+    }
+    if ((current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") && current.parent.type === "Property" && current.parent.key.type === "Identifier") {
+      return current.parent.key.name;
+    }
+  }
+  return null;
+}
 var INSERT_GATE = /insert/i;
 var store_insert_requires_on_conflict_default = createRule({
   name: "store-insert-requires-on-conflict",
@@ -13186,7 +13607,7 @@ var store_insert_requires_on_conflict_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Require an embedded SQL INSERT to carry ON CONFLICT; store writes replay under cron re-runs and queue redelivery and must be idempotent upserts."
+      description: "Require embedded inserts in explicitly replayable callables to carry conflict handling."
     },
     schema: [],
     messages: {
@@ -13202,13 +13623,17 @@ var store_insert_requires_on_conflict_default = createRule({
       if (!INSERT_WRITE.test(sql) || CONFLICT_HANDLED.test(sql)) {
         return;
       }
+      const owner = owningCallableName(node);
+      if (owner !== null && !REPLAY_CONTRACT_NAME.test(owner)) {
+        return;
+      }
       context.report({ node, messageId: "storeInsertRequiresOnConflict" });
     });
   }
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES54, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES54, ASTUtils as ASTUtils15 } 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.",
@@ -13401,7 +13826,7 @@ function methodName(node) {
   return !node.computed && node.key.type === AST_NODE_TYPES54.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES54.Identifier ? ASTUtils13.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES54.Identifier ? ASTUtils15.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
   if (node.object.type !== AST_NODE_TYPES54.ThisExpression && !isClassReference) return null;
   if (node.property.type === AST_NODE_TYPES54.PrivateIdentifier) return `#${node.property.name}`;
@@ -13454,11 +13879,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils13.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils15.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
   if (node.type === AST_NODE_TYPES54.ClassExpression && node.parent.type === AST_NODE_TYPES54.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES54.Identifier) {
-    const outer = ASTUtils13.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    const outer = ASTUtils15.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -13494,7 +13919,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (binding.type !== AST_NODE_TYPES54.Identifier) return;
-      const variable = ASTUtils13.findVariable(context.sourceCode.getScope(binding), binding.name);
+      const variable = ASTUtils15.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
@@ -13524,7 +13949,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES54.Identifier ? ASTUtils13.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES54.Identifier ? ASTUtils15.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
@@ -13608,7 +14033,7 @@ var stepdown_default = createRule({
 // src/rules/zod-naming-convention.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES55,
-  ASTUtils as ASTUtils14
+  ASTUtils as ASTUtils16
 } 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.",
@@ -13695,7 +14120,7 @@ var zod_naming_convention_default = createRule({
     const acceptsSchemaWord = convention !== "prefix";
     const zodBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils14.findVariable(
+      return ASTUtils16.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -13891,7 +14316,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.0.0"
+  version: "15.2.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",