@sarj/eslint-plugin 15.17.16 → 15.17.18

package/dist/index.js

@@ -3,32 +3,32 @@ var LIBRARY_POLICY = [
   {
     "id": "LIB101",
     "module": "request",
-    "note": "Standards standardizes HTTP clients on Ky; review errors, retries, hooks, and response parsing.",
-    "replacement": "ky"
+    "note": "Use the platform-native fetch API; review errors, timeouts, retries, and response parsing during migration.",
+    "replacement": "native fetch"
   },
   {
     "id": "LIB101",
     "module": "node-fetch",
-    "note": "Standards standardizes HTTP clients on Ky; review errors, retries, hooks, and response parsing.",
-    "replacement": "ky"
+    "note": "Use the platform-native fetch API; review errors, timeouts, retries, and response parsing during migration.",
+    "replacement": "native fetch"
   },
   {
     "id": "LIB101",
     "module": "cross-fetch",
-    "note": "Standards standardizes HTTP clients on Ky; review errors, retries, hooks, and response parsing.",
-    "replacement": "ky"
+    "note": "Use the platform-native fetch API; review errors, timeouts, retries, and response parsing during migration.",
+    "replacement": "native fetch"
   },
   {
     "id": "LIB101",
     "module": "isomorphic-fetch",
-    "note": "Standards standardizes HTTP clients on Ky; review errors, retries, hooks, and response parsing.",
-    "replacement": "ky"
+    "note": "Use the platform-native fetch API; review errors, timeouts, retries, and response parsing during migration.",
+    "replacement": "native fetch"
   },
   {
     "id": "LIB101",
     "module": "axios",
-    "note": "Standards standardizes HTTP clients on Ky; review errors, retries, hooks, and response parsing.",
-    "replacement": "ky"
+    "note": "Use the platform-native fetch API; review errors, timeouts, retries, and response parsing during migration.",
+    "replacement": "native fetch"
   },
   {
     "id": "LIB102",
@@ -2507,12 +2507,12 @@ function exportedNextConfigProperty(sourceCode, path) {
 // src/rules/no-dangerously-allow-svg.ts
 var NEXT_CONFIG_RE = /(?:^|\/)next\.config\.[cm]?[jt]s$/;
 var NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION = {
-  summary: "Next.js image configuration enables unsanitized SVG rendering",
+  summary: "Next.js image configuration enables SVG rendering without the required response hardening",
   rationale: "SVG files can contain scripts and other active content; enabling dangerouslyAllowSVG makes the image optimizer serve that content from the application origin.",
-  remediation: "Keep dangerouslyAllowSVG disabled. If SVG delivery is unavoidable, use a separately reviewed asset path with restrictive Content-Disposition and Content-Security-Policy headers.",
+  remediation: "Keep dangerouslyAllowSVG disabled. If SVG optimization is required, retain attachment disposition and set the image Content-Security-Policy to `script-src 'none'; sandbox;`.",
   category: "security",
   limitations: [
-    "Only a literal true in the effective images property of a directly exported object, unescaped const alias, or isolated module.exports object is reported. Wrappers, factories, spreads, computed keys and mutations are not inferred."
+    "Only literal effective properties of a directly exported object, unescaped const alias, or isolated module.exports object are analyzed. Wrappers, factories, spreads, computed keys, dynamic policies and mutations are not inferred."
   ],
   examples: [
     {
@@ -2535,6 +2535,19 @@ var NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION = {
     }
   ]
 };
+function literalString(node) {
+  if (node?.value.type === "Literal" && typeof node.value.value === "string") return node.value.value;
+  if (node?.value.type === "TemplateLiteral" && node.value.expressions.length === 0) return node.value.quasis[0]?.value.cooked ?? null;
+  return null;
+}
+function hasHardenedSvgPolicy(policy) {
+  const directives = policy.split(";").map((part) => part.trim().split(/\s+/u).filter(Boolean)).filter((parts) => parts.length > 0);
+  const scriptSources = directives.filter(([name]) => name?.toLowerCase() === "script-src");
+  const sandboxes = directives.filter(([name]) => name?.toLowerCase() === "sandbox");
+  const scriptSource = scriptSources[0];
+  const sandbox = sandboxes[0];
+  return scriptSources.length === 1 && sandboxes.length === 1 && scriptSource?.length === 2 && scriptSource[1]?.toLowerCase() === "'none'" && sandbox?.length === 1;
+}
 var no_dangerously_allow_svg_default = createRule({
   name: "no-dangerously-allow-svg",
   documentation: NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION,
@@ -2543,7 +2556,7 @@ var no_dangerously_allow_svg_default = createRule({
     docs: { description: NO_DANGEROUSLY_ALLOW_SVG_DOCUMENTATION.summary },
     schema: [],
     messages: {
-      noDangerouslyAllowSvg: "Do not enable dangerouslyAllowSVG. SVG can carry active content served from the application origin."
+      noDangerouslyAllowSvg: "Do not enable dangerouslyAllowSVG without a script-blocking sandbox policy and attachment disposition. SVG can carry active content served from the application origin."
     }
   },
   defaultOptions: [],
@@ -2553,6 +2566,12 @@ var no_dangerously_allow_svg_default = createRule({
       "Program:exit"() {
         const node = exportedNextConfigProperty(context.sourceCode, ["images", "dangerouslyAllowSVG"]);
         if (node !== null && node.value.type === "Literal" && node.value.value === true) {
+          const disposition = exportedNextConfigProperty(context.sourceCode, ["images", "contentDispositionType"]);
+          const policy = literalString(
+            exportedNextConfigProperty(context.sourceCode, ["images", "contentSecurityPolicy"])
+          );
+          const attachmentDisposition = disposition === null || literalString(disposition) === "attachment";
+          if (attachmentDisposition && policy !== null && hasHardenedSvgPolicy(policy)) return;
           context.report({ node, messageId: "noDangerouslyAllowSvg" });
         }
       }
@@ -3671,12 +3690,41 @@ var no_hand_rolled_sleep_default = createRule({
 
 // src/rules/no-hand-rolled-spinner.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
+
+// src/rules/_tailwind.ts
+var tailwindVariantPrefix = (token) => {
+  let bracketDepth = 0;
+  let parenthesisDepth = 0;
+  let escaped = false;
+  let end = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    const character = token[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === "[") bracketDepth += 1;
+    else if (character === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    else if (character === "(") parenthesisDepth += 1;
+    else if (character === ")") parenthesisDepth = Math.max(0, parenthesisDepth - 1);
+    else if (character === ":" && bracketDepth === 0 && parenthesisDepth === 0) end = index + 1;
+  }
+  return token.slice(0, end);
+};
+var tailwindBase = (token) => token.slice(tailwindVariantPrefix(token).length).replace(/^!/, "");
+var classTokens = (value) => value.split(/\s+/).filter(Boolean);
+
+// src/rules/no-hand-rolled-spinner.ts
 var NO_HAND_ROLLED_SPINNER_DOCUMENTATION = {
   summary: "Disallow intrinsic elements styled as Tailwind border-ring spinners outside the design-system implementation.",
   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 effective static className values on div and span elements are inspected; a later spread makes the value unknown. Tests, stories, generated files, and the design-system implementation are excluded."],
+  limitations: ["Only effective static className values on div and span elements are inspected; Tailwind utilities are combined only when they are unprefixed or share one exact variant context, while a later spread makes the value unknown. 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 }
@@ -3702,6 +3750,10 @@ function isContrastingEdge(token) {
   const match = DIRECTIONAL_BORDER.exec(token);
   return match?.[2] !== void 0 && !isBorderWidthValue(match[2]);
 }
+function hasSpinnerInVariant(classes, variant) {
+  const effective = classes.filter((entry) => entry.variant === "" || entry.variant === variant).map((entry) => entry.base);
+  return effective.includes("animate-spin") && effective.includes("rounded-full") && effective.some(isBorderWidth) && effective.some(isContrastingEdge);
+}
 function staticClassName(attribute) {
   const value = attribute.value;
   if (value?.type === AST_NODE_TYPES14.Literal && typeof value.value === "string") {
@@ -3744,8 +3796,12 @@ var no_hand_rolled_spinner_default = createRule({
         if (classNameAttribute?.type !== AST_NODE_TYPES14.JSXAttribute) return;
         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(isBorderWidth) && classes.some(isContrastingEdge)) {
+        const classes = className.split(/\s+/u).filter(Boolean).map((token) => ({
+          base: tailwindBase(token),
+          variant: tailwindVariantPrefix(token)
+        }));
+        const variants = new Set(classes.map((entry) => entry.variant));
+        if ([...variants].some((variant) => hasSpinnerInVariant(classes, variant))) {
           context.report({ node, messageId: "handRolledSpinner" });
         }
       }
@@ -3986,33 +4042,36 @@ var no_insecure_random_id_default = createRule({
 });
 
 // src/rules/no-detached-global-fetch.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15, ASTUtils as ASTUtils7 } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES15,
+  ASTUtils as ASTUtils7
+} from "@typescript-eslint/utils";
 var NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION = {
-  summary: "Preserve the receiver when the ambient global fetch is used as a value.",
-  rationale: "Some host runtimes expose fetch as a receiver-sensitive callable, so storing or passing the bare function can fail only after deployment.",
-  remediation: "Forward through `(input, init) => globalThis.fetch(input, init)` or bind the callable to its global receiver.",
+  summary: "Keep the ambient global fetch receiver-safe when storing or explicitly rebinding it.",
+  rationale: "Calling a raw ambient fetch through a class or object property supplies that object as `this`; receiver-sensitive hosts can reject that invocation only after deployment.",
+  remediation: "Store a forwarding wrapper such as `(input, init) => fetch(input, init)`, or bind the callable to a compatible global or undefined receiver before storing it.",
   category: "correctness",
   autofix: "none",
   limitations: [
-    "The rule recognizes the unshadowed ambient fetch, globalThis.fetch, self.fetch, and window.fetch syntactically.",
-    "Direct calls, explicit receiver binding or invocation, tests, scripts, generated files, and locally defined fetch implementations are excluded.",
-    "The rule does not follow aliases or prove which JavaScript host executes a file."
+    "The rule follows stable local variables and defaulted parameters from an unshadowed ambient fetch or globalThis/self/window fetch into direct class, object, or member storage.",
+    "Bare local aliases, callback arguments, returns, direct calls, compatible global or undefined bind/call/apply receivers, tests, scripts, generated files, and locally defined fetch implementations are excluded.",
+    "Interprocedural aliases, mutable aliases, collection storage, and host identity remain manual review boundaries."
   ],
   examples: [
     {
       id: "forwarded-global-fetch",
-      title: "Forward through the global receiver",
+      title: "Store a receiver-safe forwarding wrapper",
       outcome: "no-match",
-      files: [{ path: "src/client.ts", source: "const request = (input: RequestInfo | URL, init?: RequestInit) => globalThis.fetch(input, init);" }],
+      files: [{ path: "src/client.ts", source: "class Client { readonly request = (input: RequestInfo | URL, init?: RequestInit) => fetch(input, init); }" }],
       focusPath: "src/client.ts",
       expectedCount: 0,
       public: true
     },
     {
-      id: "detached-global-fetch",
-      title: "Do not detach the ambient fetch",
+      id: "receiver-unsafe-global-fetch",
+      title: "Do not store raw ambient fetch as an object method",
       outcome: "match",
-      files: [{ path: "src/client.ts", source: "class Client { constructor(private readonly request: typeof fetch = fetch) {} }" }],
+      files: [{ path: "src/client.ts", source: "class Client { readonly request = fetch; }" }],
       focusPath: "src/client.ts",
       expectedCount: 1,
       public: true
@@ -4020,85 +4079,131 @@ var NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION = {
   ]
 };
 var GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
-var RECEIVER_METHODS = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
+var EXPLICIT_RECEIVER_METHODS = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
+var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
+function unwrapExpression(node) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES15.ChainExpression || current.type === AST_NODE_TYPES15.TSAsExpression || current.type === AST_NODE_TYPES15.TSNonNullExpression || current.type === AST_NODE_TYPES15.TSTypeAssertion) {
+    current = current.expression;
+  }
+  return current;
+}
 var no_detached_global_fetch_default = createRule({
   name: "no-detached-global-fetch",
   documentation: NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION,
   meta: {
     type: "problem",
-    docs: { description: "Preserve the receiver when the ambient global fetch is used as a value." },
+    docs: { description: NO_DETACHED_GLOBAL_FETCH_DOCUMENTATION.summary },
     schema: [],
     messages: {
-      detachedGlobalFetch: "The ambient global `fetch` is being detached from its receiver. Forward through `globalThis.fetch(...)` or bind it to the global receiver."
+      detachedGlobalFetch: "Raw ambient `fetch` becomes receiver-unsafe when stored or rebound this way. Store a forwarding wrapper or bind it to a compatible global or undefined receiver."
     }
   },
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
-    if (isTestFile(context.filename) || isScriptFile(context.filename) || isGeneratedFile(context.filename, sourceCode.text)) {
-      return {};
+    if (isTestFile(context.filename) || isScriptFile(context.filename) || isGeneratedFile(context.filename, sourceCode.text)) return {};
+    const aliases = /* @__PURE__ */ new Set();
+    function bindingOf(identifier) {
+      return ASTUtils7.findVariable(sourceCode.getScope(identifier), identifier.name);
     }
     function resolvesToGlobal(identifier) {
-      const variable = ASTUtils7.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = bindingOf(identifier);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalReceiver(node) {
       return node.type === AST_NODE_TYPES15.Identifier && GLOBAL_RECEIVERS.has(node.name) && resolvesToGlobal(node);
     }
-    function isTypePosition(node) {
-      let parent = node.parent;
-      while (parent !== void 0) {
-        if (parent.type === AST_NODE_TYPES15.TSTypeQuery) return true;
-        if (!parent.type.startsWith("TS")) return false;
-        parent = parent.parent;
-      }
-      return false;
+    function isStableAlias(variable) {
+      return !variable.references.some(
+        (reference) => reference.isWrite() && reference.init !== true
+      );
     }
-    function receiverOf(node) {
-      if (node.type === AST_NODE_TYPES15.Identifier) return null;
-      return isGlobalReceiver(node.object) ? node.object : null;
+    function recordAlias(identifier) {
+      const variable = bindingOf(identifier);
+      if (variable !== null && isStableAlias(variable)) aliases.add(variable);
     }
-    function isDirectCall(node) {
-      return node.parent.type === AST_NODE_TYPES15.CallExpression && node.parent.callee === node;
+    function isGlobalFetchMember(node) {
+      if (!isGlobalReceiver(node.object)) return false;
+      if (!node.computed) {
+        return node.property.type === AST_NODE_TYPES15.Identifier && node.property.name === "fetch";
+      }
+      return node.property.type === AST_NODE_TYPES15.Literal && node.property.value === "fetch";
     }
-    function isSafeExplicitReceiverUse(node) {
-      const member = node.parent;
-      if (member.type !== AST_NODE_TYPES15.MemberExpression || member.object !== node || member.computed || member.property.type !== AST_NODE_TYPES15.Identifier || !RECEIVER_METHODS.has(member.property.name)) {
-        return false;
+    function staticMemberName9(node) {
+      if (!node.computed) {
+        return node.property.type === AST_NODE_TYPES15.Identifier ? node.property.name : null;
       }
-      const invocation = member.parent;
-      if (invocation.type !== AST_NODE_TYPES15.CallExpression || invocation.callee !== member) {
-        return false;
+      return node.property.type === AST_NODE_TYPES15.Literal && typeof node.property.value === "string" ? node.property.value : null;
+    }
+    function mayBeRawFetch(node) {
+      const expression = unwrapExpression(node);
+      if (expression.type === AST_NODE_TYPES15.Identifier) {
+        if (expression.name === "fetch" && resolvesToGlobal(expression)) return true;
+        const variable = bindingOf(expression);
+        return variable !== null && aliases.has(variable) && isStableAlias(variable);
       }
-      const receiver = invocation.arguments[0];
-      if (receiver === void 0 || receiver.type === AST_NODE_TYPES15.SpreadElement) return false;
-      if (node.type === AST_NODE_TYPES15.MemberExpression) {
-        const original = receiverOf(node);
-        return original !== null && receiver.type === AST_NODE_TYPES15.Identifier && receiver.name === original.name;
+      if (expression.type === AST_NODE_TYPES15.MemberExpression) {
+        return isGlobalFetchMember(expression);
       }
-      return isGlobalReceiver(receiver);
+      if (expression.type === AST_NODE_TYPES15.LogicalExpression) {
+        return expression.operator === "&&" ? mayBeRawFetch(expression.right) : mayBeRawFetch(expression.left) || mayBeRawFetch(expression.right);
+      }
+      if (expression.type === AST_NODE_TYPES15.ConditionalExpression) {
+        return mayBeRawFetch(expression.consequent) || mayBeRawFetch(expression.alternate);
+      }
+      if (expression.type === AST_NODE_TYPES15.SequenceExpression) {
+        const last = expression.expressions.at(-1);
+        return last !== void 0 && mayBeRawFetch(last);
+      }
+      return false;
+    }
+    function recordAliasFromValue(identifier, value) {
+      if (mayBeRawFetch(value)) recordAlias(identifier);
+    }
+    function reportStored(node) {
+      if (mayBeRawFetch(node)) context.report({ node, messageId: "detachedGlobalFetch" });
     }
-    function reportIfDetached(node) {
-      if (isTypePosition(node) || isDirectCall(node) || isSafeExplicitReceiverUse(node)) return;
-      context.report({ node, messageId: "detachedGlobalFetch" });
+    function isCompatibleReceiver(node) {
+      if (node === void 0 || node.type === AST_NODE_TYPES15.SpreadElement) return false;
+      if (node.type !== AST_NODE_TYPES15.Identifier || !resolvesToGlobal(node)) return false;
+      return GLOBAL_RECEIVERS.has(node.name) || node.name === "undefined";
     }
     return {
-      Identifier(node) {
-        if (node.name !== "fetch" || !resolvesToGlobal(node)) return;
-        const parent = node.parent;
-        if (parent.type === AST_NODE_TYPES15.MemberExpression && parent.property === node) {
-          return;
-        }
-        if (parent.type === AST_NODE_TYPES15.Property && parent.key === node && !parent.computed && !parent.shorthand) {
-          return;
+      AssignmentExpression(node) {
+        if (STORAGE_ASSIGNMENT_OPERATORS.has(node.operator) && node.left.type === AST_NODE_TYPES15.MemberExpression) {
+          reportStored(node.right);
         }
-        reportIfDetached(node);
       },
-      "MemberExpression[computed=false]"(node) {
-        if (node.property.type !== AST_NODE_TYPES15.Identifier || node.property.name !== "fetch" || !isGlobalReceiver(node.object)) {
+      AssignmentPattern(node) {
+        if (node.left.type !== AST_NODE_TYPES15.Identifier) return;
+        recordAliasFromValue(node.left, node.right);
+        if (node.parent.type === AST_NODE_TYPES15.TSParameterProperty) reportStored(node.right);
+      },
+      CallExpression(node) {
+        const callee = unwrapExpression(node.callee);
+        if (callee.type !== AST_NODE_TYPES15.MemberExpression || !EXPLICIT_RECEIVER_METHODS.has(staticMemberName9(callee) ?? "") || !mayBeRawFetch(callee.object) || isCompatibleReceiver(node.arguments[0])) return;
+        context.report({ node: callee.object, messageId: "detachedGlobalFetch" });
+      },
+      Property(node) {
+        if (node.parent.type === AST_NODE_TYPES15.ObjectPattern || node.method || node.value.type === AST_NODE_TYPES15.AssignmentPattern || node.value.type === AST_NODE_TYPES15.TSEmptyBodyFunctionExpression) return;
+        reportStored(node.value);
+      },
+      PropertyDefinition(node) {
+        if (node.value !== null) reportStored(node.value);
+      },
+      VariableDeclarator(node) {
+        if (node.init === null) return;
+        if (node.id.type === AST_NODE_TYPES15.Identifier) {
+          recordAliasFromValue(node.id, node.init);
           return;
         }
-        reportIfDetached(node);
+        if (node.id.type !== AST_NODE_TYPES15.ObjectPattern || !isGlobalReceiver(unwrapExpression(node.init))) return;
+        for (const property of node.id.properties) {
+          if (property.type !== AST_NODE_TYPES15.Property || property.computed || property.key.type !== AST_NODE_TYPES15.Identifier || property.key.name !== "fetch") continue;
+          const value = property.value.type === AST_NODE_TYPES15.AssignmentPattern ? property.value.left : property.value;
+          if (value.type === AST_NODE_TYPES15.Identifier) recordAlias(value);
+        }
       }
     };
   }
@@ -4364,7 +4469,7 @@ var NO_JSON_STRINGIFY_OBJECT_EQUALITY_DOCUMENTATION = {
 };
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["!=", "!==", "==", "==="]);
 var PRIMITIVE_FLAGS = ts.TypeFlags.BigIntLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Never | ts.TypeFlags.Null | ts.TypeFlags.NumberLike | ts.TypeFlags.StringLike | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
-function unwrapExpression(node) {
+function unwrapExpression2(node) {
   let current = node;
   while (current.type === AST_NODE_TYPES16.ChainExpression || current.type === AST_NODE_TYPES16.TSAsExpression || current.type === AST_NODE_TYPES16.TSNonNullExpression || current.type === AST_NODE_TYPES16.TSTypeAssertion) {
     current = current.expression;
@@ -4372,10 +4477,10 @@ function unwrapExpression(node) {
   return current;
 }
 function jsonStringifyArgument(node, sourceCode) {
-  const expression = unwrapExpression(node);
+  const expression = unwrapExpression2(node);
   if (expression.type !== AST_NODE_TYPES16.CallExpression) return null;
   const { callee } = expression;
-  if (callee.type !== AST_NODE_TYPES16.MemberExpression || callee.computed || callee.object.type !== AST_NODE_TYPES16.Identifier || callee.object.name !== "JSON" || callee.property.type !== AST_NODE_TYPES16.Identifier || callee.property.name !== "stringify") {
+  if (callee.type !== AST_NODE_TYPES16.MemberExpression || callee.object.type !== AST_NODE_TYPES16.Identifier || callee.object.name !== "JSON" || (!callee.computed ? callee.property.type !== AST_NODE_TYPES16.Identifier || callee.property.name !== "stringify" : callee.property.type !== AST_NODE_TYPES16.Literal || callee.property.value !== "stringify")) {
     return null;
   }
   const variable = ASTUtils9.findVariable(sourceCode.getScope(callee.object), "JSON");
@@ -4403,7 +4508,7 @@ function typeMayContainObject(type, checker) {
   return true;
 }
 function syntaxMayContainObject(node) {
-  const expression = unwrapExpression(node);
+  const expression = unwrapExpression2(node);
   if (expression.type === AST_NODE_TYPES16.ObjectExpression) return true;
   if (expression.type !== AST_NODE_TYPES16.ArrayExpression) return null;
   for (const element of expression.elements) {
@@ -5043,7 +5148,7 @@ var INTERFACE_CONTRACT_MEMBERS_PRIVATE_DOCUMENTATION = {
   category: "architecture",
   autofix: "none",
   limitations: [
-    "Only concrete classes with an explicit `implements` clause are checked; constructors and static members are excluded.",
+    "Only concrete classes with an explicit `implements` clause are checked; constructors, static members, protected extension hooks, and overrides are excluded.",
     "Inherited interface members are resolved by TypeScript. Computed names are excluded because their contract identity is not stable syntax.",
     "The rule abstains for the whole class when TypeScript cannot resolve any implemented contract, avoiding false positives for missing or unavailable package declarations.",
     "The rule is report-only because a public member can have consumers in another source file; the developer must choose whether to extend the interface or privatize it.",
@@ -5095,7 +5200,7 @@ function reportClass(context, services, owner) {
   }
 }
 function candidate(member) {
-  return member.type === AST_NODE_TYPES20.MethodDefinition && member.kind !== "constructor" && !member.static && !member.computed && member.key.type === AST_NODE_TYPES20.Identifier && member.value.body !== null;
+  return member.type === AST_NODE_TYPES20.MethodDefinition && member.kind !== "constructor" && !member.static && member.accessibility !== "protected" && !member.override && !member.computed && member.key.type === AST_NODE_TYPES20.Identifier && member.value.body !== null;
 }
 function interfaceNames(services, owner) {
   const tsOwner = services.esTreeNodeToTSNodeMap.get(owner);
@@ -5453,7 +5558,7 @@ var NO_BARE_RETURN_FROM_TEST_CATCH_DOCUMENTATION = {
   remediation: "Rethrow the error, assert on it, or use the runner's explicit skip mechanism when the capability is optional.",
   category: "testing",
   filePatterns: ["**/*.test.*", "**/*.spec.*", "**/tests/**", "**/__tests__/**"],
-  limitations: ["Only bare returns owned by a direct supported test callback and followed lexically by a framework assertion are reported."],
+  limitations: ["Only bare returns owned by a direct supported test callback and followed lexically by a framework assertion are reported. A runner skip suppresses the finding only when it is an unconditional earlier statement in the return's block."],
   examples: [
     { id: "rethrow", title: "Preserve the failure", outcome: "no-match", files: [{ path: "src/codec.test.ts", source: "test('decodes', () => { try { decode(); } catch (error) { throw error; } expect(result()).toBe('ok'); });" }], focusPath: "src/codec.test.ts", expectedCount: 0, public: true },
     { id: "bare-return", title: "Do not silently pass", outcome: "match", files: [{ path: "src/codec.test.ts", source: "test('decodes', () => { try { decode(); } catch { return; } expect(result()).toBe('ok'); });" }], focusPath: "src/codec.test.ts", expectedCount: 1, public: true }
@@ -5474,10 +5579,11 @@ function importedName4(identifier, context, modules) {
   const variable = ASTUtils11.findVariable(context.sourceCode.getScope(identifier), identifier.name);
   if (variable === null || variable.defs.length === 0) return identifier.name;
   for (const definition of variable.defs) {
-    if (definition.node.type !== AST_NODE_TYPES22.ImportSpecifier) continue;
+    if (definition.node.type !== AST_NODE_TYPES22.ImportSpecifier && definition.node.type !== AST_NODE_TYPES22.ImportDefaultSpecifier && definition.node.type !== AST_NODE_TYPES22.ImportNamespaceSpecifier) continue;
     const declaration = definition.node.parent;
     if (declaration.type !== AST_NODE_TYPES22.ImportDeclaration || typeof declaration.source.value !== "string" || !modules.has(declaration.source.value)) continue;
     if (declaration.source.value === "node:assert" || declaration.source.value === "node:assert/strict") return "assert";
+    if (definition.node.type !== AST_NODE_TYPES22.ImportSpecifier) continue;
     const imported = definition.node.imported;
     return imported.type === AST_NODE_TYPES22.Identifier ? imported.name : String(imported.value);
   }
@@ -5529,6 +5635,13 @@ function isExplicitSkip(node, context) {
   const root = rootIdentifier2(node.callee.object);
   return root !== null && TEST_NAMES.has(importedName4(root, context, TEST_MODULES2) ?? "");
 }
+function hasDominatingExplicitSkip(node, context) {
+  const block = node.parent;
+  if (block?.type !== AST_NODE_TYPES22.BlockStatement) return false;
+  return block.body.some(
+    (candidate2) => candidate2.range[1] <= node.range[0] && candidate2.type === AST_NODE_TYPES22.ExpressionStatement && isExplicitSkip(candidate2.expression, context)
+  );
+}
 var no_bare_return_from_test_catch_default = createRule({
   name: "no-bare-return-from-test-catch",
   documentation: NO_BARE_RETURN_FROM_TEST_CATCH_DOCUMENTATION,
@@ -5554,11 +5667,12 @@ var no_bare_return_from_test_catch_default = createRule({
           }
           if (current === null || current === void 0) break;
         }
-        if (catchClause === null || catchClause.parent.finalizer !== null) return;
+        if (catchClause === null) return;
         const parameter = catchClause.param;
-        if (parameter?.type === AST_NODE_TYPES22.Identifier && node.parent === catchClause.body) {
+        const returnBlock = node.parent;
+        if (parameter?.type === AST_NODE_TYPES22.Identifier && returnBlock?.type === AST_NODE_TYPES22.BlockStatement) {
           const errorBinding = ASTUtils11.findVariable(context.sourceCode.getScope(parameter), parameter.name);
-          const assertedError = catchClause.body.body.some((statement) => {
+          const assertedError = returnBlock.body.some((statement) => {
             if (statement.range[1] >= node.range[0] || statement.type !== AST_NODE_TYPES22.ExpressionStatement) return false;
             const expression = statement.expression;
             if (expression.type !== AST_NODE_TYPES22.CallExpression || !isAssertion(expression, context)) return false;
@@ -5572,7 +5686,7 @@ var no_bare_return_from_test_catch_default = createRule({
           });
           if (assertedError) return;
         }
-        if (walkOwnScope(catchClause.body, (current) => current.type === AST_NODE_TYPES22.ThrowStatement || isExplicitSkip(current, context))) return;
+        if (hasDominatingExplicitSkip(node, context)) return;
         if (!walkOwnScope(owner.body, (current) => current.range[0] > node.range[1] && isAssertion(current, context))) return;
         context.report({ node, messageId: "bareReturnFromTestCatch" });
       }
@@ -5810,7 +5924,8 @@ var no_long_comment_default = createRule({
 });
 
 // src/rules/no-vague-suppression-description.ts
-var DIRECTIVE_WITH_DESCRIPTION_RE = /^(?:eslint-(?:disable|disable-next-line|disable-line)\b[^:\n]*?|@ts-expect-error\b)\s*(?::|--)\s*(.+?)\s*$/iu;
+var ESLINT_DIRECTIVE_WITH_DESCRIPTION_RE = /^eslint-(?:disable|disable-next-line|disable-line)\b[^:\n]*?\s*(?::|--)\s*(.+?)\s*$/iu;
+var TS_EXPECT_ERROR_WITH_DESCRIPTION_RE = /^@ts-expect-error\b(?:(?:\s*(?::|--)\s*)|\s+)(.+?)\s*$/iu;
 var VAGUE_RE = /^(?:needed|required|intentional(?:ly)?|ignore(?:d)?|false positive|type error|typescript|to satisfy (?:the )?(?:linter|typescript|type checker))\.?$/iu;
 var NO_VAGUE_SUPPRESSION_DESCRIPTION_DOCUMENTATION = {
   summary: "Require suppression descriptions to name the concrete mismatch or invariant instead of a generic non-reason.",
@@ -5853,6 +5968,9 @@ var NO_VAGUE_SUPPRESSION_DESCRIPTION_DOCUMENTATION = {
     }
   ]
 };
+function suppressionDescription(text) {
+  return (ESLINT_DIRECTIVE_WITH_DESCRIPTION_RE.exec(text)?.[1] ?? TS_EXPECT_ERROR_WITH_DESCRIPTION_RE.exec(text)?.[1])?.trim();
+}
 var no_vague_suppression_description_default = createRule({
   name: "no-vague-suppression-description",
   documentation: NO_VAGUE_SUPPRESSION_DESCRIPTION_DOCUMENTATION,
@@ -5875,7 +5993,7 @@ var no_vague_suppression_description_default = createRule({
       Program() {
         for (const comment of context.sourceCode.getAllComments()) {
           const text = comment.value.trim();
-          const description = DIRECTIVE_WITH_DESCRIPTION_RE.exec(text)?.[1]?.trim();
+          const description = suppressionDescription(text);
           if (description === void 0 || !VAGUE_RE.test(description)) continue;
           context.report({
             loc: comment.loc,
@@ -6939,12 +7057,24 @@ var NO_RESTRICTED_LIBRARY_LOAD_DOCUMENTATION = {
     { id: "runtime-load", title: "Do not load a restricted library at runtime", outcome: "match", files: [{ path: "src/client.ts", source: "const client = require('axios');" }], focusPath: "src/client.ts", expectedCount: 1, public: true }
   ]
 };
-function literalModule(node) {
-  return node?.type === AST_NODE_TYPES28.Literal && typeof node.value === "string" ? node.value : null;
+function staticModule(node) {
+  if (node?.type === AST_NODE_TYPES28.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node?.type === AST_NODE_TYPES28.TemplateLiteral && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
 }
 function matchesModule(source, module) {
   return source === module || source.startsWith(`${module}/`);
 }
+function staticMemberName4(node) {
+  if (!node.computed && node.property.type === AST_NODE_TYPES28.Identifier) {
+    return node.property.name;
+  }
+  return node.computed && node.property.type === AST_NODE_TYPES28.Literal && typeof node.property.value === "string" ? node.property.value : null;
+}
 var no_restricted_library_load_default = createRule({
   name: "no-restricted-library-load",
   documentation: NO_RESTRICTED_LIBRARY_LOAD_DOCUMENTATION,
@@ -7008,24 +7138,24 @@ var no_restricted_library_load_default = createRule({
     }
     return {
       ImportExpression(node) {
-        const source = literalModule(node.source);
+        const source = staticModule(node.source);
         if (source !== null) report2(node.source, source);
       },
       CallExpression(node) {
         let requireIdentifier = null;
         if (node.callee.type === AST_NODE_TYPES28.Identifier && node.callee.name === "require") {
           requireIdentifier = node.callee;
-        } else if (node.callee.type === AST_NODE_TYPES28.MemberExpression && !node.callee.computed && node.callee.object.type === AST_NODE_TYPES28.Identifier && node.callee.object.name === "require" && node.callee.property.type === AST_NODE_TYPES28.Identifier && node.callee.property.name === "resolve") {
+        } else if (node.callee.type === AST_NODE_TYPES28.MemberExpression && node.callee.object.type === AST_NODE_TYPES28.Identifier && node.callee.object.name === "require" && staticMemberName4(node.callee) === "resolve") {
           requireIdentifier = node.callee.object;
         }
         if (requireIdentifier === null || !isUnshadowedRequire(requireIdentifier)) return;
-        const source = literalModule(node.arguments[0]);
+        const source = staticModule(node.arguments[0]);
         if (source !== null) report2(node.arguments[0], source);
       },
       TSImportEqualsDeclaration(node) {
         if (node.importKind === "type") return;
         if (node.moduleReference.type !== AST_NODE_TYPES28.TSExternalModuleReference) return;
-        const source = literalModule(node.moduleReference.expression);
+        const source = staticModule(node.moduleReference.expression);
         if (source !== null) report2(node.moduleReference.expression, source);
       }
     };
@@ -11072,7 +11202,7 @@ function rootIdentifier3(callee) {
   if (callee.type === AST_NODE_TYPES45.TaggedTemplateExpression) return rootIdentifier3(callee.tag);
   return null;
 }
-function staticMemberName4(member) {
+function staticMemberName5(member) {
   if (!member.computed && member.property.type === AST_NODE_TYPES45.Identifier) return member.property.name;
   if (member.computed && member.property.type === AST_NODE_TYPES45.Literal && typeof member.property.value === "string") {
     return member.property.value;
@@ -11087,7 +11217,7 @@ function isTestBody2(node, isFrameworkTest) {
 function isTestCaller(callee) {
   if (callee.type === AST_NODE_TYPES45.Identifier) return TEST_CALLERS3.has(callee.name);
   if (callee.type !== AST_NODE_TYPES45.MemberExpression) return false;
-  const member = staticMemberName4(callee);
+  const member = staticMemberName5(callee);
   return member !== null && TEST_MODIFIERS3.has(member) && isTestCaller(callee.object);
 }
 function nearestEnclosingFunction2(node) {
@@ -11168,7 +11298,7 @@ function opensSubtest(node, callbackParameters) {
     return false;
   }
   const callee = node.callee;
-  return callee.type === AST_NODE_TYPES45.MemberExpression && staticMemberName4(callee) === "test" && callee.object.type === AST_NODE_TYPES45.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
+  return callee.type === AST_NODE_TYPES45.MemberExpression && staticMemberName5(callee) === "test" && callee.object.type === AST_NODE_TYPES45.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
     (argument) => argument.type !== AST_NODE_TYPES45.SpreadElement && FUNCTION_TYPES6.has(argument.type)
   );
 }
@@ -11218,7 +11348,7 @@ var test_loops_over_literal_cases_default = createRule({
         for (let current = node; current !== void 0 && current !== enclosing; current = current.parent) {
           if (current.parent?.type === AST_NODE_TYPES45.BlockStatement && current.parent.body.at(-1) !== current) return;
         }
-        const cases = unwrapExpression2(node.right);
+        const cases = unwrapExpression3(node.right);
         const callbackParameters = new Set(
           enclosing.params.flatMap((parameter) => parameter.type === AST_NODE_TYPES45.Identifier ? [parameter.name] : [])
         );
@@ -11246,9 +11376,9 @@ var test_loops_over_literal_cases_default = createRule({
     };
   }
 });
-function unwrapExpression2(node) {
+function unwrapExpression3(node) {
   if (node.type === AST_NODE_TYPES45.TSAsExpression || node.type === AST_NODE_TYPES45.TSTypeAssertion || node.type === AST_NODE_TYPES45.TSSatisfiesExpression || node.type === AST_NODE_TYPES45.TSNonNullExpression) {
-    return unwrapExpression2(node.expression);
+    return unwrapExpression3(node.expression);
   }
   return node;
 }
@@ -12041,14 +12171,14 @@ function isAsConst(node, sourceText) {
   if (node.type !== AST_NODE_TYPES52.TSAsExpression) return false;
   return sourceText(node.typeAnnotation).trim() === "const";
 }
-function unwrapExpression3(node) {
+function unwrapExpression4(node) {
   if (node.type === AST_NODE_TYPES52.TSAsExpression || node.type === AST_NODE_TYPES52.TSSatisfiesExpression || node.type === AST_NODE_TYPES52.TSNonNullExpression) {
-    return unwrapExpression3(node.expression);
+    return unwrapExpression4(node.expression);
   }
   return node;
 }
 function isObjectFreeze(node, isUnshadowedGlobal3) {
-  const inner = unwrapExpression3(node);
+  const inner = unwrapExpression4(node);
   if (inner.type === AST_NODE_TYPES52.CallExpression && inner.callee.type === AST_NODE_TYPES52.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES52.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal3(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES52.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
     const argument = inner.arguments[0];
     return argument !== void 0 && argument.type !== AST_NODE_TYPES52.SpreadElement && collectionKind(argument, isUnshadowedGlobal3) === "literal";
@@ -12056,7 +12186,7 @@ function isObjectFreeze(node, isUnshadowedGlobal3) {
   return false;
 }
 function collectionKind(node, isUnshadowedGlobal3) {
-  const inner = unwrapExpression3(node);
+  const inner = unwrapExpression4(node);
   if (inner.type === AST_NODE_TYPES52.CallExpression && inner.callee.type === AST_NODE_TYPES52.MemberExpression && !inner.callee.computed && inner.callee.object.type === AST_NODE_TYPES52.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal3(inner.callee.object) && inner.callee.property.type === AST_NODE_TYPES52.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== AST_NODE_TYPES52.SpreadElement) {
     return collectionKind(inner.arguments[0], isUnshadowedGlobal3);
   }
@@ -15497,17 +15627,18 @@ var prefer_schema_for_api_payload_default = createRule({
 // src/rules/prefer-shared-zod-enum.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES67, ASTUtils as ASTUtils38 } from "@typescript-eslint/utils";
 var PREFER_SHARED_ZOD_ENUM_DOCUMENTATION = {
-  summary: "Give literal Zod enum domains one reusable module-level schema.",
-  rationale: "Inline or repeated literal domains hide a reusable contract and allow equivalent fields to drift independently.",
+  summary: "Give repeated literal Zod enum domains one reusable module-level schema.",
+  rationale: "Repeated literal domains hide a shared contract and allow equivalent fields to drift independently.",
   remediation: "Declare a module-level named Zod enum schema and reuse it at each field or contract site.",
   category: "maintainability",
-  limitations: ["Only direct z.enum calls with string-literal arrays are inspected; computed domains require review. Equal values do not prove a shared business domain: retain local schemas when ownership, error customization, or future evolution differs, and review initialization order before extraction."],
+  limitations: ["Only two or more exact, same-order direct z.enum calls with string-literal arrays and no customization argument in one module are inspected; one-off, computed, and customized domains require review. Equal values do not prove a shared business domain: retain local schemas when ownership or future evolution differs, and review initialization order before extraction."],
   examples: [
     { id: "shared-provider", title: "Reuse a named enum schema", outcome: "no-match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const ProviderSchema = z.enum(['agy', 'claude', 'sol']); const JobSchema = z.object({ provider: ProviderSchema }); const StatusSchema = z.object({ provider: ProviderSchema.optional() });" }], focusPath: "src/provider.ts", expectedCount: 0, public: true },
-    { id: "inline-provider", title: "Do not inline enum domains in object fields", outcome: "match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const JobSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']) });" }], focusPath: "src/provider.ts", expectedCount: 1, public: true }
+    { id: "inline-provider", title: "Do not repeat an inline enum domain", outcome: "match", files: [{ path: "src/provider.ts", source: "import { z } from 'zod'; const JobSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']) }); const StatusSchema = z.object({ provider: z.enum(['agy', 'claude', 'sol']).optional() });" }], focusPath: "src/provider.ts", expectedCount: 2, public: true }
   ]
 };
 function literalDomain(node) {
+  if (node.arguments.length !== 1) return null;
   const [argument] = node.arguments;
   if (argument?.type !== AST_NODE_TYPES67.ArrayExpression || argument.elements.length < 2) return null;
   const values = [];
@@ -15533,7 +15664,7 @@ var prefer_shared_zod_enum_default = createRule({
   documentation: PREFER_SHARED_ZOD_ENUM_DOCUMENTATION,
   meta: {
     type: "suggestion",
-    docs: { description: "Give literal Zod enum domains one reusable module-level schema." },
+    docs: { description: PREFER_SHARED_ZOD_ENUM_DOCUMENTATION.summary },
     schema: [],
     messages: {
       shareEnumDomain: "Extract this literal Zod enum to one module-level named schema and reuse it."
@@ -15544,7 +15675,7 @@ var prefer_shared_zod_enum_default = createRule({
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     const zodBindings = /* @__PURE__ */ new Set();
     const bindingOf = (node) => ASTUtils38.findVariable(context.sourceCode.getScope(node), node.name);
-    const seen = /* @__PURE__ */ new Set();
+    const candidates = /* @__PURE__ */ new Map();
     return {
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
@@ -15562,10 +15693,19 @@ var prefer_shared_zod_enum_default = createRule({
         const domain = literalDomain(node);
         if (domain === null) return;
         const key = JSON.stringify(domain);
-        const inline = !isModuleLevelNamedSchema(node);
-        if (inline || seen.has(key))
-          context.report({ node, messageId: "shareEnumDomain" });
-        else seen.add(key);
+        const group = candidates.get(key) ?? [];
+        group.push({ node, named: isModuleLevelNamedSchema(node) });
+        candidates.set(key, group);
+      },
+      "Program:exit"() {
+        for (const group of candidates.values()) {
+          if (group.length < 2) continue;
+          const canonical = group.find((candidate2) => candidate2.named);
+          for (const candidate2 of group) {
+            if (candidate2 === canonical) continue;
+            context.report({ node: candidate2.node, messageId: "shareEnumDomain" });
+          }
+        }
       }
     };
   }
@@ -15640,35 +15780,6 @@ var prefer_switch_for_repeated_equality_default = createRule({
 import { AST_NODE_TYPES as AST_NODE_TYPES69 } from "@typescript-eslint/utils";
 import { existsSync as existsSync2, lstatSync as lstatSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname2, join as join2, parse } from "path";
-
-// src/rules/_tailwind.ts
-var tailwindVariantPrefix = (token) => {
-  let bracketDepth = 0;
-  let parenthesisDepth = 0;
-  let escaped = false;
-  let end = 0;
-  for (let index = 0; index < token.length; index += 1) {
-    const character = token[index];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (character === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (character === "[") bracketDepth += 1;
-    else if (character === "]") bracketDepth = Math.max(0, bracketDepth - 1);
-    else if (character === "(") parenthesisDepth += 1;
-    else if (character === ")") parenthesisDepth = Math.max(0, parenthesisDepth - 1);
-    else if (character === ":" && bracketDepth === 0 && parenthesisDepth === 0) end = index + 1;
-  }
-  return token.slice(0, end);
-};
-var tailwindBase = (token) => token.slice(tailwindVariantPrefix(token).length).replace(/^!/, "");
-var classTokens = (value) => value.split(/\s+/).filter(Boolean);
-
-// src/rules/prefer-semantic-colors.ts
 var PREFER_SEMANTIC_COLORS_DOCUMENTATION = {
   summary: "Enforce semantic color tokens over raw Tailwind palette classes, arbitrary color values, and inline color literals.",
   rationale: "Semantic tokens keep themes and product meaning consistent while raw colors couple components to a palette value.",
@@ -16722,7 +16833,7 @@ var TEST_MODIFIERS4 = /* @__PURE__ */ new Set(["concurrent", "fails", "only", "s
 var EXPECT_MODIFIERS = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var SNAPSHOT_MATCHERS = /snapshot/iu;
 var MIN_CASES2 = 3;
-function staticMemberName5(node) {
+function staticMemberName6(node) {
   if (!node.computed && node.property.type === AST_NODE_TYPES71.Identifier) return node.property.name;
   if (node.computed && node.property.type === AST_NODE_TYPES71.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
@@ -16749,7 +16860,7 @@ function isDirectTestCallback2(node, context) {
 function testRoot2(callee) {
   if (callee.type === AST_NODE_TYPES71.Identifier) return callee;
   if (callee.type !== AST_NODE_TYPES71.MemberExpression) return null;
-  const modifier = staticMemberName5(callee);
+  const modifier = staticMemberName6(callee);
   return modifier !== null && TEST_MODIFIERS4.has(modifier) ? testRoot2(callee.object) : null;
 }
 function isStatic(node) {
@@ -16813,7 +16924,7 @@ function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
   while (receiver.type === AST_NODE_TYPES71.MemberExpression) {
-    const modifier = staticMemberName5(receiver);
+    const modifier = staticMemberName6(receiver);
     if (modifier === null || !EXPECT_MODIFIERS.has(modifier)) return null;
     modifiers.unshift(modifier);
     receiver = receiver.object;
@@ -18407,8 +18518,8 @@ var FLUENT_BUILDER_NAME_RE = /Builder$/;
 var FLUENT_RESULT_TYPE_RE = /(?:Builder|Base|Query|Without)(?:\W|$)/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
-var STORAGE_ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
-var staticMemberName6 = (member) => {
+var STORAGE_ASSIGNMENT_OPERATORS2 = /* @__PURE__ */ new Set(["=", "&&=", "??=", "||="]);
+var staticMemberName7 = (member) => {
   if (member.property.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${member.property.name}`;
   if (!member.computed && member.property.type === AST_NODE_TYPES77.Identifier) return member.property.name;
   return member.computed && member.property.type === AST_NODE_TYPES77.Literal && typeof member.property.value === "string" ? member.property.value : null;
@@ -18500,8 +18611,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
       if (current === void 0) break;
       if (current.type === AST_NODE_TYPES77.ArrowFunctionExpression || current.type === AST_NODE_TYPES77.FunctionExpression || current.type === AST_NODE_TYPES77.FunctionDeclaration || current.type === AST_NODE_TYPES77.ClassExpression || current.type === AST_NODE_TYPES77.ClassDeclaration) continue;
       const expression = current.type === AST_NODE_TYPES77.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === AST_NODE_TYPES77.AssignmentExpression && expression.left.type === AST_NODE_TYPES77.MemberExpression && expression.left.object.type === AST_NODE_TYPES77.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== AST_NODE_TYPES77.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== AST_NODE_TYPES77.MemberExpression || expression.left.object.type !== AST_NODE_TYPES77.ThisExpression || storedField === null) {
+      const storedField = expression?.type === AST_NODE_TYPES77.AssignmentExpression && expression.left.type === AST_NODE_TYPES77.MemberExpression && expression.left.object.type === AST_NODE_TYPES77.ThisExpression ? staticMemberName7(expression.left) : null;
+      if (expression?.type !== AST_NODE_TYPES77.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS2.has(expression.operator) || expression.left.type !== AST_NODE_TYPES77.MemberExpression || expression.left.object.type !== AST_NODE_TYPES77.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -18525,7 +18636,7 @@ var readConstructor = (ctor, declared, typeParameters) => {
         const fields = storedFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Set();
         fields.add(storedField);
         storedFieldsFrom.set(source.object.name, fields);
-        const member = staticMemberName6(source);
+        const member = staticMemberName7(source);
         if (member !== null) {
           const members = storedMemberFieldsFrom.get(source.object.name) ?? /* @__PURE__ */ new Map();
           const memberFields = members.get(member) ?? /* @__PURE__ */ new Set();
@@ -18657,7 +18768,7 @@ var invokedInstanceField = (call) => {
 var instanceField = (candidate2) => {
   let node = candidate2;
   while (node.type === AST_NODE_TYPES77.ChainExpression || node.type === AST_NODE_TYPES77.TSAsExpression || node.type === AST_NODE_TYPES77.TSNonNullExpression || node.type === AST_NODE_TYPES77.TSSatisfiesExpression || node.type === AST_NODE_TYPES77.TSTypeAssertion) node = node.expression;
-  return node.type === AST_NODE_TYPES77.MemberExpression && node.object.type === AST_NODE_TYPES77.ThisExpression ? staticMemberName6(node) : null;
+  return node.type === AST_NODE_TYPES77.MemberExpression && node.object.type === AST_NODE_TYPES77.ThisExpression ? staticMemberName7(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
@@ -19247,14 +19358,14 @@ var REQUIRE_STATIC_NEXT_MATCHER_DOCUMENTATION = {
   ]
 };
 var NEXT_ENTRY_FILE = /(?:^|[/\\])(?:middleware|proxy)\.[cm]?[jt]sx?$/u;
-function unwrapExpression4(node) {
+function unwrapExpression5(node) {
   if (node.type === AST_NODE_TYPES79.TSAsExpression || node.type === AST_NODE_TYPES79.TSSatisfiesExpression || node.type === AST_NODE_TYPES79.TSNonNullExpression || node.type === AST_NODE_TYPES79.TSTypeAssertion) {
-    return unwrapExpression4(node.expression);
+    return unwrapExpression5(node.expression);
   }
   return node;
 }
 function isStaticValue(node) {
-  const value = unwrapExpression4(node);
+  const value = unwrapExpression5(node);
   if (value.type === AST_NODE_TYPES79.Literal) {
     return true;
   }
@@ -19274,9 +19385,8 @@ function isStaticValue(node) {
   return false;
 }
 function propertyName5(property) {
-  if (property.computed) return null;
-  if (property.key.type === AST_NODE_TYPES79.Identifier) return property.key.name;
-  return typeof property.key.value === "string" ? property.key.value : null;
+  if (!property.computed && property.key.type === AST_NODE_TYPES79.Identifier) return property.key.name;
+  return property.key.type === AST_NODE_TYPES79.Literal && typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
   name: "require-static-next-matcher",
@@ -19305,7 +19415,7 @@ var require_static_next_matcher_default = createRule({
           if (declaration.id.type !== AST_NODE_TYPES79.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
-          const config = unwrapExpression4(declaration.init);
+          const config = unwrapExpression5(declaration.init);
           if (config.type !== AST_NODE_TYPES79.ObjectExpression) {
             continue;
           }
@@ -19324,40 +19434,46 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-import { ASTUtils as ASTUtils44 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES80, ASTUtils as ASTUtils44 } from "@typescript-eslint/utils";
 var REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION = {
-  summary: "react-hook-form useForm call without explicit initial or reactive values",
-  rationale: "Without an explicit initial value, fields can change from uncontrolled to controlled as data arrives, reset behavior becomes ambiguous, and the form's initial shape no longer documents the values users can edit.",
-  remediation: "Provide defaultValues for initial state, or values when reactive external state owns initialization; choose schema-appropriate values for controlled fields.",
+  summary: "Require explicit form-level initialization or a field default for directly bound Controller fields.",
+  rationale: "React Hook Form exposes form-level defaultValues/values and field-level defaultValue as its explicit initialization mechanisms. A directly bound controlled field should not omit both mechanisms.",
+  remediation: "Provide a non-undefined defaultValues or values option to useForm, or a non-undefined defaultValue on the associated Controller/useController field.",
   category: "correctness",
   limitations: [
-    "Only direct calls to a scope-resolved useForm value imported from react-hook-form are checked; reactive values are accepted, while wrapper hooks, spreads and computed option objects are intentionally not inferred."
+    "The rule proves only that an explicit form-level initialization option or field default is present; it does not prove that a particular field path occurs inside a defaultValues/values object.",
+    "The rule reports only scope-resolved Controller/useController fields explicitly bound to a directly created useForm control. FormProvider context, wrapper hooks, dynamic options, spreads, computed properties, and interprocedural flows are intentionally left unreported."
   ],
   examples: [
     {
-      id: "form-with-initial-values",
-      title: "Give the form an explicit initial shape",
+      id: "controlled-field-with-form-defaults",
+      title: "Initialize controlled fields at form level",
       outcome: "no-match",
-      files: [{ path: "profile-form.tsx", source: "'use client'; import { useForm } from 'react-hook-form'; function ProfileForm() { const form = useForm({ defaultValues: { name: '' } }); return <input {...form.register('name')} />; }" }],
+      files: [{ path: "profile-form.tsx", source: "'use client'; import { Controller, useForm } from 'react-hook-form'; function ProfileForm() { const form = useForm({ defaultValues: { name: '' } }); return <Controller control={form.control} name='name' render={() => null} />; }" }],
       focusPath: "profile-form.tsx",
       expectedCount: 0,
       public: true
     },
     {
-      id: "form-without-initial-values",
-      title: "Do not leave form initialization implicit",
+      id: "controlled-field-without-default",
+      title: "Do not leave a controlled field uninitialized",
       outcome: "match",
-      files: [{ path: "profile-form.tsx", source: "'use client'; import { useForm } from 'react-hook-form'; function ProfileForm() { const form = useForm({ mode: 'onChange' }); return <input {...form.register('name')} />; }" }],
+      files: [{ path: "profile-form.tsx", source: "'use client'; import { Controller, useForm } from 'react-hook-form'; function ProfileForm() { const form = useForm(); return <Controller control={form.control} name='name' render={() => null} />; }" }],
       focusPath: "profile-form.tsx",
       expectedCount: 1,
       public: true
     }
   ]
 };
-function hasInitializationOrUnknownOptions(options) {
-  return options?.type === "ObjectExpression" && options.properties.some(
-    (property) => property.type === "SpreadElement" || property.computed || (property.key.type === "Identifier" && ["defaultValues", "values"].includes(property.key.name) || property.key.type === "Literal" && ["defaultValues", "values"].includes(String(property.key.value)))
-  );
+function staticPropertyName(property) {
+  if (property.computed) return null;
+  if (property.key.type === AST_NODE_TYPES80.Identifier) return property.key.name;
+  if (property.key.type === AST_NODE_TYPES80.Literal && typeof property.key.value === "string") return property.key.value;
+  return null;
+}
+function unwrapExpression6(node) {
+  if (node.type === AST_NODE_TYPES80.TSAsExpression || node.type === AST_NODE_TYPES80.TSSatisfiesExpression || node.type === AST_NODE_TYPES80.TSNonNullExpression || node.type === AST_NODE_TYPES80.TSTypeAssertion) return unwrapExpression6(node.expression);
+  return node;
 }
 var require_use_form_default_values_default = createRule({
   name: "require-use-form-default-values",
@@ -19366,27 +19482,127 @@ var require_use_form_default_values_default = createRule({
     type: "problem",
     docs: { description: REQUIRE_USE_FORM_DEFAULT_VALUES_DOCUMENTATION.summary },
     schema: [],
-    messages: {
-      requireUseFormDefaultValues: "Provide defaultValues or reactive values to useForm so controlled fields have an explicit initial shape."
-    }
+    messages: { requireUseFormDefaultValues: "Add non-undefined defaultValues/values to the associated useForm call or non-undefined defaultValue to this field." }
   },
   defaultOptions: [],
   create(context) {
-    const importedHooks = /* @__PURE__ */ new Set();
+    const imported = /* @__PURE__ */ new Map();
+    const uninitializedForms = /* @__PURE__ */ new Set();
+    const uninitializedControls = /* @__PURE__ */ new Set();
+    const bindingNamed = (node, name) => ASTUtils44.findVariable(context.sourceCode.getScope(node), name);
+    const bindingOf = (node) => bindingNamed(node, node.name);
+    const stable = (variable) => !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
+    const importedKind = (node) => {
+      const variable = bindingOf(node);
+      return variable !== null && stable(variable) ? imported.get(variable) ?? null : null;
+    };
+    const importedJsxKind = (node) => {
+      const variable = bindingNamed(node, node.name);
+      return variable !== null && stable(variable) ? imported.get(variable) ?? null : null;
+    };
+    const isDefinitelyUndefined = (node) => {
+      const value = unwrapExpression6(node);
+      return value.type === AST_NODE_TYPES80.UnaryExpression && value.operator === "void" || value.type === AST_NODE_TYPES80.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
+    };
+    const initializationState = (node) => {
+      if (node === void 0) return "uninitialized";
+      if (node.type !== AST_NODE_TYPES80.ObjectExpression) return "unknown";
+      const initialization = /* @__PURE__ */ new Map();
+      for (const property of node.properties) {
+        if (property.type === AST_NODE_TYPES80.SpreadElement || property.computed) return "unknown";
+        if (property.type !== AST_NODE_TYPES80.Property) continue;
+        const name = staticPropertyName(property);
+        if (name === "defaultValues" || name === "values") initialization.set(name, !isDefinitelyUndefined(property.value));
+      }
+      return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
+    };
+    const uninitializedUseFormCall = (node) => {
+      if (node.type !== AST_NODE_TYPES80.CallExpression || node.callee.type !== AST_NODE_TYPES80.Identifier || importedKind(node.callee) !== "useForm") return false;
+      const options = node.arguments[0];
+      return options?.type !== AST_NODE_TYPES80.SpreadElement && initializationState(options) === "uninitialized";
+    };
+    const isUninitializedForm = (node) => {
+      if (node.type !== AST_NODE_TYPES80.Identifier) return false;
+      const variable = bindingOf(node);
+      return variable !== null && stable(variable) && uninitializedForms.has(variable);
+    };
+    const isUninitializedControl = (node) => {
+      if (node.type === AST_NODE_TYPES80.Identifier) {
+        const variable = bindingOf(node);
+        return variable !== null && stable(variable) && uninitializedControls.has(variable);
+      }
+      return node.type === AST_NODE_TYPES80.MemberExpression && !node.computed && node.property.type === AST_NODE_TYPES80.Identifier && node.property.name === "control" && isUninitializedForm(node.object);
+    };
+    const fieldOptionsNeedDefault = (node) => {
+      if (node?.type !== AST_NODE_TYPES80.ObjectExpression) return false;
+      let control = null;
+      let hasDefault = false;
+      for (const property of node.properties) {
+        if (property.type === AST_NODE_TYPES80.SpreadElement || property.computed) return false;
+        if (property.type !== AST_NODE_TYPES80.Property) continue;
+        const name = staticPropertyName(property);
+        if (name === "control") control = property.value;
+        if (name === "defaultValue") hasDefault = !isDefinitelyUndefined(property.value);
+      }
+      return control !== null && isUninitializedControl(control) && !hasDefault;
+    };
+    const jsxAttribute = (node, name) => {
+      let result = null;
+      for (const attribute of node.attributes) {
+        if (attribute.type === AST_NODE_TYPES80.JSXSpreadAttribute) return null;
+        if (attribute.name.type === AST_NODE_TYPES80.JSXIdentifier && attribute.name.name === name) result = attribute;
+      }
+      return result;
+    };
+    const trackDestructuredControl = (pattern) => {
+      for (const property of pattern.properties) {
+        if (property.type !== AST_NODE_TYPES80.Property || staticPropertyName(property) !== "control" || property.value.type !== AST_NODE_TYPES80.Identifier) continue;
+        const variable = bindingOf(property.value);
+        if (variable !== null) uninitializedControls.add(variable);
+      }
+    };
     return {
       ImportDeclaration(node) {
         if (node.source.value !== "react-hook-form") return;
         for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier" || (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) !== "useForm") continue;
-          const variable = ASTUtils44.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
-          if (variable) importedHooks.add(variable);
+          if (specifier.type !== AST_NODE_TYPES80.ImportSpecifier) continue;
+          const name = specifier.imported.type === AST_NODE_TYPES80.Identifier ? specifier.imported.name : String(specifier.imported.value);
+          if (name !== "Controller" && name !== "useController" && name !== "useForm") continue;
+          const variable = bindingOf(specifier.local);
+          if (variable !== null) imported.set(variable, name);
+        }
+      },
+      VariableDeclarator(node) {
+        if (node.init === null) return;
+        if (uninitializedUseFormCall(node.init)) {
+          if (node.id.type === AST_NODE_TYPES80.Identifier) {
+            const variable = bindingOf(node.id);
+            if (variable !== null) uninitializedForms.add(variable);
+          } else if (node.id.type === AST_NODE_TYPES80.ObjectPattern) {
+            trackDestructuredControl(node.id);
+          }
+          return;
+        }
+        if (node.id.type === AST_NODE_TYPES80.ObjectPattern && isUninitializedForm(node.init)) {
+          trackDestructuredControl(node.id);
+          return;
+        }
+        if (node.id.type === AST_NODE_TYPES80.Identifier && node.init.type === AST_NODE_TYPES80.MemberExpression && !node.init.computed && node.init.property.type === AST_NODE_TYPES80.Identifier && node.init.property.name === "control" && isUninitializedForm(node.init.object)) {
+          const variable = bindingOf(node.id);
+          if (variable !== null) uninitializedControls.add(variable);
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== "Identifier") return;
-        const variable = ASTUtils44.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
-        const options = node.arguments[0];
-        if (!variable || !importedHooks.has(variable) || options !== void 0 && options.type !== "ObjectExpression" || hasInitializationOrUnknownOptions(options)) return;
+        if (node.callee.type !== AST_NODE_TYPES80.Identifier || importedKind(node.callee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === AST_NODE_TYPES80.SpreadElement ? void 0 : node.arguments[0])) return;
+        context.report({ node, messageId: "requireUseFormDefaultValues" });
+      },
+      JSXOpeningElement(node) {
+        if (node.name.type !== AST_NODE_TYPES80.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.attributes.some((attribute) => attribute.type === AST_NODE_TYPES80.JSXSpreadAttribute)) return;
+        const control = jsxAttribute(node, "control");
+        if (control?.value?.type !== AST_NODE_TYPES80.JSXExpressionContainer || control.value.expression.type === AST_NODE_TYPES80.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
+        const defaultValue = jsxAttribute(node, "defaultValue");
+        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== AST_NODE_TYPES80.JSXExpressionContainer || defaultValue.value.expression.type !== AST_NODE_TYPES80.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       }
     };
@@ -19462,7 +19678,7 @@ var require_use_server_in_actions_file_default = createRule({
 
 // src/rules/require-zod-form-validation.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES80,
+  AST_NODE_TYPES as AST_NODE_TYPES81,
   ASTUtils as ASTUtils45
 } from "@typescript-eslint/utils";
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
@@ -19490,14 +19706,14 @@ var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
-    if (current.type === AST_NODE_TYPES80.Identifier) {
+    if (current.type === AST_NODE_TYPES81.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES80.CallExpression) {
+    if (current.type === AST_NODE_TYPES81.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === AST_NODE_TYPES80.MemberExpression) {
+    if (current.type === AST_NODE_TYPES81.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -19506,12 +19722,12 @@ var zodReceiverRoot = (node) => {
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === AST_NODE_TYPES80.AwaitExpression) {
+  if (current.type === AST_NODE_TYPES81.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== AST_NODE_TYPES80.CallExpression) return false;
+  if (current.type !== AST_NODE_TYPES81.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === AST_NODE_TYPES80.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES80.Identifier && callee.property.name === "formData";
+  return callee.type === AST_NODE_TYPES81.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES81.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -19542,16 +19758,16 @@ var require_zod_form_validation_default = createRule({
         return false;
       }
       const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES80.VariableDeclarator) {
+      if (definition?.type !== "Variable" || definition.node.type !== AST_NODE_TYPES81.VariableDeclarator) {
         return false;
       }
       const init = definition.node.init;
-      return init?.type === AST_NODE_TYPES80.ObjectExpression || init?.type === AST_NODE_TYPES80.ArrayExpression || init?.type === AST_NODE_TYPES80.Literal || init?.type === AST_NODE_TYPES80.ArrowFunctionExpression || init?.type === AST_NODE_TYPES80.FunctionExpression;
+      return init?.type === AST_NODE_TYPES81.ObjectExpression || init?.type === AST_NODE_TYPES81.ArrayExpression || init?.type === AST_NODE_TYPES81.Literal || init?.type === AST_NODE_TYPES81.ArrowFunctionExpression || init?.type === AST_NODE_TYPES81.FunctionExpression;
     };
     const isZodParseCall = (node) => {
-      if (node.type !== AST_NODE_TYPES80.CallExpression) return false;
+      if (node.type !== AST_NODE_TYPES81.CallExpression) return false;
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES80.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES80.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES81.MemberExpression || callee.computed || callee.property.type !== AST_NODE_TYPES81.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
         return false;
       }
       const root = zodReceiverRoot(callee.object);
@@ -19560,14 +19776,14 @@ var require_zod_form_validation_default = createRule({
       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_TYPES80.Identifier) return false;
+      if (node.type !== AST_NODE_TYPES81.Identifier) return false;
       const conventionalName = /formdata/i.test(node.name);
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES80.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES81.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return def?.type === "Parameter" && conventionalName;
@@ -19578,8 +19794,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== AST_NODE_TYPES80.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES80.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
+      if (callee.type !== AST_NODE_TYPES81.MemberExpression) return false;
+      if (callee.property.type !== AST_NODE_TYPES81.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -19588,15 +19804,15 @@ var require_zod_form_validation_default = createRule({
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
         if (isZodParseCall(parent)) return parent;
-        if (parent.type === AST_NODE_TYPES80.CallExpression && parent.callee.type === AST_NODE_TYPES80.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES81.CallExpression && parent.callee.type === AST_NODE_TYPES81.Identifier && ["Number", "String", "Boolean"].includes(parent.callee.name) && parent.arguments.length === 1 && (resolvedBinding(parent.callee)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES80.CallExpression && parent.callee.type === AST_NODE_TYPES80.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES80.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES80.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
+        if (parent.type === AST_NODE_TYPES81.CallExpression && parent.callee.type === AST_NODE_TYPES81.MemberExpression && !parent.callee.computed && parent.callee.object.type === AST_NODE_TYPES81.Identifier && parent.callee.object.name === "Object" && parent.callee.property.type === AST_NODE_TYPES81.Identifier && parent.callee.property.name === "fromEntries" && (resolvedBinding(parent.callee.object)?.defs.length ?? 0) === 0) {
           parent = parent.parent;
           continue;
         }
-        if (parent.type === AST_NODE_TYPES80.CallExpression || parent.type === AST_NODE_TYPES80.NewExpression || parent.type === AST_NODE_TYPES80.TaggedTemplateExpression || parent.type === AST_NODE_TYPES80.ArrowFunctionExpression || parent.type === AST_NODE_TYPES80.FunctionExpression || parent.type === AST_NODE_TYPES80.FunctionDeclaration) return null;
+        if (parent.type === AST_NODE_TYPES81.CallExpression || parent.type === AST_NODE_TYPES81.NewExpression || parent.type === AST_NODE_TYPES81.TaggedTemplateExpression || parent.type === AST_NODE_TYPES81.ArrowFunctionExpression || parent.type === AST_NODE_TYPES81.FunctionExpression || parent.type === AST_NODE_TYPES81.FunctionDeclaration) return null;
         parent = parent.parent;
       }
       return null;
@@ -19604,16 +19820,16 @@ var require_zod_form_validation_default = createRule({
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES80.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES80.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+      return parent !== null && parent !== void 0 && parent.type === AST_NODE_TYPES81.BinaryExpression && parent.operator === "instanceof" && parent.left === node && parent.right.type === AST_NODE_TYPES81.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
     };
     const boundDeclarator = (node) => {
       let current = node;
       let parent = current.parent;
-      while ((parent.type === AST_NODE_TYPES80.TSAsExpression || parent.type === AST_NODE_TYPES80.TSSatisfiesExpression || parent.type === AST_NODE_TYPES80.TSNonNullExpression || parent.type === AST_NODE_TYPES80.ChainExpression) && parent.expression === current) {
+      while ((parent.type === AST_NODE_TYPES81.TSAsExpression || parent.type === AST_NODE_TYPES81.TSSatisfiesExpression || parent.type === AST_NODE_TYPES81.TSNonNullExpression || parent.type === AST_NODE_TYPES81.ChainExpression) && parent.expression === current) {
         current = parent;
         parent = current.parent;
       }
-      if (parent.type === AST_NODE_TYPES80.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES80.Identifier) {
+      if (parent.type === AST_NODE_TYPES81.VariableDeclarator && parent.init === current && parent.id.type === AST_NODE_TYPES81.Identifier) {
         return parent;
       }
       return null;
@@ -19622,7 +19838,7 @@ var require_zod_form_validation_default = createRule({
       let current = node;
       while (current.parent !== void 0) {
         const parent = current.parent;
-        if (parent.type === AST_NODE_TYPES80.BlockStatement || parent.type === AST_NODE_TYPES80.Program) {
+        if (parent.type === AST_NODE_TYPES81.BlockStatement || parent.type === AST_NODE_TYPES81.Program) {
           return current;
         }
         current = parent;
@@ -19631,12 +19847,12 @@ var require_zod_form_validation_default = createRule({
     };
     const zodParseMethod = (call) => {
       const callee = call.callee;
-      return callee.type === AST_NODE_TYPES80.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES80.Identifier ? callee.property.name : null;
+      return callee.type === AST_NODE_TYPES81.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES81.Identifier ? callee.property.name : null;
     };
     const hasConditionalAncestorBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === AST_NODE_TYPES80.LogicalExpression || current.type === AST_NODE_TYPES80.ConditionalExpression) {
+        if (current.type === AST_NODE_TYPES81.LogicalExpression || current.type === AST_NODE_TYPES81.ConditionalExpression) {
           return true;
         }
         current = current.parent;
@@ -19646,7 +19862,7 @@ var require_zod_form_validation_default = createRule({
     const isAwaitedBeforeStatement = (node, statement) => {
       let current = node.parent;
       while (current !== void 0 && current !== statement) {
-        if (current.type === AST_NODE_TYPES80.AwaitExpression) return true;
+        if (current.type === AST_NODE_TYPES81.AwaitExpression) return true;
         current = current.parent;
       }
       return false;
@@ -19659,7 +19875,7 @@ var require_zod_form_validation_default = createRule({
       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_TYPES80.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES80.ExpressionStatement) {
+      if (validationStatement.type !== AST_NODE_TYPES81.VariableDeclaration && validationStatement.type !== AST_NODE_TYPES81.ExpressionStatement) {
         return null;
       }
       const method = zodParseMethod(parse2);
@@ -19671,16 +19887,16 @@ var require_zod_form_validation_default = createRule({
     };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
-      if (parent.type === AST_NODE_TYPES80.UnaryExpression && parent.operator === "typeof") {
+      if (parent.type === AST_NODE_TYPES81.UnaryExpression && parent.operator === "typeof") {
         return true;
       }
-      if (parent.type !== AST_NODE_TYPES80.BinaryExpression || parent.left !== identifier) {
+      if (parent.type !== AST_NODE_TYPES81.BinaryExpression || parent.left !== identifier) {
         return false;
       }
       if (parent.operator === "instanceof") {
-        return parent.right.type === AST_NODE_TYPES80.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
+        return parent.right.type === AST_NODE_TYPES81.Identifier && (parent.right.name === "File" || parent.right.name === "Blob");
       }
-      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES80.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES80.Identifier && parent.right.name === "undefined");
+      return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES81.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES81.Identifier && parent.right.name === "undefined");
     };
     const isDescendantOf = (node, ancestor) => {
       let current = node;
@@ -19691,23 +19907,23 @@ var require_zod_form_validation_default = createRule({
       return false;
     };
     const blockTerminates = (node) => {
-      if (node.type === AST_NODE_TYPES80.ReturnStatement || node.type === AST_NODE_TYPES80.ThrowStatement) {
+      if (node.type === AST_NODE_TYPES81.ReturnStatement || node.type === AST_NODE_TYPES81.ThrowStatement) {
         return true;
       }
-      if (node.type !== AST_NODE_TYPES80.BlockStatement || node.body.length === 0) return false;
+      if (node.type !== AST_NODE_TYPES81.BlockStatement || node.body.length === 0) return false;
       const last = node.body.at(-1);
       return last !== void 0 && blockTerminates(last);
     };
     const narrowingIf = (identifier) => {
       const comparison = identifier.parent;
-      if (comparison?.type !== AST_NODE_TYPES80.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES80.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+      if (comparison?.type !== AST_NODE_TYPES81.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES81.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
         return null;
       }
       const maybeNegation = comparison.parent;
-      const negated = maybeNegation?.type === AST_NODE_TYPES80.UnaryExpression && maybeNegation.operator === "!";
+      const negated = maybeNegation?.type === AST_NODE_TYPES81.UnaryExpression && maybeNegation.operator === "!";
       const test = negated ? maybeNegation : comparison;
       const branch = test.parent;
-      return branch?.type === AST_NODE_TYPES80.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+      return branch?.type === AST_NODE_TYPES81.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
     };
     const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
       if (positive) return isDescendantOf(use, branch.consequent);
@@ -19727,7 +19943,7 @@ var require_zod_form_validation_default = createRule({
       const variable = context.sourceCode.getDeclaredVariables(declarator)[0];
       if (variable === void 0) return false;
       const references = variable.references.filter((reference) => !reference.isWriteOnly()).map((reference) => reference.identifier).filter(
-        (identifier) => identifier.type === AST_NODE_TYPES80.Identifier
+        (identifier) => identifier.type === AST_NODE_TYPES81.Identifier
       );
       if (references.length === 0) return false;
       const narrowings = references.map(narrowingIf).filter(
@@ -19753,7 +19969,7 @@ var require_zod_form_validation_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES80.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES80.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES80.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES80.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES81.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES81.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES81.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES81.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             const binding = resolvedBinding(specifier.local);
             if (binding !== null) zodBindings.add(binding);
           }
@@ -19843,7 +20059,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES81, ASTUtils as ASTUtils46 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES82, ASTUtils as ASTUtils46 } from "@typescript-eslint/utils";
 var STEPDOWN_DOCUMENTATION = {
   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.",
@@ -19861,7 +20077,7 @@ var STEPDOWN_DOCUMENTATION = {
   ]
 };
 function isFunction(node) {
-  return node.type === AST_NODE_TYPES81.ArrowFunctionExpression || node.type === AST_NODE_TYPES81.FunctionDeclaration || node.type === AST_NODE_TYPES81.FunctionExpression;
+  return node.type === AST_NODE_TYPES82.ArrowFunctionExpression || node.type === AST_NODE_TYPES82.FunctionDeclaration || node.type === AST_NODE_TYPES82.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
@@ -19956,8 +20172,8 @@ function moduleScope(context, program) {
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
     program.body.flatMap((statement) => {
-      const node = statement.type === AST_NODE_TYPES81.ExportNamedDeclaration ? statement.declaration : statement;
-      return node?.type === AST_NODE_TYPES81.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
+      const node = statement.type === AST_NODE_TYPES82.ExportNamedDeclaration ? statement.declaration : statement;
+      return node?.type === AST_NODE_TYPES82.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
   const exported = exportedNames(program);
@@ -19981,7 +20197,7 @@ function moduleScope(context, program) {
       const nearestFunction2 = [...ancestors].reverse().find(isFunction);
       const parent = identifier.parent;
       const callerDefinition = nearestFunction2 === void 0 ? void 0 : byFunction.get(nearestFunction2);
-      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES81.CallExpression || parent.callee !== identifier) {
+      if (callerDefinition === void 0 || parent.type !== AST_NODE_TYPES82.CallExpression || parent.callee !== identifier) {
         pinned.add(definition.name);
         continue;
       }
@@ -19996,38 +20212,38 @@ function moduleScope(context, program) {
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== AST_NODE_TYPES81.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
-    if (statement.declaration?.type === AST_NODE_TYPES81.FunctionDeclaration && statement.declaration.id !== null) {
+    if (statement.type !== AST_NODE_TYPES82.ExportNamedDeclaration || statement.exportKind === "type" || statement.source !== null) continue;
+    if (statement.declaration?.type === AST_NODE_TYPES82.FunctionDeclaration && statement.declaration.id !== null) {
       names.add(statement.declaration.id.name);
     }
-    if (statement.declaration?.type === AST_NODE_TYPES81.VariableDeclaration) {
+    if (statement.declaration?.type === AST_NODE_TYPES82.VariableDeclaration) {
       for (const declarator of statement.declaration.declarations) {
-        if (declarator.id.type === AST_NODE_TYPES81.Identifier) names.add(declarator.id.name);
+        if (declarator.id.type === AST_NODE_TYPES82.Identifier) names.add(declarator.id.name);
       }
     }
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES81.Identifier) {
+      if (specifier.exportKind !== "type" && specifier.local.type === AST_NODE_TYPES82.Identifier) {
         names.add(specifier.local.name);
       }
     }
   }
   for (const statement of program.body) {
-    if (statement.type === AST_NODE_TYPES81.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES81.Identifier) names.add(statement.declaration.name);
-    if (statement.type === AST_NODE_TYPES81.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES81.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
+    if (statement.type === AST_NODE_TYPES82.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES82.Identifier) names.add(statement.declaration.name);
+    if (statement.type === AST_NODE_TYPES82.ExportDefaultDeclaration && statement.declaration.type === AST_NODE_TYPES82.FunctionDeclaration && statement.declaration.id !== null) names.add(statement.declaration.id.name);
   }
   return names;
 }
 function moduleDefinitions(program) {
   const definitions = [];
   for (const statement of program.body) {
-    const node = statement.type === AST_NODE_TYPES81.ExportNamedDeclaration || statement.type === AST_NODE_TYPES81.ExportDefaultDeclaration ? statement.declaration : statement;
-    if (node?.type === AST_NODE_TYPES81.FunctionDeclaration && node.id !== null && node.body !== null) {
+    const node = statement.type === AST_NODE_TYPES82.ExportNamedDeclaration || statement.type === AST_NODE_TYPES82.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (node?.type === AST_NODE_TYPES82.FunctionDeclaration && node.id !== null && node.body !== null) {
       definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== AST_NODE_TYPES81.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== AST_NODE_TYPES82.VariableDeclaration || node.kind !== "const") continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === AST_NODE_TYPES81.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      if (declarator.id.type === AST_NODE_TYPES82.Identifier && declarator.init !== null && isFunction(declarator.init)) {
         definitions.push({
           name: declarator.id.name,
           node: declarator,
@@ -20040,21 +20256,21 @@ function moduleDefinitions(program) {
   return definitions;
 }
 function methodName(node) {
-  if (node.key.type === AST_NODE_TYPES81.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === AST_NODE_TYPES81.Identifier ? node.key.name : null;
+  if (node.key.type === AST_NODE_TYPES82.PrivateIdentifier) return `#${node.key.name}`;
+  return !node.computed && node.key.type === AST_NODE_TYPES82.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES81.Identifier ? ASTUtils46.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES82.Identifier ? ASTUtils46.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== AST_NODE_TYPES81.ThisExpression && !isClassReference) return null;
-  if (node.property.type === AST_NODE_TYPES81.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES81.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES81.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.object.type !== AST_NODE_TYPES82.ThisExpression && !isClassReference) return null;
+  if (node.property.type === AST_NODE_TYPES82.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES82.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES82.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function referencedPropertyName(node) {
-  if (node.property.type === AST_NODE_TYPES81.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === AST_NODE_TYPES81.Identifier) return node.property.name;
-  return node.computed && node.property.type === AST_NODE_TYPES81.Literal && typeof node.property.value === "string" ? node.property.value : null;
+  if (node.property.type === AST_NODE_TYPES82.PrivateIdentifier) return `#${node.property.name}`;
+  if (!node.computed && node.property.type === AST_NODE_TYPES82.Identifier) return node.property.name;
+  return node.computed && node.property.type === AST_NODE_TYPES82.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
@@ -20070,7 +20286,7 @@ function walk(node, visitorKeys, visit, nestedFunction = false) {
 }
 function classScope(context, node, computedReferenceNames) {
   const methods = node.body.body.filter(
-    (member) => member.type === AST_NODE_TYPES81.MethodDefinition
+    (member) => member.type === AST_NODE_TYPES82.MethodDefinition
   );
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
@@ -20078,8 +20294,8 @@ function classScope(context, node, computedReferenceNames) {
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   for (const member of node.body.body) {
-    if (member.type !== AST_NODE_TYPES81.TSAbstractMethodDefinition) continue;
-    const name = !member.computed && member.key.type === AST_NODE_TYPES81.Identifier ? member.key.name : null;
+    if (member.type !== AST_NODE_TYPES82.TSAbstractMethodDefinition) continue;
+    const name = !member.computed && member.key.type === AST_NODE_TYPES82.Identifier ? member.key.name : null;
     if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
   }
   const scopeDefinitions = methods.flatMap((method) => {
@@ -20088,7 +20304,7 @@ function classScope(context, node, computedReferenceNames) {
   });
   const definitions = methods.flatMap((method) => {
     const name = methodName(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES81.PrivateIdentifier;
+    const isPrivate = method.accessibility === "private" || method.key.type === AST_NODE_TYPES82.PrivateIdentifier;
     return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
   });
   if (definitions.length === 0) return;
@@ -20100,7 +20316,7 @@ function classScope(context, node, computedReferenceNames) {
     const internal = ASTUtils46.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
-  if (node.type === AST_NODE_TYPES81.ClassExpression && node.parent.type === AST_NODE_TYPES81.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES81.Identifier) {
+  if (node.type === AST_NODE_TYPES82.ClassExpression && node.parent.type === AST_NODE_TYPES82.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES82.Identifier) {
     const outer = ASTUtils46.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
@@ -20117,26 +20333,26 @@ function classScope(context, node, computedReferenceNames) {
     }
     const thisValue = (value) => {
       let current = value;
-      while (current?.type === AST_NODE_TYPES81.TSAsExpression || current?.type === AST_NODE_TYPES81.TSSatisfiesExpression || current?.type === AST_NODE_TYPES81.TSNonNullExpression) current = current.expression;
-      return current?.type === AST_NODE_TYPES81.ThisExpression;
+      while (current?.type === AST_NODE_TYPES82.TSAsExpression || current?.type === AST_NODE_TYPES82.TSSatisfiesExpression || current?.type === AST_NODE_TYPES82.TSNonNullExpression) current = current.expression;
+      return current?.type === AST_NODE_TYPES82.ThisExpression;
     };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== AST_NODE_TYPES81.VariableDeclarator && current.type !== AST_NODE_TYPES81.AssignmentPattern) return;
-      if (current.type === AST_NODE_TYPES81.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES81.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === AST_NODE_TYPES81.VariableDeclarator ? current.id : current.left;
-      const value = current.type === AST_NODE_TYPES81.VariableDeclarator ? current.init : current.right;
+      if (nestedFunction || current.type !== AST_NODE_TYPES82.VariableDeclarator && current.type !== AST_NODE_TYPES82.AssignmentPattern) return;
+      if (current.type === AST_NODE_TYPES82.VariableDeclarator && (current.parent.type !== AST_NODE_TYPES82.VariableDeclaration || current.parent.kind !== "const")) return;
+      const binding = current.type === AST_NODE_TYPES82.VariableDeclarator ? current.id : current.left;
+      const value = current.type === AST_NODE_TYPES82.VariableDeclarator ? current.init : current.right;
       if (!thisValue(value)) return;
-      if (binding.type === AST_NODE_TYPES81.ObjectPattern) {
+      if (binding.type === AST_NODE_TYPES82.ObjectPattern) {
         for (const property of binding.properties) {
-          if (property.type === AST_NODE_TYPES81.RestElement) {
+          if (property.type === AST_NODE_TYPES82.RestElement) {
             for (const name of privateNames) pinned.add(name);
-          } else if (property.key.type === AST_NODE_TYPES81.Identifier && privateNames.has(property.key.name)) {
+          } else if (property.key.type === AST_NODE_TYPES82.Identifier && privateNames.has(property.key.name)) {
             pinned.add(property.key.name);
           }
         }
         return;
       }
-      if (binding.type !== AST_NODE_TYPES81.Identifier) return;
+      if (binding.type !== AST_NODE_TYPES82.Identifier) return;
       const variable = ASTUtils46.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
@@ -20150,16 +20366,16 @@ function classScope(context, node, computedReferenceNames) {
       walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
-      if (current.type === AST_NODE_TYPES81.VariableDeclarator && current.id.type === AST_NODE_TYPES81.ObjectPattern && thisValue(current.init)) {
+      if (current.type === AST_NODE_TYPES82.VariableDeclarator && current.id.type === AST_NODE_TYPES82.ObjectPattern && thisValue(current.init)) {
         for (const property of current.id.properties) {
-          if (property.type === AST_NODE_TYPES81.RestElement) {
+          if (property.type === AST_NODE_TYPES82.RestElement) {
             for (const name of privateNames) pinned.add(name);
             continue;
           }
-          if (property.type === AST_NODE_TYPES81.Property && property.key.type === AST_NODE_TYPES81.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
+          if (property.type === AST_NODE_TYPES82.Property && property.key.type === AST_NODE_TYPES82.Identifier && privateNames.has(property.key.name)) pinned.add(property.key.name);
         }
       }
-      if (current.type !== AST_NODE_TYPES81.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES82.MemberExpression) return;
       const target = referencedMethod(context, current, methodClassVariables);
       if (target === null) {
         const possibleTarget = referencedPropertyName(current);
@@ -20167,12 +20383,12 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES81.Identifier ? ASTUtils46.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES82.Identifier ? ASTUtils46.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES81.CallExpression || current.parent.callee !== current) {
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== AST_NODE_TYPES82.CallExpression || current.parent.callee !== current) {
         pinned.add(target);
         return;
       }
@@ -20192,9 +20408,9 @@ function classScope(context, node, computedReferenceNames) {
     }
   }
   for (const member of node.body.body) {
-    if (member.type === AST_NODE_TYPES81.MethodDefinition || member.type === AST_NODE_TYPES81.TSAbstractMethodDefinition) continue;
+    if (member.type === AST_NODE_TYPES82.MethodDefinition || member.type === AST_NODE_TYPES82.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
-      if (current.type !== AST_NODE_TYPES81.MemberExpression) return;
+      if (current.type !== AST_NODE_TYPES82.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
       if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
@@ -20216,12 +20432,12 @@ function classScope(context, node, computedReferenceNames) {
 }
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
-    case AST_NODE_TYPES81.StaticBlock:
+    case AST_NODE_TYPES82.StaticBlock:
       return true;
-    case AST_NODE_TYPES81.PropertyDefinition:
-    case AST_NODE_TYPES81.AccessorProperty:
+    case AST_NODE_TYPES82.PropertyDefinition:
+    case AST_NODE_TYPES82.AccessorProperty:
       return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
-    case AST_NODE_TYPES81.MethodDefinition:
+    case AST_NODE_TYPES82.MethodDefinition:
       return member.computed || member.decorators.length > 0;
     default:
       return false;
@@ -20253,7 +20469,7 @@ var stepdown_default = createRule({
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === AST_NODE_TYPES81.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES81.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === AST_NODE_TYPES82.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES82.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
       }
@@ -20262,8 +20478,8 @@ var stepdown_default = createRule({
 });
 
 // src/rules/source-coupled-test.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES82, ASTUtils as ASTUtils47 } from "@typescript-eslint/utils";
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
+import { AST_NODE_TYPES as AST_NODE_TYPES83, ASTUtils as ASTUtils47 } from "@typescript-eslint/utils";
+var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc?|toml|py|[cm]?[jt]s)$/iu;
 var FS_MODULES = /* @__PURE__ */ new Set(["fs", "node:fs", "fs/promises", "node:fs/promises"]);
 var FS_READERS = /* @__PURE__ */ new Set(["readFile", "readFileSync"]);
 var TEXT_TRANSFORMS = /* @__PURE__ */ new Set([
@@ -20300,6 +20516,8 @@ var EXPECT_MATCHERS = /* @__PURE__ */ new Set([
 ]);
 var EXPECT_MODIFIERS2 = /* @__PURE__ */ new Set(["not", "rejects", "resolves"]);
 var ASSERT_MATCHERS = /* @__PURE__ */ new Set(["deepEqual", "doesNotMatch", "equal", "match", "notDeepEqual", "notEqual", "notStrictEqual", "ok", "strictEqual"]);
+var EXPECT_MODULES = /* @__PURE__ */ new Set(["@jest/globals", "@playwright/test", "bun:test", "vitest"]);
+var ASSERT_MODULES = /* @__PURE__ */ new Set(["assert", "assert/strict", "node:assert", "node:assert/strict"]);
 var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   summary: "Disallow raw repository source text as a test oracle; parse or execute the artifact instead.",
   rationale: "Substring and regex checks can pass on comments or unreachable configuration and fail after behavior-preserving formatting changes.",
@@ -20307,6 +20525,7 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
   category: "testing",
   limitations: [
     "The rule follows stable lexical bindings, static source paths, awaited reads, and common text operations. Reassigned bindings, dynamic paths, unknown path wrappers, iterator pipelines, and interprocedural flows remain unreported.",
+    "Assertion roots are scope-resolved for supported test runners and Node assert imports; local or unknown helpers with assertion-like names are not inferred.",
     "When raw representation is genuinely the contract (for example a golden or compatibility sentinel), use an exact line suppression with the reason."
   ],
   examples: [
@@ -20330,22 +20549,22 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
     }
   ]
 };
-function staticMemberName7(node) {
-  if (!node.computed && node.property.type === AST_NODE_TYPES82.Identifier) return node.property.name;
-  if (node.computed && node.property.type === AST_NODE_TYPES82.Literal && typeof node.property.value === "string") return node.property.value;
+function staticMemberName8(node) {
+  if (!node.computed && node.property.type === AST_NODE_TYPES83.Identifier) return node.property.name;
+  if (node.computed && node.property.type === AST_NODE_TYPES83.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
 }
 function unwrap7(node) {
-  if (node.type === AST_NODE_TYPES82.AwaitExpression) return unwrap7(node.argument);
-  if (node.type === AST_NODE_TYPES82.ChainExpression) return unwrap7(node.expression);
-  if (node.type === AST_NODE_TYPES82.TSAsExpression || node.type === AST_NODE_TYPES82.TSNonNullExpression || node.type === AST_NODE_TYPES82.TSTypeAssertion) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES83.AwaitExpression) return unwrap7(node.argument);
+  if (node.type === AST_NODE_TYPES83.ChainExpression) return unwrap7(node.expression);
+  if (node.type === AST_NODE_TYPES83.TSAsExpression || node.type === AST_NODE_TYPES83.TSNonNullExpression || node.type === AST_NODE_TYPES83.TSTypeAssertion) return unwrap7(node.expression);
   return node;
 }
 function stringValue(node) {
   const current = unwrap7(node);
-  if (current.type === AST_NODE_TYPES82.Literal && typeof current.value === "string") return current.value;
-  if (current.type === AST_NODE_TYPES82.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
-  if (current.type === AST_NODE_TYPES82.BinaryExpression && current.operator === "+") {
+  if (current.type === AST_NODE_TYPES83.Literal && typeof current.value === "string") return current.value;
+  if (current.type === AST_NODE_TYPES83.TemplateLiteral && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+  if (current.type === AST_NODE_TYPES83.BinaryExpression && current.operator === "+") {
     const left = stringValue(current.left);
     const right = stringValue(current.right);
     return left === null || right === null ? null : left + right;
@@ -20357,7 +20576,7 @@ function importSource(node) {
 }
 function requireSource(node) {
   const current = unwrap7(node);
-  if (current.type !== AST_NODE_TYPES82.CallExpression || current.callee.type !== AST_NODE_TYPES82.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES82.SpreadElement) return null;
+  if (current.type !== AST_NODE_TYPES83.CallExpression || current.callee.type !== AST_NODE_TYPES83.Identifier || current.callee.name !== "require" || current.arguments.length !== 1 || current.arguments[0]?.type === AST_NODE_TYPES83.SpreadElement) return null;
   return stringValue(current.arguments[0]);
 }
 function newScope() {
@@ -20380,6 +20599,27 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
       const bindingOf = (node) => ASTUtils47.findVariable(context.sourceCode.getScope(node), node.name);
+      const assertionKind = (node) => {
+        const binding = bindingOf(node);
+        if (binding === null || binding.defs.length === 0) {
+          return node.name === "assert" || node.name === "expect" ? node.name : null;
+        }
+        for (const definition of binding.defs) {
+          const specifier = definition.node;
+          if (specifier.type !== AST_NODE_TYPES83.ImportSpecifier && specifier.type !== AST_NODE_TYPES83.ImportDefaultSpecifier && specifier.type !== AST_NODE_TYPES83.ImportNamespaceSpecifier || specifier.parent.type !== AST_NODE_TYPES83.ImportDeclaration) continue;
+          const source = importSource(specifier.parent);
+          if (source !== null && ASSERT_MODULES.has(source)) {
+            if (specifier.type !== AST_NODE_TYPES83.ImportSpecifier) return "assert";
+            const imported2 = specifier.imported.type === AST_NODE_TYPES83.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (imported2 === "strict" || ASSERT_MATCHERS.has(imported2)) return "assert";
+            continue;
+          }
+          if (source === null || !EXPECT_MODULES.has(source) || specifier.type !== AST_NODE_TYPES83.ImportSpecifier) continue;
+          const imported = specifier.imported.type === AST_NODE_TYPES83.Identifier ? specifier.imported.name : String(specifier.imported.value);
+          if (imported === "assert" || imported === "expect") return imported;
+        }
+        return null;
+      };
       const visible = (kind, node) => {
         const name2 = bindingOf(node);
         if (name2 === null || name2.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
@@ -20402,70 +20642,70 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         const current = unwrap7(node);
         const value = stringValue(current);
         if (value !== null) return sourceSuffixRe.test(value);
-        if (current.type === AST_NODE_TYPES82.Identifier) return visible("paths", current);
-        if (current.type === AST_NODE_TYPES82.CallExpression || current.type === AST_NODE_TYPES82.NewExpression) {
+        if (current.type === AST_NODE_TYPES83.Identifier) return visible("paths", current);
+        if (current.type === AST_NODE_TYPES83.CallExpression || current.type === AST_NODE_TYPES83.NewExpression) {
           const callee = current.callee;
           const first = current.arguments[0];
-          if (first === void 0 || first.type === AST_NODE_TYPES82.SpreadElement) return false;
-          if (current.type === AST_NODE_TYPES82.NewExpression && callee.type === AST_NODE_TYPES82.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
-          if (callee.type === AST_NODE_TYPES82.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES82.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES82.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES82.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
+          if (first === void 0 || first.type === AST_NODE_TYPES83.SpreadElement) return false;
+          if (current.type === AST_NODE_TYPES83.NewExpression && callee.type === AST_NODE_TYPES83.Identifier && callee.name === "URL" && (bindingOf(callee)?.defs.length ?? 0) === 0) return sourcePath(first);
+          if (callee.type === AST_NODE_TYPES83.Identifier && bindingOf(callee)?.defs.some((definition) => definition.node.type === AST_NODE_TYPES83.ImportSpecifier && definition.node.imported.type === AST_NODE_TYPES83.Identifier && definition.node.imported.name === "fileURLToPath" && definition.node.parent.type === AST_NODE_TYPES83.ImportDeclaration && ["node:url", "url"].includes(String(definition.node.parent.source.value)))) return sourcePath(first);
         }
         return false;
       };
       const rawRead = (node) => {
         const current = unwrap7(node);
-        if (current.type !== AST_NODE_TYPES82.CallExpression || current.arguments.length === 0) return false;
+        if (current.type !== AST_NODE_TYPES83.CallExpression || current.arguments.length === 0) return false;
         const callee = unwrap7(current.callee);
-        if (callee.type === AST_NODE_TYPES82.Identifier) {
+        if (callee.type === AST_NODE_TYPES83.Identifier) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
-        if (callee.type !== AST_NODE_TYPES82.MemberExpression) return false;
-        const name2 = staticMemberName7(callee);
+        if (callee.type !== AST_NODE_TYPES83.MemberExpression) return false;
+        const name2 = staticMemberName8(callee);
         const object = unwrap7(callee.object);
-        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES82.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
+        return name2 !== null && FS_READERS.has(name2) && object.type === AST_NODE_TYPES83.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
       const rawOrigins = (node) => {
         const current = unwrap7(node);
-        if (current.type === AST_NODE_TYPES82.Identifier) return visibleRawOrigins(current);
+        if (current.type === AST_NODE_TYPES83.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
-        if (current.type === AST_NODE_TYPES82.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES82.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
-        if (current.type !== AST_NODE_TYPES82.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES83.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES83.MemberExpression && staticMemberName8(current) === "length") return rawOrigins(current.object);
+        if (current.type !== AST_NODE_TYPES83.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES82.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = staticMemberName7(callee);
+        if (callee.type !== AST_NODE_TYPES83.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = staticMemberName8(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
       const evidenceOrigins = (node) => {
         const current = unwrap7(node);
         const direct = rawOrigins(current);
         if (direct.size > 0) return direct;
-        if (current.type === AST_NODE_TYPES82.BinaryExpression || current.type === AST_NODE_TYPES82.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
-        if (current.type === AST_NODE_TYPES82.UnaryExpression) return evidenceOrigins(current.argument);
-        if (current.type !== AST_NODE_TYPES82.CallExpression) return /* @__PURE__ */ new Set();
+        if (current.type === AST_NODE_TYPES83.BinaryExpression || current.type === AST_NODE_TYPES83.LogicalExpression) return /* @__PURE__ */ new Set([...evidenceOrigins(current.left), ...evidenceOrigins(current.right)]);
+        if (current.type === AST_NODE_TYPES83.UnaryExpression) return evidenceOrigins(current.argument);
+        if (current.type !== AST_NODE_TYPES83.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
-        if (callee.type !== AST_NODE_TYPES82.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = staticMemberName7(callee);
+        if (callee.type !== AST_NODE_TYPES83.MemberExpression) return /* @__PURE__ */ new Set();
+        const name2 = staticMemberName8(callee);
         if (name2 !== null && TEXT_PREDICATES.has(name2)) return rawOrigins(callee.object);
-        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES82.SpreadElement ? [] : [...rawOrigins(argument)]));
+        if (name2 !== null && REGEXP_PREDICATES.has(name2)) return new Set(current.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES83.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap7(node.callee);
-        if (callee.type === AST_NODE_TYPES82.Identifier && callee.name === "assert") {
-          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES82.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (callee.type === AST_NODE_TYPES83.Identifier && assertionKind(callee) === "assert") {
+          return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES83.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (callee.type !== AST_NODE_TYPES82.MemberExpression) return /* @__PURE__ */ new Set();
-        const matcher = staticMemberName7(callee);
+        if (callee.type !== AST_NODE_TYPES83.MemberExpression) return /* @__PURE__ */ new Set();
+        const matcher = staticMemberName8(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap7(callee.object);
-        while (receiver.type === AST_NODE_TYPES82.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
-        if (receiver.type === AST_NODE_TYPES82.CallExpression && receiver.callee.type === AST_NODE_TYPES82.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === AST_NODE_TYPES83.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName8(receiver) ?? "")) receiver = unwrap7(receiver.object);
+        if (receiver.type === AST_NODE_TYPES83.CallExpression && receiver.callee.type === AST_NODE_TYPES83.Identifier && assertionKind(receiver.callee) === "expect") {
           if (!EXPECT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES82.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+          return new Set([...receiver.arguments, ...node.arguments].flatMap((argument) => argument.type === AST_NODE_TYPES83.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== AST_NODE_TYPES82.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
-        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES82.SpreadElement ? [] : [...evidenceOrigins(argument)]));
+        if (receiver.type !== AST_NODE_TYPES83.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        return new Set(node.arguments.flatMap((argument) => argument.type === AST_NODE_TYPES83.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
         const name2 = bindingOf(node);
@@ -20487,7 +20727,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       };
       const sourceCollection = (node) => {
         const current = unwrap7(node);
-        return current.type === AST_NODE_TYPES82.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES82.SpreadElement && sourcePath(element));
+        return current.type === AST_NODE_TYPES83.ArrayExpression && current.elements.length > 0 && current.elements.every((element) => element !== null && element.type !== AST_NODE_TYPES83.SpreadElement && sourcePath(element));
       };
       const enterFunction = () => {
         scopes.push(newScope());
@@ -20500,8 +20740,8 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           const source = importSource(node);
           if (source === null || !FS_MODULES.has(source)) return;
           for (const specifier of node.specifiers) {
-            if (specifier.type === AST_NODE_TYPES82.ImportSpecifier) {
-              const imported = specifier.imported.type === AST_NODE_TYPES82.Identifier ? specifier.imported.name : String(specifier.imported.value);
+            if (specifier.type === AST_NODE_TYPES83.ImportSpecifier) {
+              const imported = specifier.imported.type === AST_NODE_TYPES83.Identifier ? specifier.imported.name : String(specifier.imported.value);
               if (FS_READERS.has(imported)) declare(specifier.local, { fsReader: true });
             } else {
               declare(specifier.local, { fsObject: true });
@@ -20514,30 +20754,30 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           if (node.init === null) return;
           const required = requireSource(node.init);
           const initializer = unwrap7(node.init);
-          if (required !== null && initializer.type === AST_NODE_TYPES82.CallExpression && initializer.callee.type === AST_NODE_TYPES82.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
-          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES82.Identifier) {
+          if (required !== null && initializer.type === AST_NODE_TYPES83.CallExpression && initializer.callee.type === AST_NODE_TYPES83.Identifier && (bindingOf(initializer.callee)?.defs.length ?? 0) > 0) return;
+          if (required !== null && FS_MODULES.has(required) && node.id.type === AST_NODE_TYPES83.Identifier) {
             declare(node.id, { fsObject: true });
             return;
           }
-          if (node.id.type === AST_NODE_TYPES82.ObjectPattern && required !== null && FS_MODULES.has(required)) {
+          if (node.id.type === AST_NODE_TYPES83.ObjectPattern && required !== null && FS_MODULES.has(required)) {
             for (const property of node.id.properties) {
-              if (property.type !== AST_NODE_TYPES82.Property || property.value.type !== AST_NODE_TYPES82.Identifier) continue;
-              const key = property.key.type === AST_NODE_TYPES82.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES82.Literal ? String(property.key.value) : "";
+              if (property.type !== AST_NODE_TYPES83.Property || property.value.type !== AST_NODE_TYPES83.Identifier) continue;
+              const key = property.key.type === AST_NODE_TYPES83.Identifier ? property.key.name : property.key.type === AST_NODE_TYPES83.Literal ? String(property.key.value) : "";
               if (FS_READERS.has(key)) declare(property.value, { fsReader: true });
             }
             return;
           }
-          if (node.id.type !== AST_NODE_TYPES82.Identifier) return;
+          if (node.id.type !== AST_NODE_TYPES83.Identifier) return;
           declare(node.id, { collection: sourceCollection(node.init), path: sourcePath(node.init), rawOrigins: rawOrigins(node.init) });
         },
         AssignmentExpression(node) {
-          if (node.left.type === AST_NODE_TYPES82.Identifier) declare(node.left, {});
+          if (node.left.type === AST_NODE_TYPES83.Identifier) declare(node.left, {});
         },
         ForOfStatement(node) {
           const right = unwrap7(node.right);
-          const collection = right.type === AST_NODE_TYPES82.Identifier && visible("collections", right);
-          const left = node.left.type === AST_NODE_TYPES82.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
-          if (collection && left?.type === AST_NODE_TYPES82.Identifier) declare(left, { path: true });
+          const collection = right.type === AST_NODE_TYPES83.Identifier && visible("collections", right);
+          const left = node.left.type === AST_NODE_TYPES83.VariableDeclaration ? node.left.declarations[0]?.id : node.left;
+          if (collection && left?.type === AST_NODE_TYPES83.Identifier) declare(left, { path: true });
         },
         CallExpression(node) {
           const origins = rawAssertionOrigins(node);
@@ -20556,15 +20796,15 @@ var source_coupled_test_default = createSourceCoupledRule(
 );
 
 // src/rules/sole-export-matches-filename.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES83 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES84 } from "@typescript-eslint/utils";
 var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
-  summary: "Match a module filename to its sole named public runtime export.",
+  summary: "Make a module filename reflect its sole named public runtime export.",
   rationale: "When a module owns one runtime responsibility, matching names make that responsibility directly discoverable.",
-  remediation: "Rename the module stem to the kebab-case export name, or colocate genuinely related exports.",
+  remediation: "Name the module for the exported responsibility, using either the full export name or a clear leading or trailing domain phrase; otherwise colocate genuinely related exports.",
   category: "maintainability",
   limitations: [
     "Framework entrypoints, generic stems covered by no-generic-single-export-module, tests, generated files, anonymous defaults, CommonJS, and re-exports are excluded.",
-    "The rule compares the primary filename stem and preserves a single private underscore prefix and conventional suffixes such as .server or .worker.",
+    "The rule compares the primary filename stem and preserves a single private underscore prefix and conventional suffixes such as .server or .worker. A leading or trailing export-name phrase is accepted only at token boundaries; multi-token stems also tolerate established acronym spelling such as github versus GitHub.",
     "Exported destructuring patterns are excluded rather than undercounted as public exports."
   ],
   examples: [
@@ -20590,6 +20830,23 @@ var EXCLUDED_STEMS = /* @__PURE__ */ new Set([
   "util",
   "utils"
 ]);
+var WEAK_DOMAIN_TOKENS = /* @__PURE__ */ new Set([
+  "adapter",
+  "client",
+  "config",
+  "controller",
+  "factory",
+  "handler",
+  "manager",
+  "provider",
+  "record",
+  "repository",
+  "router",
+  "schema",
+  "service",
+  "store",
+  "worker"
+]);
 function stem3(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
   return base.replace(/\.[cm]?[jt]sx?$/u, "").split(".")[0] ?? "";
@@ -20597,13 +20854,32 @@ function stem3(filename) {
 function kebabCase(name) {
   return name.replace(/([A-Z]{2,})([A-Z][a-z])/gu, "$1-$2").replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[^a-z0-9]+/giu, "-").replaceAll(/^-+|-+$/gu, "").toLowerCase();
 }
+function reflectsExportName(fileStem, exportedStem) {
+  if (fileStem.startsWith("_")) return false;
+  const visibleFileStem = fileStem.toLowerCase();
+  const fileTokens = visibleFileStem.split("-").filter(Boolean);
+  const exportTokens = exportedStem.split("-").filter(Boolean);
+  if (fileTokens.length === 0 || exportTokens.length === 0) return false;
+  if (fileTokens.length === 1) {
+    const [token] = fileTokens;
+    return token !== void 0 && token.length >= 4 && !WEAK_DOMAIN_TOKENS.has(token) && (exportTokens[0] === token || exportTokens.at(-1) === token);
+  }
+  const compactFile = fileTokens.join("");
+  if (compactFile.length < 6) return false;
+  const boundaryPhrases = /* @__PURE__ */ new Set();
+  for (let index = 1; index <= exportTokens.length; index += 1) {
+    boundaryPhrases.add(exportTokens.slice(0, index).join(""));
+    boundaryPhrases.add(exportTokens.slice(-index).join(""));
+  }
+  return boundaryPhrases.has(compactFile);
+}
 function declarationExport(statement) {
   const declaration = statement.declaration;
   if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === AST_NODE_TYPES83.ClassDeclaration || declaration.type === AST_NODE_TYPES83.FunctionDeclaration || declaration.type === AST_NODE_TYPES83.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== AST_NODE_TYPES83.VariableDeclaration) return [];
+  if (declaration.type === AST_NODE_TYPES84.ClassDeclaration || declaration.type === AST_NODE_TYPES84.FunctionDeclaration || declaration.type === AST_NODE_TYPES84.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
+  if (declaration.type !== AST_NODE_TYPES84.VariableDeclaration) return [];
   return declaration.declarations.flatMap(
-    (item) => item.id.type === AST_NODE_TYPES83.Identifier ? [{ name: item.id.name, node: item }] : []
+    (item) => item.id.type === AST_NODE_TYPES84.Identifier ? [{ name: item.id.name, node: item }] : []
   );
 }
 var sole_export_matches_filename_default = createRule({
@@ -20611,7 +20887,7 @@ var sole_export_matches_filename_default = createRule({
   documentation: SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION,
   meta: {
     type: "suggestion",
-    docs: { description: "Match a module filename to its sole named public runtime export." },
+    docs: { description: SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION.summary },
     schema: [],
     messages: {
       matchSoleExport: "This module's sole runtime export is `{{exported}}`; rename the file stem to `{{expected}}`."
@@ -20627,32 +20903,32 @@ var sole_export_matches_filename_default = createRule({
         const exports = [];
         const publicExports = /* @__PURE__ */ new Set();
         for (const statement of program.body) {
-          if (statement.type === AST_NODE_TYPES83.ExportAllDeclaration || statement.type === AST_NODE_TYPES83.ExportNamedDeclaration && statement.source !== null) return;
-          if (statement.type === AST_NODE_TYPES83.ExportDefaultDeclaration) {
+          if (statement.type === AST_NODE_TYPES84.ExportAllDeclaration || statement.type === AST_NODE_TYPES84.ExportNamedDeclaration && statement.source !== null) return;
+          if (statement.type === AST_NODE_TYPES84.ExportDefaultDeclaration) {
             publicExports.add("default");
             const declaration2 = statement.declaration;
-            if ((declaration2.type === AST_NODE_TYPES83.ClassDeclaration || declaration2.type === AST_NODE_TYPES83.FunctionDeclaration) && declaration2.id !== null) exports.push({ name: declaration2.id.name, node: declaration2 });
+            if ((declaration2.type === AST_NODE_TYPES84.ClassDeclaration || declaration2.type === AST_NODE_TYPES84.FunctionDeclaration) && declaration2.id !== null) exports.push({ name: declaration2.id.name, node: declaration2 });
             else return;
           }
-          if (statement.type !== AST_NODE_TYPES83.ExportNamedDeclaration) continue;
+          if (statement.type !== AST_NODE_TYPES84.ExportNamedDeclaration) continue;
           const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES83.Identifier) {
+          if (declaration !== null && "id" in declaration && declaration.id?.type === AST_NODE_TYPES84.Identifier) {
             publicExports.add(declaration.id.name);
           }
-          if (declaration?.type === AST_NODE_TYPES83.VariableDeclaration) {
-            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES83.Identifier)) return;
+          if (declaration?.type === AST_NODE_TYPES84.VariableDeclaration) {
+            if (declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES84.Identifier)) return;
             for (const item of declaration.declarations) {
-              if (item.id.type === AST_NODE_TYPES83.Identifier) publicExports.add(item.id.name);
+              if (item.id.type === AST_NODE_TYPES84.Identifier) publicExports.add(item.id.name);
             }
           }
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES83.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES84.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
           }
           if (statement.exportKind === "type") continue;
           exports.push(...declarationExport(statement));
           for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === AST_NODE_TYPES83.Identifier ? specifier.exported.name : specifier.exported.value;
+            const exported = specifier.exported.type === AST_NODE_TYPES84.Identifier ? specifier.exported.name : specifier.exported.value;
             publicExports.add(String(exported));
             if (specifier.exportKind === "type") continue;
             if (exported === "default") exports.push({ name: specifier.local.name, node: specifier });
@@ -20664,11 +20940,11 @@ var sole_export_matches_filename_default = createRule({
         const only = [...unique.values()][0];
         if (only === void 0) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
-        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === AST_NODE_TYPES83.ImportDeclaration && statement.source.value === "astro:content")) return;
+        if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === AST_NODE_TYPES84.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
-        if (expected === fileStem.toLowerCase()) return;
+        if (expected === fileStem.toLowerCase() || reflectsExportName(fileStem, exportedStem)) return;
         context.report({ node: only.node, messageId: "matchSoleExport", data: { exported: only.name, expected } });
       }
     };
@@ -20715,7 +20991,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 
 // src/rules/require-pascal-case-zod-schema-name.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES84,
+  AST_NODE_TYPES as AST_NODE_TYPES85,
   ASTUtils as ASTUtils48
 } from "@typescript-eslint/utils";
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
@@ -20849,18 +21125,18 @@ var SCHEMA_RETURNING_METHODS = /* @__PURE__ */ new Set([
   "superRefine",
   "transform"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES84.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES85.Identifier ? callee.property.name : null;
 var calleeChainRoot2 = (node) => {
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES84.Identifier) {
+    if (current.type === AST_NODE_TYPES85.Identifier) {
       return current;
     }
-    if (current.type === AST_NODE_TYPES84.MemberExpression) {
+    if (current.type === AST_NODE_TYPES85.MemberExpression) {
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES84.CallExpression) {
+    if (current.type === AST_NODE_TYPES85.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -20871,13 +21147,13 @@ var chainMemberNames2 = (node) => {
   const names = [];
   let current = node;
   for (; ; ) {
-    if (current.type === AST_NODE_TYPES84.MemberExpression) {
-      if (current.computed || current.property.type !== AST_NODE_TYPES84.Identifier) return [];
+    if (current.type === AST_NODE_TYPES85.MemberExpression) {
+      if (current.computed || current.property.type !== AST_NODE_TYPES85.Identifier) return [];
       names.push(current.property.name);
       current = current.object;
       continue;
     }
-    if (current.type === AST_NODE_TYPES84.CallExpression) {
+    if (current.type === AST_NODE_TYPES85.CallExpression) {
       current = current.callee;
       continue;
     }
@@ -20886,18 +21162,18 @@ var chainMemberNames2 = (node) => {
   names.reverse();
   return names;
 };
-var unwrapExpression5 = (node) => {
+var unwrapExpression7 = (node) => {
   let current = node;
-  while (current.type === AST_NODE_TYPES84.TSAsExpression || current.type === AST_NODE_TYPES84.TSSatisfiesExpression || current.type === AST_NODE_TYPES84.TSNonNullExpression || current.type === AST_NODE_TYPES84.TSTypeAssertion) {
+  while (current.type === AST_NODE_TYPES85.TSAsExpression || current.type === AST_NODE_TYPES85.TSSatisfiesExpression || current.type === AST_NODE_TYPES85.TSNonNullExpression || current.type === AST_NODE_TYPES85.TSTypeAssertion) {
     current = current.expression;
   }
   return current;
 };
 var isModuleDeclarator = (node) => {
   const declaration = node.parent;
-  if (declaration.type !== AST_NODE_TYPES84.VariableDeclaration) return false;
+  if (declaration.type !== AST_NODE_TYPES85.VariableDeclaration) return false;
   const owner = declaration.parent;
-  return owner.type === AST_NODE_TYPES84.Program || owner.type === AST_NODE_TYPES84.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES84.Program;
+  return owner.type === AST_NODE_TYPES85.Program || owner.type === AST_NODE_TYPES85.ExportNamedDeclaration && owner.parent.type === AST_NODE_TYPES85.Program;
 };
 var require_pascal_case_zod_schema_name_default = createRule({
   name: "require-pascal-case-zod-schema-name",
@@ -20937,9 +21213,9 @@ var require_pascal_case_zod_schema_name_default = createRule({
       return binding !== null && schemaBindings.has(binding);
     }
     function isConfirmedSchema(expression) {
-      const init = unwrapExpression5(expression);
-      if (init.type === AST_NODE_TYPES84.Identifier) return isSchemaBinding(init);
-      if (init.type !== AST_NODE_TYPES84.CallExpression || init.callee.type !== AST_NODE_TYPES84.MemberExpression) {
+      const init = unwrapExpression7(expression);
+      if (init.type === AST_NODE_TYPES85.Identifier) return isSchemaBinding(init);
+      if (init.type !== AST_NODE_TYPES85.CallExpression || init.callee.type !== AST_NODE_TYPES85.MemberExpression) {
         return false;
       }
       const terminal = terminalMethodName(init.callee);
@@ -20959,7 +21235,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       ImportDeclaration(node) {
         if (!isZodModule(node.source.value)) return;
         for (const specifier of node.specifiers) {
-          if (specifier.type === AST_NODE_TYPES84.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES84.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES84.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES84.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
+          if (specifier.type === AST_NODE_TYPES85.ImportNamespaceSpecifier || specifier.type === AST_NODE_TYPES85.ImportDefaultSpecifier || specifier.type === AST_NODE_TYPES85.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES85.Identifier ? specifier.imported.name === "z" : specifier.imported.value === "z")) {
             recordZodBinding(specifier.local);
           }
         }
@@ -20968,7 +21244,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
         if (!isModuleDeclarator(node)) return;
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (node.id.type !== AST_NODE_TYPES84.Identifier) return;
+        if (node.id.type !== AST_NODE_TYPES85.Identifier) return;
         if (!isConfirmedSchema(init)) return;
         const binding = resolvedBinding(node.id);
         if (binding !== null) schemaBindings.add(binding);
@@ -21167,7 +21443,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.16"
+  version: "15.17.18"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {