@sarj/eslint-plugin 15.17.16 → 15.17.17

package/dist/index.cjs

@@ -2555,12 +2555,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: [
     {
@@ -2583,6 +2583,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,
@@ -2591,7 +2604,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: [],
@@ -2601,6 +2614,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" });
         }
       }
@@ -3719,12 +3738,41 @@ var no_hand_rolled_sleep_default = createRule({
 
 // src/rules/no-hand-rolled-spinner.ts
 var import_utils17 = require("@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 }
@@ -3750,6 +3798,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 === import_utils17.AST_NODE_TYPES.Literal && typeof value.value === "string") {
@@ -3792,8 +3844,12 @@ var no_hand_rolled_spinner_default = createRule({
         if (classNameAttribute?.type !== import_utils17.AST_NODE_TYPES.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" });
         }
       }
@@ -4036,31 +4092,31 @@ var no_insecure_random_id_default = createRule({
 // src/rules/no-detached-global-fetch.ts
 var import_utils19 = require("@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
@@ -4068,85 +4124,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 === import_utils19.AST_NODE_TYPES.ChainExpression || current.type === import_utils19.AST_NODE_TYPES.TSAsExpression || current.type === import_utils19.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils19.AST_NODE_TYPES.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 import_utils19.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
     }
     function resolvesToGlobal(identifier) {
-      const variable = import_utils19.ASTUtils.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = bindingOf(identifier);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalReceiver(node) {
       return node.type === import_utils19.AST_NODE_TYPES.Identifier && GLOBAL_RECEIVERS.has(node.name) && resolvesToGlobal(node);
     }
-    function isTypePosition(node) {
-      let parent = node.parent;
-      while (parent !== void 0) {
-        if (parent.type === import_utils19.AST_NODE_TYPES.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 === import_utils19.AST_NODE_TYPES.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 === import_utils19.AST_NODE_TYPES.CallExpression && node.parent.callee === node;
+    function isGlobalFetchMember(node) {
+      if (!isGlobalReceiver(node.object)) return false;
+      if (!node.computed) {
+        return node.property.type === import_utils19.AST_NODE_TYPES.Identifier && node.property.name === "fetch";
+      }
+      return node.property.type === import_utils19.AST_NODE_TYPES.Literal && node.property.value === "fetch";
     }
-    function isSafeExplicitReceiverUse(node) {
-      const member = node.parent;
-      if (member.type !== import_utils19.AST_NODE_TYPES.MemberExpression || member.object !== node || member.computed || member.property.type !== import_utils19.AST_NODE_TYPES.Identifier || !RECEIVER_METHODS.has(member.property.name)) {
-        return false;
+    function staticMemberName9(node) {
+      if (!node.computed) {
+        return node.property.type === import_utils19.AST_NODE_TYPES.Identifier ? node.property.name : null;
       }
-      const invocation = member.parent;
-      if (invocation.type !== import_utils19.AST_NODE_TYPES.CallExpression || invocation.callee !== member) {
-        return false;
+      return node.property.type === import_utils19.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+    }
+    function mayBeRawFetch(node) {
+      const expression = unwrapExpression(node);
+      if (expression.type === import_utils19.AST_NODE_TYPES.Identifier) {
+        if (expression.name === "fetch" && resolvesToGlobal(expression)) return true;
+        const variable = bindingOf(expression);
+        return variable !== null && aliases.has(variable) && isStableAlias(variable);
+      }
+      if (expression.type === import_utils19.AST_NODE_TYPES.MemberExpression) {
+        return isGlobalFetchMember(expression);
       }
-      const receiver = invocation.arguments[0];
-      if (receiver === void 0 || receiver.type === import_utils19.AST_NODE_TYPES.SpreadElement) return false;
-      if (node.type === import_utils19.AST_NODE_TYPES.MemberExpression) {
-        const original = receiverOf(node);
-        return original !== null && receiver.type === import_utils19.AST_NODE_TYPES.Identifier && receiver.name === original.name;
+      if (expression.type === import_utils19.AST_NODE_TYPES.LogicalExpression) {
+        return expression.operator === "&&" ? mayBeRawFetch(expression.right) : mayBeRawFetch(expression.left) || mayBeRawFetch(expression.right);
       }
-      return isGlobalReceiver(receiver);
+      if (expression.type === import_utils19.AST_NODE_TYPES.ConditionalExpression) {
+        return mayBeRawFetch(expression.consequent) || mayBeRawFetch(expression.alternate);
+      }
+      if (expression.type === import_utils19.AST_NODE_TYPES.SequenceExpression) {
+        const last = expression.expressions.at(-1);
+        return last !== void 0 && mayBeRawFetch(last);
+      }
+      return false;
     }
-    function reportIfDetached(node) {
-      if (isTypePosition(node) || isDirectCall(node) || isSafeExplicitReceiverUse(node)) return;
-      context.report({ node, messageId: "detachedGlobalFetch" });
+    function recordAliasFromValue(identifier, value) {
+      if (mayBeRawFetch(value)) recordAlias(identifier);
+    }
+    function reportStored(node) {
+      if (mayBeRawFetch(node)) context.report({ node, messageId: "detachedGlobalFetch" });
+    }
+    function isCompatibleReceiver(node) {
+      if (node === void 0 || node.type === import_utils19.AST_NODE_TYPES.SpreadElement) return false;
+      if (node.type !== import_utils19.AST_NODE_TYPES.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 === import_utils19.AST_NODE_TYPES.MemberExpression && parent.property === node) {
-          return;
-        }
-        if (parent.type === import_utils19.AST_NODE_TYPES.Property && parent.key === node && !parent.computed && !parent.shorthand) {
-          return;
+      AssignmentExpression(node) {
+        if (STORAGE_ASSIGNMENT_OPERATORS.has(node.operator) && node.left.type === import_utils19.AST_NODE_TYPES.MemberExpression) {
+          reportStored(node.right);
         }
-        reportIfDetached(node);
       },
-      "MemberExpression[computed=false]"(node) {
-        if (node.property.type !== import_utils19.AST_NODE_TYPES.Identifier || node.property.name !== "fetch" || !isGlobalReceiver(node.object)) {
+      AssignmentPattern(node) {
+        if (node.left.type !== import_utils19.AST_NODE_TYPES.Identifier) return;
+        recordAliasFromValue(node.left, node.right);
+        if (node.parent.type === import_utils19.AST_NODE_TYPES.TSParameterProperty) reportStored(node.right);
+      },
+      CallExpression(node) {
+        const callee = unwrapExpression(node.callee);
+        if (callee.type !== import_utils19.AST_NODE_TYPES.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 === import_utils19.AST_NODE_TYPES.ObjectPattern || node.method || node.value.type === import_utils19.AST_NODE_TYPES.AssignmentPattern || node.value.type === import_utils19.AST_NODE_TYPES.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 === import_utils19.AST_NODE_TYPES.Identifier) {
+          recordAliasFromValue(node.id, node.init);
           return;
         }
-        reportIfDetached(node);
+        if (node.id.type !== import_utils19.AST_NODE_TYPES.ObjectPattern || !isGlobalReceiver(unwrapExpression(node.init))) return;
+        for (const property of node.id.properties) {
+          if (property.type !== import_utils19.AST_NODE_TYPES.Property || property.computed || property.key.type !== import_utils19.AST_NODE_TYPES.Identifier || property.key.name !== "fetch") continue;
+          const value = property.value.type === import_utils19.AST_NODE_TYPES.AssignmentPattern ? property.value.left : property.value;
+          if (value.type === import_utils19.AST_NODE_TYPES.Identifier) recordAlias(value);
+        }
       }
     };
   }
@@ -4408,7 +4510,7 @@ var NO_JSON_STRINGIFY_OBJECT_EQUALITY_DOCUMENTATION = {
 };
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["!=", "!==", "==", "==="]);
 var PRIMITIVE_FLAGS = import_typescript.default.TypeFlags.BigIntLike | import_typescript.default.TypeFlags.BooleanLike | import_typescript.default.TypeFlags.ESSymbolLike | import_typescript.default.TypeFlags.Never | import_typescript.default.TypeFlags.Null | import_typescript.default.TypeFlags.NumberLike | import_typescript.default.TypeFlags.StringLike | import_typescript.default.TypeFlags.Undefined | import_typescript.default.TypeFlags.Void;
-function unwrapExpression(node) {
+function unwrapExpression2(node) {
   let current = node;
   while (current.type === import_utils21.AST_NODE_TYPES.ChainExpression || current.type === import_utils21.AST_NODE_TYPES.TSAsExpression || current.type === import_utils21.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils21.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
@@ -4416,10 +4518,10 @@ function unwrapExpression(node) {
   return current;
 }
 function jsonStringifyArgument(node, sourceCode) {
-  const expression = unwrapExpression(node);
+  const expression = unwrapExpression2(node);
   if (expression.type !== import_utils21.AST_NODE_TYPES.CallExpression) return null;
   const { callee } = expression;
-  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.object.name !== "JSON" || callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.property.name !== "stringify") {
+  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.object.name !== "JSON" || (!callee.computed ? callee.property.type !== import_utils21.AST_NODE_TYPES.Identifier || callee.property.name !== "stringify" : callee.property.type !== import_utils21.AST_NODE_TYPES.Literal || callee.property.value !== "stringify")) {
     return null;
   }
   const variable = import_utils21.ASTUtils.findVariable(sourceCode.getScope(callee.object), "JSON");
@@ -4447,7 +4549,7 @@ function typeMayContainObject(type, checker) {
   return true;
 }
 function syntaxMayContainObject(node) {
-  const expression = unwrapExpression(node);
+  const expression = unwrapExpression2(node);
   if (expression.type === import_utils21.AST_NODE_TYPES.ObjectExpression) return true;
   if (expression.type !== import_utils21.AST_NODE_TYPES.ArrayExpression) return null;
   for (const element of expression.elements) {
@@ -5076,7 +5178,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.",
@@ -5128,7 +5230,7 @@ function reportClass(context, services, owner) {
   }
 }
 function candidate(member) {
-  return member.type === import_utils26.AST_NODE_TYPES.MethodDefinition && member.kind !== "constructor" && !member.static && !member.computed && member.key.type === import_utils26.AST_NODE_TYPES.Identifier && member.value.body !== null;
+  return member.type === import_utils26.AST_NODE_TYPES.MethodDefinition && member.kind !== "constructor" && !member.static && member.accessibility !== "protected" && !member.override && !member.computed && member.key.type === import_utils26.AST_NODE_TYPES.Identifier && member.value.body !== null;
 }
 function interfaceNames(services, owner) {
   const tsOwner = services.esTreeNodeToTSNodeMap.get(owner);
@@ -5486,7 +5588,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 }
@@ -5507,10 +5609,11 @@ function importedName4(identifier, context, modules) {
   const variable = import_utils29.ASTUtils.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 !== import_utils29.AST_NODE_TYPES.ImportSpecifier) continue;
+    if (definition.node.type !== import_utils29.AST_NODE_TYPES.ImportSpecifier && definition.node.type !== import_utils29.AST_NODE_TYPES.ImportDefaultSpecifier && definition.node.type !== import_utils29.AST_NODE_TYPES.ImportNamespaceSpecifier) continue;
     const declaration = definition.node.parent;
     if (declaration.type !== import_utils29.AST_NODE_TYPES.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 !== import_utils29.AST_NODE_TYPES.ImportSpecifier) continue;
     const imported = definition.node.imported;
     return imported.type === import_utils29.AST_NODE_TYPES.Identifier ? imported.name : String(imported.value);
   }
@@ -5562,6 +5665,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 !== import_utils29.AST_NODE_TYPES.BlockStatement) return false;
+  return block.body.some(
+    (candidate2) => candidate2.range[1] <= node.range[0] && candidate2.type === import_utils29.AST_NODE_TYPES.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,
@@ -5587,11 +5697,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 === import_utils29.AST_NODE_TYPES.Identifier && node.parent === catchClause.body) {
+        const returnBlock = node.parent;
+        if (parameter?.type === import_utils29.AST_NODE_TYPES.Identifier && returnBlock?.type === import_utils29.AST_NODE_TYPES.BlockStatement) {
           const errorBinding = import_utils29.ASTUtils.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 !== import_utils29.AST_NODE_TYPES.ExpressionStatement) return false;
             const expression = statement.expression;
             if (expression.type !== import_utils29.AST_NODE_TYPES.CallExpression || !isAssertion(expression, context)) return false;
@@ -5605,7 +5716,7 @@ var no_bare_return_from_test_catch_default = createRule({
           });
           if (assertedError) return;
         }
-        if (walkOwnScope(catchClause.body, (current) => current.type === import_utils29.AST_NODE_TYPES.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" });
       }
@@ -5843,7 +5954,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.",
@@ -5886,6 +5998,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,
@@ -5908,7 +6023,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,
@@ -6972,12 +7087,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 === import_utils37.AST_NODE_TYPES.Literal && typeof node.value === "string" ? node.value : null;
+function staticModule(node) {
+  if (node?.type === import_utils37.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node?.type === import_utils37.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? null;
+  }
+  return null;
 }
 function matchesModule(source, module2) {
   return source === module2 || source.startsWith(`${module2}/`);
 }
+function staticMemberName4(node) {
+  if (!node.computed && node.property.type === import_utils37.AST_NODE_TYPES.Identifier) {
+    return node.property.name;
+  }
+  return node.computed && node.property.type === import_utils37.AST_NODE_TYPES.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,
@@ -7041,24 +7168,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 === import_utils37.AST_NODE_TYPES.Identifier && node.callee.name === "require") {
           requireIdentifier = node.callee;
-        } else if (node.callee.type === import_utils37.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.object.name === "require" && node.callee.property.type === import_utils37.AST_NODE_TYPES.Identifier && node.callee.property.name === "resolve") {
+        } else if (node.callee.type === import_utils37.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils37.AST_NODE_TYPES.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 !== import_utils37.AST_NODE_TYPES.TSExternalModuleReference) return;
-        const source = literalModule(node.moduleReference.expression);
+        const source = staticModule(node.moduleReference.expression);
         if (source !== null) report2(node.moduleReference.expression, source);
       }
     };
@@ -11098,7 +11225,7 @@ function rootIdentifier3(callee) {
   if (callee.type === import_utils60.AST_NODE_TYPES.TaggedTemplateExpression) return rootIdentifier3(callee.tag);
   return null;
 }
-function staticMemberName4(member) {
+function staticMemberName5(member) {
   if (!member.computed && member.property.type === import_utils60.AST_NODE_TYPES.Identifier) return member.property.name;
   if (member.computed && member.property.type === import_utils60.AST_NODE_TYPES.Literal && typeof member.property.value === "string") {
     return member.property.value;
@@ -11113,7 +11240,7 @@ function isTestBody2(node, isFrameworkTest) {
 function isTestCaller(callee) {
   if (callee.type === import_utils60.AST_NODE_TYPES.Identifier) return TEST_CALLERS3.has(callee.name);
   if (callee.type !== import_utils60.AST_NODE_TYPES.MemberExpression) return false;
-  const member = staticMemberName4(callee);
+  const member = staticMemberName5(callee);
   return member !== null && TEST_MODIFIERS3.has(member) && isTestCaller(callee.object);
 }
 function nearestEnclosingFunction2(node) {
@@ -11194,7 +11321,7 @@ function opensSubtest(node, callbackParameters) {
     return false;
   }
   const callee = node.callee;
-  return callee.type === import_utils60.AST_NODE_TYPES.MemberExpression && staticMemberName4(callee) === "test" && callee.object.type === import_utils60.AST_NODE_TYPES.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
+  return callee.type === import_utils60.AST_NODE_TYPES.MemberExpression && staticMemberName5(callee) === "test" && callee.object.type === import_utils60.AST_NODE_TYPES.Identifier && callbackParameters.has(callee.object.name) && node.arguments.some(
     (argument) => argument.type !== import_utils60.AST_NODE_TYPES.SpreadElement && FUNCTION_TYPES6.has(argument.type)
   );
 }
@@ -11244,7 +11371,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 === import_utils60.AST_NODE_TYPES.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 === import_utils60.AST_NODE_TYPES.Identifier ? [parameter.name] : [])
         );
@@ -11272,9 +11399,9 @@ var test_loops_over_literal_cases_default = createRule({
     };
   }
 });
-function unwrapExpression2(node) {
+function unwrapExpression3(node) {
   if (node.type === import_utils60.AST_NODE_TYPES.TSAsExpression || node.type === import_utils60.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils60.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils60.AST_NODE_TYPES.TSNonNullExpression) {
-    return unwrapExpression2(node.expression);
+    return unwrapExpression3(node.expression);
   }
   return node;
 }
@@ -12061,14 +12188,14 @@ function isAsConst(node, sourceText) {
   if (node.type !== import_utils68.AST_NODE_TYPES.TSAsExpression) return false;
   return sourceText(node.typeAnnotation).trim() === "const";
 }
-function unwrapExpression3(node) {
+function unwrapExpression4(node) {
   if (node.type === import_utils68.AST_NODE_TYPES.TSAsExpression || node.type === import_utils68.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils68.AST_NODE_TYPES.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 === import_utils68.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils68.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal3(inner.callee.object) && inner.callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1) {
     const argument = inner.arguments[0];
     return argument !== void 0 && argument.type !== import_utils68.AST_NODE_TYPES.SpreadElement && collectionKind(argument, isUnshadowedGlobal3) === "literal";
@@ -12076,7 +12203,7 @@ function isObjectFreeze(node, isUnshadowedGlobal3) {
   return false;
 }
 function collectionKind(node, isUnshadowedGlobal3) {
-  const inner = unwrapExpression3(node);
+  const inner = unwrapExpression4(node);
   if (inner.type === import_utils68.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils68.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils68.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && isUnshadowedGlobal3(inner.callee.object) && inner.callee.property.type === import_utils68.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils68.AST_NODE_TYPES.SpreadElement) {
     return collectionKind(inner.arguments[0], isUnshadowedGlobal3);
   }
@@ -15503,17 +15630,18 @@ var prefer_schema_for_api_payload_default = createRule({
 // src/rules/prefer-shared-zod-enum.ts
 var import_utils83 = require("@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 !== import_utils83.AST_NODE_TYPES.ArrayExpression || argument.elements.length < 2) return null;
   const values = [];
@@ -15539,7 +15667,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."
@@ -15550,7 +15678,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) => import_utils83.ASTUtils.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;
@@ -15568,10 +15696,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" });
+          }
+        }
       }
     };
   }
@@ -15646,35 +15783,6 @@ var prefer_switch_for_repeated_equality_default = createRule({
 var import_utils85 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("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.",
@@ -16728,7 +16836,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 === import_utils88.AST_NODE_TYPES.Identifier) return node.property.name;
   if (node.computed && node.property.type === import_utils88.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
@@ -16755,7 +16863,7 @@ function isDirectTestCallback2(node, context) {
 function testRoot2(callee) {
   if (callee.type === import_utils88.AST_NODE_TYPES.Identifier) return callee;
   if (callee.type !== import_utils88.AST_NODE_TYPES.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) {
@@ -16819,7 +16927,7 @@ function expectCallFromMatcher(node) {
   const modifiers = [];
   let receiver = node.object;
   while (receiver.type === import_utils88.AST_NODE_TYPES.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 +18515,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 === import_utils94.AST_NODE_TYPES.PrivateIdentifier) return `#${member.property.name}`;
   if (!member.computed && member.property.type === import_utils94.AST_NODE_TYPES.Identifier) return member.property.name;
   return member.computed && member.property.type === import_utils94.AST_NODE_TYPES.Literal && typeof member.property.value === "string" ? member.property.value : null;
@@ -18500,8 +18608,8 @@ var readConstructor = (ctor, declared, typeParameters) => {
       if (current === void 0) break;
       if (current.type === import_utils94.AST_NODE_TYPES.ArrowFunctionExpression || current.type === import_utils94.AST_NODE_TYPES.FunctionExpression || current.type === import_utils94.AST_NODE_TYPES.FunctionDeclaration || current.type === import_utils94.AST_NODE_TYPES.ClassExpression || current.type === import_utils94.AST_NODE_TYPES.ClassDeclaration) continue;
       const expression = current.type === import_utils94.AST_NODE_TYPES.ExpressionStatement ? current.expression : null;
-      const storedField = expression?.type === import_utils94.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils94.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils94.AST_NODE_TYPES.ThisExpression ? staticMemberName6(expression.left) : null;
-      if (expression?.type !== import_utils94.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS.has(expression.operator) || expression.left.type !== import_utils94.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils94.AST_NODE_TYPES.ThisExpression || storedField === null) {
+      const storedField = expression?.type === import_utils94.AST_NODE_TYPES.AssignmentExpression && expression.left.type === import_utils94.AST_NODE_TYPES.MemberExpression && expression.left.object.type === import_utils94.AST_NODE_TYPES.ThisExpression ? staticMemberName7(expression.left) : null;
+      if (expression?.type !== import_utils94.AST_NODE_TYPES.AssignmentExpression || !STORAGE_ASSIGNMENT_OPERATORS2.has(expression.operator) || expression.left.type !== import_utils94.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils94.AST_NODE_TYPES.ThisExpression || storedField === null) {
         for (const key of Object.keys(current)) {
           if (key === "parent") continue;
           const value = current[key];
@@ -18525,7 +18633,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 +18765,7 @@ var invokedInstanceField = (call) => {
 var instanceField = (candidate2) => {
   let node = candidate2;
   while (node.type === import_utils94.AST_NODE_TYPES.ChainExpression || node.type === import_utils94.AST_NODE_TYPES.TSAsExpression || node.type === import_utils94.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils94.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils94.AST_NODE_TYPES.TSTypeAssertion) node = node.expression;
-  return node.type === import_utils94.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils94.AST_NODE_TYPES.ThisExpression ? staticMemberName6(node) : null;
+  return node.type === import_utils94.AST_NODE_TYPES.MemberExpression && node.object.type === import_utils94.AST_NODE_TYPES.ThisExpression ? staticMemberName7(node) : null;
 };
 var behaviorallyInvokedFields = (body2) => {
   const invoked = /* @__PURE__ */ new Set();
@@ -19247,14 +19355,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 === import_utils96.AST_NODE_TYPES.TSAsExpression || node.type === import_utils96.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils96.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils96.AST_NODE_TYPES.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 === import_utils96.AST_NODE_TYPES.Literal) {
     return true;
   }
@@ -19274,9 +19382,8 @@ function isStaticValue(node) {
   return false;
 }
 function propertyName5(property) {
-  if (property.computed) return null;
-  if (property.key.type === import_utils96.AST_NODE_TYPES.Identifier) return property.key.name;
-  return typeof property.key.value === "string" ? property.key.value : null;
+  if (!property.computed && property.key.type === import_utils96.AST_NODE_TYPES.Identifier) return property.key.name;
+  return property.key.type === import_utils96.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
 }
 var require_static_next_matcher_default = createRule({
   name: "require-static-next-matcher",
@@ -19305,7 +19412,7 @@ var require_static_next_matcher_default = createRule({
           if (declaration.id.type !== import_utils96.AST_NODE_TYPES.Identifier || declaration.id.name !== "config" || declaration.init === null) {
             continue;
           }
-          const config = unwrapExpression4(declaration.init);
+          const config = unwrapExpression5(declaration.init);
           if (config.type !== import_utils96.AST_NODE_TYPES.ObjectExpression) {
             continue;
           }
@@ -19326,38 +19433,44 @@ var require_static_next_matcher_default = createRule({
 // src/rules/require-use-form-default-values.ts
 var import_utils97 = require("@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 === import_utils97.AST_NODE_TYPES.Identifier) return property.key.name;
+  if (property.key.type === import_utils97.AST_NODE_TYPES.Literal && typeof property.key.value === "string") return property.key.value;
+  return null;
+}
+function unwrapExpression6(node) {
+  if (node.type === import_utils97.AST_NODE_TYPES.TSAsExpression || node.type === import_utils97.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils97.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils97.AST_NODE_TYPES.TSTypeAssertion) return unwrapExpression6(node.expression);
+  return node;
 }
 var require_use_form_default_values_default = createRule({
   name: "require-use-form-default-values",
@@ -19366,27 +19479,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) => import_utils97.ASTUtils.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 === import_utils97.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils97.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
+    };
+    const initializationState = (node) => {
+      if (node === void 0) return "uninitialized";
+      if (node.type !== import_utils97.AST_NODE_TYPES.ObjectExpression) return "unknown";
+      const initialization = /* @__PURE__ */ new Map();
+      for (const property of node.properties) {
+        if (property.type === import_utils97.AST_NODE_TYPES.SpreadElement || property.computed) return "unknown";
+        if (property.type !== import_utils97.AST_NODE_TYPES.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 !== import_utils97.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils97.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useForm") return false;
+      const options = node.arguments[0];
+      return options?.type !== import_utils97.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
+    };
+    const isUninitializedForm = (node) => {
+      if (node.type !== import_utils97.AST_NODE_TYPES.Identifier) return false;
+      const variable = bindingOf(node);
+      return variable !== null && stable(variable) && uninitializedForms.has(variable);
+    };
+    const isUninitializedControl = (node) => {
+      if (node.type === import_utils97.AST_NODE_TYPES.Identifier) {
+        const variable = bindingOf(node);
+        return variable !== null && stable(variable) && uninitializedControls.has(variable);
+      }
+      return node.type === import_utils97.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils97.AST_NODE_TYPES.Identifier && node.property.name === "control" && isUninitializedForm(node.object);
+    };
+    const fieldOptionsNeedDefault = (node) => {
+      if (node?.type !== import_utils97.AST_NODE_TYPES.ObjectExpression) return false;
+      let control = null;
+      let hasDefault = false;
+      for (const property of node.properties) {
+        if (property.type === import_utils97.AST_NODE_TYPES.SpreadElement || property.computed) return false;
+        if (property.type !== import_utils97.AST_NODE_TYPES.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 === import_utils97.AST_NODE_TYPES.JSXSpreadAttribute) return null;
+        if (attribute.name.type === import_utils97.AST_NODE_TYPES.JSXIdentifier && attribute.name.name === name) result = attribute;
+      }
+      return result;
+    };
+    const trackDestructuredControl = (pattern) => {
+      for (const property of pattern.properties) {
+        if (property.type !== import_utils97.AST_NODE_TYPES.Property || staticPropertyName(property) !== "control" || property.value.type !== import_utils97.AST_NODE_TYPES.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 = import_utils97.ASTUtils.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
-          if (variable) importedHooks.add(variable);
+          if (specifier.type !== import_utils97.AST_NODE_TYPES.ImportSpecifier) continue;
+          const name = specifier.imported.type === import_utils97.AST_NODE_TYPES.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 === import_utils97.AST_NODE_TYPES.Identifier) {
+            const variable = bindingOf(node.id);
+            if (variable !== null) uninitializedForms.add(variable);
+          } else if (node.id.type === import_utils97.AST_NODE_TYPES.ObjectPattern) {
+            trackDestructuredControl(node.id);
+          }
+          return;
+        }
+        if (node.id.type === import_utils97.AST_NODE_TYPES.ObjectPattern && isUninitializedForm(node.init)) {
+          trackDestructuredControl(node.id);
+          return;
+        }
+        if (node.id.type === import_utils97.AST_NODE_TYPES.Identifier && node.init.type === import_utils97.AST_NODE_TYPES.MemberExpression && !node.init.computed && node.init.property.type === import_utils97.AST_NODE_TYPES.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 = import_utils97.ASTUtils.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 !== import_utils97.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useController" || !fieldOptionsNeedDefault(node.arguments[0]?.type === import_utils97.AST_NODE_TYPES.SpreadElement ? void 0 : node.arguments[0])) return;
+        context.report({ node, messageId: "requireUseFormDefaultValues" });
+      },
+      JSXOpeningElement(node) {
+        if (node.name.type !== import_utils97.AST_NODE_TYPES.JSXIdentifier || importedJsxKind(node.name) !== "Controller") return;
+        if (node.attributes.some((attribute) => attribute.type === import_utils97.AST_NODE_TYPES.JSXSpreadAttribute)) return;
+        const control = jsxAttribute(node, "control");
+        if (control?.value?.type !== import_utils97.AST_NODE_TYPES.JSXExpressionContainer || control.value.expression.type === import_utils97.AST_NODE_TYPES.JSXEmptyExpression || !isUninitializedControl(control.value.expression)) return;
+        const defaultValue = jsxAttribute(node, "defaultValue");
+        if (defaultValue !== null && (defaultValue.value === null || defaultValue.value.type !== import_utils97.AST_NODE_TYPES.JSXExpressionContainer || defaultValue.value.expression.type !== import_utils97.AST_NODE_TYPES.JSXEmptyExpression && !isDefinitelyUndefined(defaultValue.value.expression))) return;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
       }
     };
@@ -20260,7 +20473,7 @@ var stepdown_default = createRule({
 
 // src/rules/source-coupled-test.ts
 var import_utils102 = require("@typescript-eslint/utils");
-var GENERAL_SOURCE_SUFFIX_RE = /\.(?:bash|sh|ya?ml|jsonc|py|[cm]?[jt]s)$/iu;
+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([
@@ -20297,6 +20510,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.",
@@ -20304,6 +20519,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: [
@@ -20327,7 +20543,7 @@ var SOURCE_COUPLED_TEST_DOCUMENTATION = {
     }
   ]
 };
-function staticMemberName7(node) {
+function staticMemberName8(node) {
   if (!node.computed && node.property.type === import_utils102.AST_NODE_TYPES.Identifier) return node.property.name;
   if (node.computed && node.property.type === import_utils102.AST_NODE_TYPES.Literal && typeof node.property.value === "string") return node.property.value;
   return null;
@@ -20377,6 +20593,27 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
       const reportedOrigins = /* @__PURE__ */ new Set();
       const currentScope = () => scopes.at(-1) ?? scopes[0];
       const bindingOf = (node) => import_utils102.ASTUtils.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 !== import_utils102.AST_NODE_TYPES.ImportSpecifier && specifier.type !== import_utils102.AST_NODE_TYPES.ImportDefaultSpecifier && specifier.type !== import_utils102.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.parent.type !== import_utils102.AST_NODE_TYPES.ImportDeclaration) continue;
+          const source = importSource(specifier.parent);
+          if (source !== null && ASSERT_MODULES.has(source)) {
+            if (specifier.type !== import_utils102.AST_NODE_TYPES.ImportSpecifier) return "assert";
+            const imported2 = specifier.imported.type === import_utils102.AST_NODE_TYPES.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 !== import_utils102.AST_NODE_TYPES.ImportSpecifier) continue;
+          const imported = specifier.imported.type === import_utils102.AST_NODE_TYPES.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;
@@ -20417,7 +20654,7 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
           return visible("fsReaders", callee) && sourcePath(current.arguments[0]);
         }
         if (callee.type !== import_utils102.AST_NODE_TYPES.MemberExpression) return false;
-        const name2 = staticMemberName7(callee);
+        const name2 = staticMemberName8(callee);
         const object = unwrap7(callee.object);
         return name2 !== null && FS_READERS.has(name2) && object.type === import_utils102.AST_NODE_TYPES.Identifier && visible("fsObjects", object) && sourcePath(current.arguments[0]);
       };
@@ -20426,11 +20663,11 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         if (current.type === import_utils102.AST_NODE_TYPES.Identifier) return visibleRawOrigins(current);
         if (rawRead(current)) return /* @__PURE__ */ new Set([`${current.range[0]}:${current.range[1]}`]);
         if (current.type === import_utils102.AST_NODE_TYPES.BinaryExpression && current.operator === "+") return /* @__PURE__ */ new Set([...rawOrigins(current.left), ...rawOrigins(current.right)]);
-        if (current.type === import_utils102.AST_NODE_TYPES.MemberExpression && staticMemberName7(current) === "length") return rawOrigins(current.object);
+        if (current.type === import_utils102.AST_NODE_TYPES.MemberExpression && staticMemberName8(current) === "length") return rawOrigins(current.object);
         if (current.type !== import_utils102.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
         if (callee.type !== import_utils102.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = staticMemberName7(callee);
+        const name2 = staticMemberName8(callee);
         return name2 !== null && TEXT_TRANSFORMS.has(name2) ? rawOrigins(callee.object) : /* @__PURE__ */ new Set();
       };
       const evidenceOrigins = (node) => {
@@ -20442,26 +20679,26 @@ function createSourceCoupledRule(name, documentation, sourceSuffixRe) {
         if (current.type !== import_utils102.AST_NODE_TYPES.CallExpression) return /* @__PURE__ */ new Set();
         const callee = unwrap7(current.callee);
         if (callee.type !== import_utils102.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const name2 = staticMemberName7(callee);
+        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 === import_utils102.AST_NODE_TYPES.SpreadElement ? [] : [...rawOrigins(argument)]));
         return /* @__PURE__ */ new Set();
       };
       const rawAssertionOrigins = (node) => {
         const callee = unwrap7(node.callee);
-        if (callee.type === import_utils102.AST_NODE_TYPES.Identifier && callee.name === "assert") {
+        if (callee.type === import_utils102.AST_NODE_TYPES.Identifier && assertionKind(callee) === "assert") {
           return new Set(node.arguments.flatMap((argument) => argument.type === import_utils102.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
         if (callee.type !== import_utils102.AST_NODE_TYPES.MemberExpression) return /* @__PURE__ */ new Set();
-        const matcher = staticMemberName7(callee);
+        const matcher = staticMemberName8(callee);
         if (matcher === null) return /* @__PURE__ */ new Set();
         let receiver = unwrap7(callee.object);
-        while (receiver.type === import_utils102.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName7(receiver) ?? "")) receiver = unwrap7(receiver.object);
-        if (receiver.type === import_utils102.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils102.AST_NODE_TYPES.Identifier && receiver.callee.name === "expect") {
+        while (receiver.type === import_utils102.AST_NODE_TYPES.MemberExpression && EXPECT_MODIFIERS2.has(staticMemberName8(receiver) ?? "")) receiver = unwrap7(receiver.object);
+        if (receiver.type === import_utils102.AST_NODE_TYPES.CallExpression && receiver.callee.type === import_utils102.AST_NODE_TYPES.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 === import_utils102.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
         }
-        if (receiver.type !== import_utils102.AST_NODE_TYPES.Identifier || receiver.name !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
+        if (receiver.type !== import_utils102.AST_NODE_TYPES.Identifier || assertionKind(receiver) !== "assert" || !ASSERT_MATCHERS.has(matcher)) return /* @__PURE__ */ new Set();
         return new Set(node.arguments.flatMap((argument) => argument.type === import_utils102.AST_NODE_TYPES.SpreadElement ? [] : [...evidenceOrigins(argument)]));
       };
       const declare = (node, state) => {
@@ -20555,13 +20792,13 @@ var source_coupled_test_default = createSourceCoupledRule(
 // src/rules/sole-export-matches-filename.ts
 var import_utils103 = require("@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: [
@@ -20587,6 +20824,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] ?? "";
@@ -20594,6 +20848,25 @@ 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 [];
@@ -20608,7 +20881,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}}`."
@@ -20665,7 +20938,7 @@ var sole_export_matches_filename_default = createRule({
         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 } });
       }
     };
@@ -20880,7 +21153,7 @@ var chainMemberNames2 = (node) => {
   names.reverse();
   return names;
 };
-var unwrapExpression5 = (node) => {
+var unwrapExpression7 = (node) => {
   let current = node;
   while (current.type === import_utils104.AST_NODE_TYPES.TSAsExpression || current.type === import_utils104.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils104.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils104.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
@@ -20931,7 +21204,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       return binding !== null && schemaBindings.has(binding);
     }
     function isConfirmedSchema(expression) {
-      const init = unwrapExpression5(expression);
+      const init = unwrapExpression7(expression);
       if (init.type === import_utils104.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
       if (init.type !== import_utils104.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils104.AST_NODE_TYPES.MemberExpression) {
         return false;
@@ -21161,7 +21434,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.16"
+  version: "15.17.17"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {