@sarj/eslint-plugin 15.17.9 → 15.17.10

package/dist/index.js

@@ -2406,7 +2406,7 @@ var no_duplicate_lifecycle_refresh_listeners_default = createRule({
       VariableDeclarator(node) {
         if (node.id.type !== AST_NODE_TYPES9.Identifier) return;
         const variable = ASTUtils3.findVariable(context.sourceCode.getScope(node.id), node.id.name);
-        if (variable === null) return;
+        if (variable === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) return;
         if (node.init?.type === AST_NODE_TYPES9.ArrowFunctionExpression || node.init?.type === AST_NODE_TYPES9.FunctionExpression) {
           functionCallbacks.set(node.init, variable);
         }
@@ -2417,7 +2417,7 @@ var no_duplicate_lifecycle_refresh_listeners_default = createRule({
       FunctionDeclaration(node) {
         if (node.id === null) return;
         const variable = ASTUtils3.findVariable(context.sourceCode.getScope(node.id), node.id.name);
-        if (variable !== null) functionCallbacks.set(node, variable);
+        if (variable !== null && !variable.references.some((reference) => reference.isWrite() && !reference.init)) functionCallbacks.set(node, variable);
       },
       CallExpression(node) {
         const item = registration(context.sourceCode, node);
@@ -4434,105 +4434,9 @@ import * as ts from "typescript";
 import {
   AST_NODE_TYPES as AST_NODE_TYPES16
 } from "@typescript-eslint/utils";
-function symbolAt(services, checker, node) {
-  return checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node));
-}
-function sameSymbol(left, right) {
-  return left !== void 0 && right !== void 0 && left === right;
-}
-function enclosingClass(node) {
-  let current = node.parent;
-  while (current !== void 0) {
-    if (current.type === AST_NODE_TYPES16.ClassDeclaration || current.type === AST_NODE_TYPES16.ClassExpression) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
 function memberName2(member) {
   return !member.computed && member.key.type === AST_NODE_TYPES16.Identifier ? member.key.name : null;
 }
-function privateMemberFixes(context, services, owner, members, removePrivateKeyword) {
-  const first = members[0];
-  const name = first === void 0 ? null : memberName2(first);
-  if (first === void 0 || name === null || members.some((member) => member.static || member.decorators.length > 0)) {
-    return void 0;
-  }
-  if (owner.body.body.some((member) => {
-    if (member.type !== AST_NODE_TYPES16.MethodDefinition && member.type !== AST_NODE_TYPES16.PropertyDefinition && member.type !== AST_NODE_TYPES16.AccessorProperty) return false;
-    return member.key.type === AST_NODE_TYPES16.PrivateIdentifier && member.key.name === name;
-  })) return void 0;
-  const selectedMembers = new Set(members);
-  if (owner.body.body.some((member) => {
-    if (member.type !== AST_NODE_TYPES16.MethodDefinition && member.type !== AST_NODE_TYPES16.PropertyDefinition && member.type !== AST_NODE_TYPES16.AccessorProperty) return false;
-    return memberName2(member) === name && !selectedMembers.has(member);
-  })) return void 0;
-  const checker = services.program.getTypeChecker();
-  const symbols = members.map((member) => symbolAt(services, checker, member.key)).filter(
-    (symbol) => symbol !== void 0
-  );
-  if (symbols.length === 0) return void 0;
-  const references = [];
-  let unsafe = false;
-  walk(context.sourceCode.ast, context.sourceCode.visitorKeys, (node) => {
-    if (node.type === AST_NODE_TYPES16.Literal && node.value === name) {
-      unsafe = true;
-      return;
-    }
-    if (node.type !== AST_NODE_TYPES16.MemberExpression) return;
-    const propertyName6 = node.property.type === AST_NODE_TYPES16.Identifier || node.property.type === AST_NODE_TYPES16.PrivateIdentifier ? node.property.name : node.property.type === AST_NODE_TYPES16.Literal && typeof node.property.value === "string" ? node.property.value : null;
-    if (propertyName6 !== name) return;
-    const propertySymbol = symbolAt(services, checker, node.property);
-    if (node.computed || node.property.type !== AST_NODE_TYPES16.Identifier || node.object.type !== AST_NODE_TYPES16.ThisExpression || enclosingClass(node) !== owner || !symbols.some((symbol) => sameSymbol(symbol, propertySymbol))) {
-      unsafe = true;
-      return;
-    }
-    references.push(node);
-  });
-  if (unsafe) return void 0;
-  const privateKeywordRanges = /* @__PURE__ */ new Map();
-  if (removePrivateKeyword) {
-    const comments = context.sourceCode.getAllComments();
-    for (const member of members) {
-      const keyword = context.sourceCode.getTokens(member).find((token) => token.value === "private");
-      const next = keyword === void 0 ? void 0 : context.sourceCode.getTokenAfter(keyword);
-      if (keyword === void 0 || next === null || next === void 0) return void 0;
-      if (comments.some((comment) => comment.range[0] >= keyword.range[1] && comment.range[1] <= next.range[0])) {
-        return void 0;
-      }
-      privateKeywordRanges.set(member, [keyword.range[0], next.range[0]]);
-    }
-  }
-  return (fixer) => {
-    const fixes = [];
-    for (const member of members) {
-      fixes.push(fixer.replaceText(member.key, `#${name}`));
-      if (removePrivateKeyword) {
-        const range = privateKeywordRanges.get(member);
-        if (range === void 0) return [];
-        fixes.push(fixer.removeRange(range));
-      }
-    }
-    for (const reference of references) fixes.push(fixer.replaceText(reference.property, `#${name}`));
-    return fixes;
-  };
-}
-function walk(node, visitorKeys, visit) {
-  visit(node);
-  for (const key of visitorKeys[node.type] ?? []) {
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) {
-        if (typeof item === "object" && item !== null && "type" in item) {
-          walk(item, visitorKeys, visit);
-        }
-      }
-    } else if (typeof child === "object" && child !== null && "type" in child) {
-      walk(child, visitorKeys, visit);
-    }
-  }
-}
 function convertibleMemberName(member) {
   if (member.type !== AST_NODE_TYPES16.MethodDefinition && member.type !== AST_NODE_TYPES16.PropertyDefinition && member.type !== AST_NODE_TYPES16.AccessorProperty) return null;
   return memberName2(member);
@@ -5337,9 +5241,9 @@ var NO_GENERIC_SINGLE_EXPORT_MODULE_DOCUMENTATION = {
   rationale: "A generic filename hides the sole exported responsibility and makes navigation less descriptive.",
   remediation: "Choose a responsibility-bearing module name or colocate the export with its domain.",
   category: "maintainability",
-  limitations: ["Only configured generic stems with exactly one public runtime export are reported."],
+  limitations: ["Only the fixed generic-stem vocabulary with exactly one public runtime export is checked; exported destructuring patterns are excluded rather than undercounted."],
   examples: [
-    { id: "responsibility-named-module", title: "Name the module after its export", outcome: "no-match", files: [{ path: "src/order-parser.ts", source: "export function parseOrder() { return {}; }" }], focusPath: "src/order-parser.ts", expectedCount: 0, public: true },
+    { id: "responsibility-named-module", title: "Name the module after its export", outcome: "no-match", files: [{ path: "src/parse-order.ts", source: "export function parseOrder() { return {}; }" }], focusPath: "src/parse-order.ts", expectedCount: 0, public: true },
     { id: "generic-module-name", title: "Do not hide one export in a generic module", outcome: "match", files: [{ path: "src/utils.ts", source: "export function parseOrder() { return {}; }" }], focusPath: "src/utils.ts", expectedCount: 1, public: true }
   ]
 };
@@ -5400,6 +5304,7 @@ function runtimeExports(program) {
     }
     if (statement.declaration !== null) {
       const declaration = statement.declaration;
+      if (declaration.type === AST_NODE_TYPES22.VariableDeclaration && declaration.declarations.some((item) => item.id.type !== AST_NODE_TYPES22.Identifier)) ambiguous = true;
       exports.push(...declaredNames(declaration).map((name) => ({ key: name, name, node: declaration })));
     }
     for (const specifier of statement.specifiers) {
@@ -5558,7 +5463,7 @@ var no_offset_pagination_default = createRule({
 });
 
 // src/rules/no-positional-tuple-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES23 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES23, ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
 var NO_POSITIONAL_TUPLE_RETURN_DOCUMENTATION = {
   summary: "Disallow returning a multi-field tuple from a named function; return a named object so call sites cannot mismatch slots.",
   rationale: "Tuple fields are identified only by position, so reordering can preserve types while changing meaning.",
@@ -5588,7 +5493,7 @@ function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
     return argument === void 0 ? null : tupleReturnType(argument, aliases, resolving);
   }
   if (node.type === AST_NODE_TYPES23.TSTypeReference && node.typeName.type === AST_NODE_TYPES23.Identifier && !resolving.has(node.typeName.name)) {
-    const target = aliases.get(node.typeName.name);
+    const target = aliases.get(node.typeName);
     if (target !== void 0) return tupleReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
   }
   if (node.type === AST_NODE_TYPES23.TSTypeOperator && node.operator === "readonly") {
@@ -5680,20 +5585,27 @@ function exportedTypeNames(program) {
   }
   return names;
 }
-function typeAliases(program) {
+function typeAliases(sourceCode) {
   const aliases = /* @__PURE__ */ new Map();
-  for (const statement of program.body) {
+  for (const statement of sourceCode.ast.body) {
     const declaration = statement.type === AST_NODE_TYPES23.ExportNamedDeclaration ? statement.declaration : statement;
     if (declaration?.type === AST_NODE_TYPES23.TSTypeAliasDeclaration) {
-      aliases.set(declaration.id.name, declaration.typeAnnotation);
+      aliases.set(declaration.id.name, declaration);
     }
   }
-  return aliases;
+  return {
+    get(identifier) {
+      const declaration = aliases.get(identifier.name);
+      if (declaration === void 0) return void 0;
+      const binding = ASTUtils9.findVariable(sourceCode.getScope(identifier), identifier.name);
+      return binding?.defs.length === 1 && binding.defs[0]?.node === declaration ? declaration.typeAnnotation : void 0;
+    }
+  };
 }
 function callableReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
   if (node.type === AST_NODE_TYPES23.TSFunctionType) return node.returnType?.typeAnnotation ?? null;
   if (node.type === AST_NODE_TYPES23.TSTypeReference && node.typeName.type === AST_NODE_TYPES23.Identifier && !resolving.has(node.typeName.name)) {
-    const target = aliases.get(node.typeName.name);
+    const target = aliases.get(node.typeName);
     if (target !== void 0) {
       return callableReturnType(target, aliases, /* @__PURE__ */ new Set([...resolving, node.typeName.name]));
     }
@@ -5822,7 +5734,7 @@ var no_positional_tuple_return_default = createRule({
       context.sourceCode.ast,
       exportedTypeNames(context.sourceCode.ast)
     );
-    const aliases = typeAliases(context.sourceCode.ast);
+    const aliases = typeAliases(context.sourceCode);
     const reportedFunctions = /* @__PURE__ */ new WeakSet();
     const functionStack = [];
     const report2 = (annotation, name) => {
@@ -5986,7 +5898,7 @@ var no_production_browser_source_maps_default = createRule({
 });
 
 // src/rules/no-raw-env.ts
-import { ASTUtils as ASTUtils9 } from "@typescript-eslint/utils";
+import { ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
 var NO_RAW_ENV_DOCUMENTATION = {
   summary: "Disallow direct `process.env` and `import.meta.env` reads outside validated boundaries.",
   rationale: "Raw environment reads are untyped and defer invalid configuration failures until use.",
@@ -6068,7 +5980,7 @@ var no_raw_env_default = createRule({
       },
       MemberExpression(node) {
         if (isProcessEnv(node) && node.object.type === "Identifier") {
-          const binding = ASTUtils9.findVariable(context.sourceCode.getScope(node), node.object.name);
+          const binding = ASTUtils10.findVariable(context.sourceCode.getScope(node), node.object.name);
           if (binding !== null && binding.defs.length > 0 && !binding.defs.every((definition) => definition.type === "ImportBinding" && definition.parent.type === "ImportDeclaration" && ["node:process", "process"].includes(definition.parent.source.value) && ["ImportDefaultSpecifier", "ImportNamespaceSpecifier"].includes(definition.node.type))) return;
         }
         if ((isProcessEnv(node) || isImportMetaEnv(node)) && !isExemptVariableAccess(node) && !isWriteTarget(node) && !isWholeEnvSpread(node)) {
@@ -6084,7 +5996,7 @@ var no_raw_env_default = createRule({
 });
 
 // src/rules/no-raw-fetch-outside-clients.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES24, ASTUtils as ASTUtils10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES24, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
 var NO_RAW_FETCH_OUTSIDE_CLIENTS_DOCUMENTATION = {
   summary: "Disallow calling the global `fetch` outside the client layer; route outbound HTTP through a client module that owns retry, timeout and status handling.",
   rationale: "Scattered fetch calls bypass shared transport policy and are harder to stub and observe consistently.",
@@ -6272,7 +6184,7 @@ var no_raw_fetch_outside_clients_default = createRule({
       internalApiPrefixes.push(`${options.basePath}/api`);
     }
     function resolvesToGlobal(identifier) {
-      const variable = ASTUtils10.findVariable(
+      const variable = ASTUtils11.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -6281,7 +6193,7 @@ var no_raw_fetch_outside_clients_default = createRule({
     function resolveNode2(node) {
       if (node === void 0) return null;
       if (node.type !== AST_NODE_TYPES24.Identifier) return node;
-      const variable = ASTUtils10.findVariable(
+      const variable = ASTUtils11.findVariable(
         context.sourceCode.getScope(node),
         node.name
       );
@@ -6360,13 +6272,13 @@ var no_raw_fetch_outside_clients_default = createRule({
 });
 
 // src/rules/no-restricted-library-load.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES25, ASTUtils as ASTUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES25, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
 var NO_RESTRICTED_LIBRARY_LOAD_DOCUMENTATION = {
-  summary: "Apply a configured library-replacement policy to literal dynamic imports, CommonJS loads, and TypeScript import-equals declarations.",
-  rationale: "Runtime module loads can bypass the replacement policy enforced for static imports.",
-  remediation: "Load the configured replacement library instead of the restricted module.",
+  summary: "Apply configured library restrictions to literal runtime loads and CommonJS resolution references.",
+  rationale: "Dynamic imports, CommonJS loads, and package resolution checks can bypass library restrictions enforced for static imports.",
+  remediation: "Use the configured replacement for the runtime dependency reference; resolution checks do not themselves load a module.",
   category: "architecture",
-  limitations: ["Only literal dynamic imports, unshadowed CommonJS loads, and TypeScript import-equals declarations are checked."],
+  limitations: ["Only literal dynamic imports, unshadowed CommonJS loads/resolution calls, and runtime TypeScript import-equals declarations are checked; erased type imports are excluded. A configured restriction list is required."],
   examples: [
     { id: "static-import", title: "Static imports remain the static-import rule's responsibility", outcome: "no-match", files: [{ path: "src/client.ts", source: "import axios from 'axios';" }], focusPath: "src/client.ts", expectedCount: 0, public: true },
     { 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 }
@@ -6384,7 +6296,7 @@ var no_restricted_library_load_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Apply a configured library-replacement policy to literal dynamic imports, CommonJS loads, and TypeScript import-equals declarations."
+      description: NO_RESTRICTED_LIBRARY_LOAD_DOCUMENTATION.summary
     },
     schema: [
       {
@@ -6410,7 +6322,7 @@ var no_restricted_library_load_default = createRule({
       }
     ],
     messages: {
-      restrictedLibraryLoad: "{{id}}: Replace runtime loading of {{module}} with {{replacement}}.{{note}}"
+      restrictedLibraryLoad: "{{id}}: Replace this runtime dependency reference to {{module}} with {{replacement}}.{{note}}"
     }
   },
   defaultOptions: [{ libraries: [] }],
@@ -6433,7 +6345,7 @@ var no_restricted_library_load_default = createRule({
       });
     }
     function isUnshadowedRequire(node) {
-      const variable = ASTUtils11.findVariable(
+      const variable = ASTUtils12.findVariable(
         context.sourceCode.getScope(node),
         node.name
       );
@@ -6456,6 +6368,7 @@ var no_restricted_library_load_default = createRule({
         if (source !== null) report2(node.arguments[0], source);
       },
       TSImportEqualsDeclaration(node) {
+        if (node.importKind === "type") return;
         if (node.moduleReference.type !== AST_NODE_TYPES25.TSExternalModuleReference) return;
         const source = literalModule(node.moduleReference.expression);
         if (source !== null) report2(node.moduleReference.expression, source);
@@ -6465,7 +6378,7 @@ var no_restricted_library_load_default = createRule({
 });
 
 // src/rules/no-router-refresh-polling.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES26, ASTUtils as ASTUtils12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES26, ASTUtils as ASTUtils13 } from "@typescript-eslint/utils";
 var NO_ROUTER_REFRESH_POLLING_DOCUMENTATION = {
   summary: "Do not poll by calling a Next.js router's refresh method from a timer.",
   rationale: "A route refresh refetches and rerenders the whole route on every tick instead of loading the named resource that changed.",
@@ -6495,7 +6408,7 @@ function isIntervalCallee(sourceCode, node) {
   return node.type === AST_NODE_TYPES26.Identifier && node.name === "setInterval" && isUnshadowedGlobal2(sourceCode, node) || node.type === AST_NODE_TYPES26.MemberExpression && !node.computed && node.object.type === AST_NODE_TYPES26.Identifier && (node.object.name === "window" || node.object.name === "globalThis") && isUnshadowedGlobal2(sourceCode, node.object) && node.property.type === AST_NODE_TYPES26.Identifier && node.property.name === "setInterval";
 }
 function isUnshadowedGlobal2(sourceCode, node) {
-  const variable = ASTUtils12.findVariable(sourceCode.getScope(node), node.name);
+  const variable = ASTUtils13.findVariable(sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 var no_router_refresh_polling_default = createRule({
@@ -6518,21 +6431,21 @@ var no_router_refresh_polling_default = createRule({
         if (node.source.value !== "next/navigation") return;
         for (const specifier of node.specifiers) {
           if (specifier.type === AST_NODE_TYPES26.ImportSpecifier && importedName4(specifier) === "useRouter") {
-            const variable = ASTUtils12.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+            const variable = ASTUtils13.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
             if (variable !== null) routerHooks.add(variable);
           }
         }
       },
       VariableDeclarator(node) {
         if (node.id.type === AST_NODE_TYPES26.Identifier && node.init?.type === AST_NODE_TYPES26.CallExpression && node.init.callee.type === AST_NODE_TYPES26.Identifier) {
-          const hook = ASTUtils12.findVariable(context.sourceCode.getScope(node.init.callee), node.init.callee.name);
-          const router = ASTUtils12.findVariable(context.sourceCode.getScope(node.id), node.id.name);
+          const hook = ASTUtils13.findVariable(context.sourceCode.getScope(node.init.callee), node.init.callee.name);
+          const router = ASTUtils13.findVariable(context.sourceCode.getScope(node.id), node.id.name);
           if (hook !== null && router !== null && routerHooks.has(hook)) routers.add(router);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== AST_NODE_TYPES26.MemberExpression || node.callee.computed || node.callee.object.type !== AST_NODE_TYPES26.Identifier || node.callee.property.type !== AST_NODE_TYPES26.Identifier || node.callee.property.name !== "refresh") return;
-        const router = ASTUtils12.findVariable(
+        const router = ASTUtils13.findVariable(
           context.sourceCode.getScope(node.callee.object),
           node.callee.object.name
         );
@@ -7590,13 +7503,13 @@ var no_select_star_default = createRule({
 });
 
 // src/rules/no-sentinel-return-on-catch.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES30 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES30, ASTUtils as ASTUtils14 } from "@typescript-eslint/utils";
 var NO_SENTINEL_RETURN_ON_CATCH_DOCUMENTATION = {
   summary: "Disallow swallowing a caught error by returning an empty sentinel unless the error is handled or the sentinel is part of the function contract.",
   rationale: "An unreported fallback makes operational failure indistinguishable from a legitimate empty result.",
   remediation: "Rethrow, report the error before returning, or model expected absence with an explicit predicate, safe-parse, or result contract.",
   category: "correctness",
-  limitations: ["Recognized predicate, safe-parse, normal-path sentinel, deliberate parse, generated-client, and configured logging patterns are excluded."],
+  limitations: ["Recognized predicate, safe-parse, normal-path sentinel, deliberate parse, generated-client, and configured logging patterns are excluded. Locally shadowed undefined bindings are not treated as sentinels; recognized handling patterns are not a proof that every control-flow path handles the error."],
   examples: [
     { id: "reported-fallback", title: "Report an error before returning a fallback", outcome: "no-match", files: [{ path: "src/load.ts", source: "function load() { try { return read(); } catch (error) { logger.warn('load failed', error); return null; } }" }], focusPath: "src/load.ts", expectedCount: 0, public: true },
     { id: "silent-fallback", title: "Do not turn an unreported error into absence", outcome: "match", files: [{ path: "src/load.ts", source: "function load() { try { return read(); } catch { return null; } }" }], focusPath: "src/load.ts", expectedCount: 1, public: true }
@@ -8011,6 +7924,8 @@ var no_sentinel_return_on_catch_default = createRule({
         if (!isSentinelArgument(last.argument)) {
           return;
         }
+        const returned = unwrapSentinelExpression(last.argument);
+        if (returned?.type === AST_NODE_TYPES30.Identifier && returned.name === "undefined" && (ASTUtils14.findVariable(context.sourceCode.getScope(returned), returned.name)?.defs.length ?? 0) > 0) return;
         if (containsThrow(node.body)) {
           return;
         }
@@ -8460,12 +8375,13 @@ var no_storage_in_stateless_modules_default = createRule({
 // src/rules/no-string-concat-in-loop.ts
 import "@typescript-eslint/utils";
 var NO_STRING_CONCAT_IN_LOOP_DOCUMENTATION = {
-  summary: "Disallow O(n^2) string building via `+=` on a string variable inside a loop; push parts to an array and `join` instead.",
+  summary: "Prefer collecting string fragments over repeatedly accumulating a growing string inside a loop.",
   rationale: "Repeatedly rebuilding a growing string can copy all prior content on each iteration, making total work grow quadratically.",
-  remediation: "Collect each fragment in an array, then join the fragments after the loop.",
+  remediation: "Consider collecting fragments and joining once; preserve intermediate observations and coercion timing, and measure hot paths.",
   category: "performance",
   limitations: [
-    "Only local identifiers initialized with a string or template literal and accumulated in a loop body are inspected."
+    "Only local identifiers initialized with a string or template literal and accumulated in a loop body are inspected.",
+    "Deferred function bodies are excluded except recognized direct forEach callbacks. Syntax does not establish engine-specific string allocation complexity."
   ],
   examples: [
     {
@@ -8583,6 +8499,7 @@ function enclosingLoop(node) {
     if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") && parent.parent.type === "CallExpression" && parent.parent.arguments[0] === parent && parent.parent.callee.type === "MemberExpression" && !parent.parent.callee.computed && parent.parent.callee.property.type === "Identifier" && parent.parent.callee.property.name === "forEach") {
       return parent.parent;
     }
+    if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration") return null;
     if (LOOP_NODE_TYPES.has(parent.type)) {
       const loop = parent;
       if (loop.body === child) {
@@ -8594,6 +8511,19 @@ function enclosingLoop(node) {
   }
   return null;
 }
+function immediatelyExitsLoop(node, loop) {
+  if (!LOOP_NODE_TYPES.has(loop.type) || node.parent.type !== "ExpressionStatement") return false;
+  const statement = node.parent;
+  const block = statement.parent;
+  if (block.type !== "BlockStatement") return false;
+  const next = block.body[block.body.indexOf(statement) + 1];
+  if (next?.type !== "BreakStatement" && next?.type !== "ReturnStatement" && next?.type !== "ThrowStatement") return false;
+  if (next.type === "BreakStatement" && next.label !== null) return false;
+  for (let current = block; current !== void 0 && current !== loop; current = current.parent) {
+    if (current.type === "TryStatement" || next.type === "BreakStatement" && current.type === "SwitchStatement") return false;
+  }
+  return true;
+}
 function isSmallStaticForLoop(node) {
   if (node.type !== "ForStatement" || node.init?.type !== "VariableDeclaration" || node.init.declarations.length !== 1 || node.test?.type !== "BinaryExpression" || node.test.operator !== "<" && node.test.operator !== "<=" || node.update?.type !== "UpdateExpression" || node.update.operator !== "++") {
     return false;
@@ -8632,12 +8562,12 @@ var no_string_concat_in_loop_default = createRule({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow O(n^2) string building via `+=` on a string variable inside a loop; push parts to an array and `join` instead."
+      description: NO_STRING_CONCAT_IN_LOOP_DOCUMENTATION.summary
     },
     schema: [],
     messages: {
-      noStringConcatInLoop: 'Avoid building a string with `+=` inside a loop \u2014 this is O(n^2). Push the parts onto an array and use `arr.join("")` after the loop.',
-      noStringReduce: "Avoid concatenating a growing string in `reduce` \u2014 this is O(n^2). Map the fragments and join them once instead."
+      noStringConcatInLoop: "This loop repeatedly accumulates a growing string. Consider collecting fragments and joining once; preserve coercion timing and intermediate reads, and measure performance-sensitive paths.",
+      noStringReduce: "This reduce repeatedly accumulates a growing string. Consider mapping fragments and joining once if coercion timing and intermediate observations are unchanged."
     }
   },
   defaultOptions: [],
@@ -8664,6 +8594,7 @@ var no_string_concat_in_loop_default = createRule({
         if (loop === null) {
           return;
         }
+        if (immediatelyExitsLoop(node, loop)) return;
         if (isSmallStaticForLoop(loop)) {
           return;
         }
@@ -10037,7 +9968,7 @@ var no_unnecessary_use_client_default = createRule({
 // src/rules/no-unsafe-mock-casting.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES40,
-  ASTUtils as ASTUtils13
+  ASTUtils as ASTUtils15
 } from "@typescript-eslint/utils";
 var MOCK_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Mock",
@@ -10103,7 +10034,7 @@ var no_unsafe_mock_casting_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve2(identifier) {
-      return ASTUtils13.findVariable(
+      return ASTUtils15.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -10153,7 +10084,7 @@ var no_unsafe_mock_casting_default = createRule({
 import {
   ESLintUtils as ESLintUtils3,
   AST_NODE_TYPES as AST_NODE_TYPES41,
-  ASTUtils as ASTUtils14
+  ASTUtils as ASTUtils16
 } from "@typescript-eslint/utils";
 import * as ts2 from "typescript";
 var NO_ZOD_NATIVE_ENUM_DOCUMENTATION = {
@@ -10263,7 +10194,7 @@ var no_zod_native_enum_default = createRule({
     const zodImportedBindings = /* @__PURE__ */ new Map();
     const zodNamespaceBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils14.findVariable(
+      return ASTUtils16.findVariable(
         sourceCode.getScope(identifier),
         identifier.name
       );
@@ -10329,7 +10260,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/test-loops-over-literal-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES42, ASTUtils as ASTUtils15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES42, ASTUtils as ASTUtils17 } from "@typescript-eslint/utils";
 var TEST_LOOPS_OVER_LITERAL_CASES_DOCUMENTATION = {
   summary: "Disallow assertions over an inline literal case loop in a test; parameterization reports and names every case independently.",
   rationale: "A loop is reported as one test, so failures hide the individual case name and may stop later cases from running.",
@@ -10492,7 +10423,7 @@ var test_loops_over_literal_cases_default = createRule({
       return {};
     }
     const isFrameworkIdentifier = (identifier, modules) => {
-      const variable = ASTUtils15.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils17.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable === null || variable.defs.length === 0) return true;
       return variable.defs.some((definition) => {
         let current = definition.node;
@@ -10740,13 +10671,12 @@ import {
 var PREFER_ECMASCRIPT_PRIVATE_MEMBERS_DOCUMENTATION = {
   summary: "Prefer ECMAScript `#private` class members over TypeScript-only `private` members.",
   rationale: "ECMAScript private names enforce encapsulation at runtime instead of erasing the boundary during compilation.",
-  remediation: "Replace the TypeScript `private` modifier and all proven same-class references with an ECMAScript private name.",
+  remediation: "Review reflection, instance escape and framework contracts before replacing TypeScript privacy with ECMAScript private names and updating references.",
   category: "maintainability",
-  autofix: "safe",
+  autofix: "none",
   limitations: [
     "Ambient, abstract, computed, decorated, override, parameter-property, and generated declarations are excluded.",
-    "A fix is offered only for an undecorated, unexported class declaration with no references outside its body and when type information proves every use is a direct `this.name` access inside that class.",
-    "Overloads, modifier-adjacent comments, reflection, and any potentially cross-file or escaping class remain report-only."
+    "Migration is report-only: type information cannot prove that instances or constructors never escape through this, or that reflection and framework serialization do not observe ordinary private properties."
   ],
   references: ["https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Private_elements"],
   examples: [
@@ -10766,19 +10696,11 @@ var PREFER_ECMASCRIPT_PRIVATE_MEMBERS_DOCUMENTATION = {
       files: [{ path: "src/vault.ts", source: "class Vault { private read() { return 1; } open() { return this.read(); } }" }],
       focusPath: "src/vault.ts",
       expectedCount: 1,
-      public: true,
-      fixedFiles: [{ path: "src/vault.ts", source: "class Vault { #read() { return 1; } open() { return this.#read(); } }" }]
+      public: true
     }
   ]
 };
-function reportClass2(context, services, owner) {
-  const parent = owner.parent;
-  const directlyExported = parent.type === AST_NODE_TYPES45.ExportNamedDeclaration || parent.type === AST_NODE_TYPES45.ExportDefaultDeclaration;
-  const locallyClosed = !directlyExported && owner.decorators.length === 0 && owner.type === AST_NODE_TYPES45.ClassDeclaration && context.sourceCode.getDeclaredVariables(owner).every(
-    (variable) => variable.references.every(
-      (reference) => reference.identifier.range[0] >= owner.range[0] && reference.identifier.range[1] <= owner.range[1]
-    )
-  );
+function reportClass2(context, owner) {
   const groups = /* @__PURE__ */ new Map();
   for (const member of owner.body.body) {
     if (!isConvertible(member)) continue;
@@ -10791,18 +10713,10 @@ function reportClass2(context, services, owner) {
   for (const [name, members] of groups) {
     const first = members[0];
     if (first === void 0) continue;
-    const fix = locallyClosed ? privateMemberFixes(
-      context,
-      services,
-      owner,
-      members,
-      true
-    ) : void 0;
     context.report({
       node: first.key,
       messageId: "preferEcmascriptPrivate",
-      data: { name },
-      ...fix === void 0 ? {} : { fix }
+      data: { name }
     });
   }
 }
@@ -10816,7 +10730,6 @@ var prefer_ecmascript_private_members_default = createRule({
   meta: {
     type: "suggestion",
     docs: { description: "Prefer ECMAScript `#private` class members over TypeScript-only `private` members." },
-    fixable: "code",
     schema: [],
     messages: {
       preferEcmascriptPrivate: "TypeScript `private {{name}}` is erased at runtime; use the ECMAScript private name `#{{name}}`."
@@ -10833,8 +10746,8 @@ var prefer_ecmascript_private_members_default = createRule({
     }
     if (services === null) return {};
     return {
-      ClassDeclaration: (node) => reportClass2(context, services, node),
-      ClassExpression: (node) => reportClass2(context, services, node)
+      ClassDeclaration: (node) => reportClass2(context, node),
+      ClassExpression: (node) => reportClass2(context, node)
     };
   }
 });
@@ -10844,10 +10757,10 @@ import "@typescript-eslint/utils";
 import { AST_NODE_TYPES as AST_NODE_TYPES46 } from "@typescript-eslint/utils";
 var PREFER_DISCRIMINATED_UNION_DOCUMENTATION = {
   summary: "Flag flat result objects with a required positive boolean status and optional success/failure payloads.",
-  rationale: "A boolean status plus optional branch data permits contradictory and incomplete states.",
-  remediation: "Represent each result branch as a discriminated union member with its required payload.",
+  rationale: "When success and failure are mutually exclusive outcomes, a boolean plus optional branch data permits contradictory and incomplete states.",
+  remediation: "If the outcomes are mutually exclusive, represent each branch as a discriminated union member with its required payload.",
   category: "correctness",
-  limitations: ["Only local object shapes with recognized positive status and payload names are inspected."],
+  limitations: ["Only local object shapes with recognized non-computed status and payload names are inspected. Names do not prove that partial-success outcomes are forbidden; review the domain before changing its representation."],
   examples: [
     { id: "explicit-result-branches", title: "Use explicit result branches", outcome: "no-match", files: [{ path: "src/result.ts", source: "type Result = { ok: true; data: string } | { ok: false; error: string };" }], focusPath: "src/result.ts", expectedCount: 0, public: true },
     { id: "optional-result-payloads", title: "Do not make both result payloads optional", outcome: "match", files: [{ path: "src/result.ts", source: "type Result = { ok: boolean; data?: string; error?: string };" }], focusPath: "src/result.ts", expectedCount: 1, public: true }
@@ -10911,7 +10824,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
 }
 function getMemberName(member) {
-  if (member.type !== AST_NODE_TYPES46.TSPropertySignature) {
+  if (member.type !== AST_NODE_TYPES46.TSPropertySignature || member.computed) {
     return null;
   }
   const { key } = member;
@@ -10947,7 +10860,7 @@ var prefer_discriminated_union_default = createRule({
     },
     schema: [],
     messages: {
-      preferDiscriminatedUnion: "This object type uses a boolean status flag alongside several optional fields, which lets illegal states be representable. Model it as a `z.discriminatedUnion` / discriminated union (e.g. `{ ok: true; data: T } | { ok: false; error: E }`) to make illegal states unrepresentable."
+      preferDiscriminatedUnion: "This object type combines a boolean status with optional payloads. If success and failure are mutually exclusive, consider a discriminated union such as `{ ok: true; data: T } | { ok: false; error: E }`."
     }
   },
   defaultOptions: [],
@@ -10987,7 +10900,7 @@ var prefer_discriminated_union_default = createRule({
 });
 
 // src/rules/prefer-input-group-search.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES47, ASTUtils as ASTUtils16 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES47, ASTUtils as ASTUtils18 } from "@typescript-eslint/utils";
 var PREFER_INPUT_GROUP_SEARCH_DOCUMENTATION = {
   summary: "Require search icons and shared Input controls in the same visual wrapper to use InputGroup.",
   rationale: "The shared compound control provides consistent spacing, focus behavior, and accessible composition.",
@@ -11111,7 +11024,7 @@ var prefer_input_group_search_default = createRule({
       JSXOpeningElement(node) {
         const name = elementName(node);
         if (name === null) return;
-        const binding = ASTUtils16.findVariable(context.sourceCode.getScope(node), name);
+        const binding = ASTUtils18.findVariable(context.sourceCode.getScope(node), name);
         if (binding?.defs.length !== 1 || binding.defs[0]?.node.type !== AST_NODE_TYPES47.ImportSpecifier || binding.defs[0].node.importKind === "type") return;
         const occurrence = {
           ancestors: context.sourceCode.getAncestors(node),
@@ -11151,7 +11064,7 @@ var prefer_input_group_search_default = createRule({
 
 // src/rules/prefer-millisecond-control-duration-schema.ts
 import {
-  ASTUtils as ASTUtils17,
+  ASTUtils as ASTUtils19,
   AST_NODE_TYPES as AST_NODE_TYPES48
 } from "@typescript-eslint/utils";
 var PREFER_MILLISECOND_CONTROL_DURATION_SCHEMA_DOCUMENTATION = {
@@ -11220,7 +11133,7 @@ var prefer_millisecond_control_duration_schema_default = createRule({
     const zodNamespaces = /* @__PURE__ */ new Set();
     const objectFactories = /* @__PURE__ */ new Set();
     function binding(identifier) {
-      return ASTUtils17.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils19.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(target, identifier) {
       const variable = binding(identifier);
@@ -11267,7 +11180,7 @@ var prefer_millisecond_control_duration_schema_default = createRule({
 });
 
 // src/rules/prefer-immutable-module-constant.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES49, ASTUtils as ASTUtils18 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES49, ASTUtils as ASTUtils20 } from "@typescript-eslint/utils";
 var PREFER_IMMUTABLE_MODULE_CONSTANT_DOCUMENTATION = {
   summary: "Require module-level constant collections to expose readonly state.",
   rationale: "A const binding prevents reassignment but does not stop callers from mutating its array, object, Set, or Map contents.",
@@ -11420,7 +11333,7 @@ var prefer_immutable_module_constant_default = createRule({
   create(context) {
     const sourceCode = context.sourceCode;
     const isUnshadowedGlobal3 = (identifier) => {
-      const variable = ASTUtils18.findVariable(sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils20.findVariable(sourceCode.getScope(identifier), identifier.name);
       return variable === null || variable.defs.length === 0;
     };
     if (JAVASCRIPT_FILE_RE.test(context.filename) || isTestFile(context.filename) || isGeneratedFile(context.filename, sourceCode.getText())) {
@@ -12579,7 +12492,7 @@ var prefer_module_level_schema_default = createRule({
 // src/rules/prefer-module-level-refined-schema.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES53,
-  ASTUtils as ASTUtils19
+  ASTUtils as ASTUtils21
 } from "@typescript-eslint/utils";
 var BENCHMARK_PATH_RE = /(^|[/\\])(?:benchmarks?|bench)[/\\]/;
 var FACTORIES = /* @__PURE__ */ new Set([
@@ -12850,7 +12763,7 @@ var prefer_module_level_refined_schema_default = createRule({
       return {};
     const zodBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils19.findVariable(
+      return ASTUtils21.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -12951,7 +12864,7 @@ var prefer_module_level_refined_schema_default = createRule({
 // src/rules/prefer-multi-value-zod-literal.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES54,
-  ASTUtils as ASTUtils20
+  ASTUtils as ASTUtils22
 } from "@typescript-eslint/utils";
 var PREFER_MULTI_VALUE_ZOD_LITERAL_DOCUMENTATION = {
   summary: "Use the Zod 4 multi-value literal API instead of a union of literal schemas.",
@@ -12998,7 +12911,7 @@ function isStaticPrimitive(node, context) {
   if (node.type === AST_NODE_TYPES54.TemplateLiteral && node.expressions.length === 0)
     return true;
   if (node.type === AST_NODE_TYPES54.Identifier && node.name === "undefined") {
-    const binding = ASTUtils20.findVariable(
+    const binding = ASTUtils22.findVariable(
       context.sourceCode.getScope(node),
       node.name
     );
@@ -13035,7 +12948,7 @@ var prefer_multi_value_zod_literal_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const zod4Bindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils20.findVariable(
+      return ASTUtils22.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -13106,7 +13019,7 @@ function isLiteralUnion(node) {
 function exportedContract(node) {
   let current = node;
   while (current !== void 0) {
-    if (current.type === AST_NODE_TYPES55.ExportNamedDeclaration) return true;
+    if (current.type === AST_NODE_TYPES55.TSTypeAliasDeclaration || current.type === AST_NODE_TYPES55.TSInterfaceDeclaration) return current.parent.type === AST_NODE_TYPES55.ExportNamedDeclaration;
     if (current.type === AST_NODE_TYPES55.Program) return false;
     current = current.parent ?? void 0;
   }
@@ -13197,14 +13110,14 @@ var prefer_named_complex_return_type_default = createRule({
 });
 
 // src/rules/prefer-native-random-uuid.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils21 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES57, ASTUtils as ASTUtils23 } from "@typescript-eslint/utils";
 var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   summary: "Prefer `globalThis.crypto.randomUUID()` over resolved zero-argument UUID v4 bindings from the `uuid` package.",
   rationale: "The platform implementation avoids an unnecessary dependency for standard random UUID generation.",
   remediation: "Call `globalThis.crypto.randomUUID()` and remove the unused `uuid` v4 import when possible.",
   category: "maintainability",
   autofix: "suggestion",
-  limitations: ["Only resolved zero-argument UUID v4 calls are reported; customized and other UUID versions are excluded."],
+  limitations: ["Only resolved zero-argument UUID v4 calls are reported; customized and other UUID versions are excluded. Suggestions require unshadowed globalThis and comment-free calls; verify native randomUUID availability in the deployment runtime."],
   examples: [
     { id: "native-random-uuid", title: "Use the platform UUID generator", outcome: "no-match", files: [{ path: "src/id.ts", source: "const id = globalThis.crypto.randomUUID();" }], focusPath: "src/id.ts", expectedCount: 0, public: true },
     { id: "uuid-v4-package", title: "Do not call uuid v4 without options", outcome: "match", files: [{ path: "src/id.ts", source: "import { v4 } from 'uuid'; const id = v4();" }], focusPath: "src/id.ts", expectedCount: 1, public: true }
@@ -13224,7 +13137,7 @@ var prefer_native_random_uuid_default = createRule({
     hasSuggestions: true,
     schema: [],
     messages: {
-      preferNative: "Use the Node 22 native `globalThis.crypto.randomUUID()` instead of the `uuid` package for UUID v4.",
+      preferNative: "Where supported by the deployment runtime, prefer native `globalThis.crypto.randomUUID()` over the `uuid` package for UUID v4.",
       replaceWithNative: "Replace this UUID v4 call with the native implementation."
     }
   },
@@ -13233,22 +13146,24 @@ var prefer_native_random_uuid_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve2(identifier) {
-      return ASTUtils21.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      return ASTUtils23.findVariable(context.sourceCode.getScope(identifier), identifier.name);
     }
     function record(identifier, destination) {
       const variable = resolve2(identifier);
       if (variable !== null) destination.add(variable);
     }
     function report2(node) {
+      const globalBinding = ASTUtils23.findVariable(context.sourceCode.getScope(node), "globalThis");
+      const canSuggest = (globalBinding?.defs.length ?? 0) === 0 && context.sourceCode.getCommentsInside(node).length === 0;
       context.report({
         node,
         messageId: "preferNative",
-        suggest: [
+        suggest: canSuggest ? [
           {
             messageId: "replaceWithNative",
             fix: (fixer) => fixer.replaceText(node, "globalThis.crypto.randomUUID()")
           }
-        ]
+        ] : []
       });
     }
     return {
@@ -13296,7 +13211,7 @@ var prefer_native_random_uuid_default = createRule({
 });
 
 // src/rules/prefer-node-crypto-hash.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES58, ASTUtils as ASTUtils22 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES58, ASTUtils as ASTUtils24 } from "@typescript-eslint/utils";
 var PREFER_NODE_CRYPTO_HASH_DOCUMENTATION = {
   summary: "Prefer the modern one-shot node:crypto hash API when streaming state is unnecessary.",
   rationale: "A createHash-update-digest chain allocates mutable streaming state for a single in-memory value; Node's built-in hash function expresses the one-shot operation directly and can use its optimized fast path.",
@@ -13352,7 +13267,7 @@ var prefer_node_crypto_hash_default = createRule({
     const directBindings = /* @__PURE__ */ new Set();
     const namespaceBindings = /* @__PURE__ */ new Set();
     function resolve2(identifier) {
-      return ASTUtils22.findVariable(
+      return ASTUtils24.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -13539,7 +13454,7 @@ var prefer_node_fs_promises_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES60, ASTUtils as ASTUtils23 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES60, ASTUtils as ASTUtils25 } from "@typescript-eslint/utils";
 var PREFER_NON_NULLABLE_COLLECTION_DOCUMENTATION = {
   summary: "Suggest non-null arrays only when local control flow proves the nullish state is equivalent to an empty collection.",
   rationale: "A redundant nullish collection state spreads defaults and guards through consumers without carrying information.",
@@ -13669,14 +13584,14 @@ function directlyCoalesced(node) {
   return parent?.type === AST_NODE_TYPES60.LogicalExpression && parent.left === node && (parent.operator === "??" || parent.operator === "||") && emptyArray(parent.right);
 }
 function identifierIsOnlyCoalesced(context, binding, fn) {
-  const variable = ASTUtils23.findVariable(context.sourceCode.getScope(binding), binding.name);
+  const variable = ASTUtils25.findVariable(context.sourceCode.getScope(binding), binding.name);
   if (variable === null || variable.references.length === 0) return false;
   return variable.references.every(
     (reference) => belongsToFunction(reference.identifier, fn) && directlyCoalesced(reference.identifier)
   );
 }
 function memberIsOnlyCoalesced(context, object, property, fn) {
-  const variable = ASTUtils23.findVariable(context.sourceCode.getScope(object), object.name);
+  const variable = ASTUtils25.findVariable(context.sourceCode.getScope(object), object.name);
   if (variable === null) return false;
   const accesses = variable.references.flatMap((reference) => {
     if (!belongsToFunction(reference.identifier, fn)) return [null];
@@ -13786,7 +13701,7 @@ var prefer_non_nullable_collection_default = createRule({
 // src/rules/prefer-nullish-filter-predicate.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES61,
-  ASTUtils as ASTUtils24,
+  ASTUtils as ASTUtils26,
   ESLintUtils as ESLintUtils5
 } from "@typescript-eslint/utils";
 import ts3 from "typescript";
@@ -13832,7 +13747,7 @@ var PREFER_NULLISH_FILTER_PREDICATE_DOCUMENTATION = {
   ]
 };
 function isUnshadowedBoolean(node, context) {
-  const variable = ASTUtils24.findVariable(context.sourceCode.getScope(node), node.name);
+  const variable = ASTUtils26.findVariable(context.sourceCode.getScope(node), node.name);
   return variable === null || variable.defs.length === 0;
 }
 function isBuiltinArrayFilter(node, services) {
@@ -13891,7 +13806,7 @@ function isProvablyTruthy(type, checker) {
 }
 function availableParameterName(node, context) {
   for (const name of ["value", "item", "element", "candidate"]) {
-    if (ASTUtils24.findVariable(context.sourceCode.getScope(node), name) === null) return name;
+    if (ASTUtils26.findVariable(context.sourceCode.getScope(node), name) === null) return name;
   }
   return null;
 }
@@ -13945,7 +13860,7 @@ var prefer_nullish_filter_predicate_default = createRule({
 
 // src/rules/prefer-await-in-async-return.ts
 import {
-  ASTUtils as ASTUtils25,
+  ASTUtils as ASTUtils27,
   ESLintUtils as ESLintUtils6,
   AST_NODE_TYPES as AST_NODE_TYPES62
 } from "@typescript-eslint/utils";
@@ -14059,13 +13974,13 @@ var prefer_await_in_async_return_default = createRule({
     if (services === null) return {};
     const frameworkLoaders = /* @__PURE__ */ new Set();
     const rememberFrameworkLoader = (identifier) => {
-      const variable = ASTUtils25.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+      const variable = ASTUtils27.findVariable(context.sourceCode.getScope(identifier), identifier.name);
       if (variable !== null) frameworkLoaders.add(variable);
     };
     const isFrameworkLoaderCallback = (owner) => {
       const parent = owner.parent;
       if (parent.type !== AST_NODE_TYPES62.CallExpression || parent.arguments[0] !== owner || parent.callee.type !== AST_NODE_TYPES62.Identifier) return false;
-      const variable = ASTUtils25.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
+      const variable = ASTUtils27.findVariable(context.sourceCode.getScope(parent.callee), parent.callee.name);
       return variable !== null && frameworkLoaders.has(variable);
     };
     return {
@@ -14691,6 +14606,7 @@ var PREFER_SWITCH_FOR_REPEATED_EQUALITY_DOCUMENTATION = {
   category: "maintainability",
   limitations: [
     "Only direct if/else-if chains with at least three strict-equality tests are reported.",
+    "The discriminant must be a bare identifier; calls, getters, indexed reads and other repeatedly evaluated expressions are excluded. Review case-value effects, selector mutation, branch scoping, and break/continue targets when converting manually; this is not an equivalence proof.",
     "Case values may be literals, enum-like member references, or upper-case named constants; dynamic expressions are excluded.",
     "The rule deliberately ignores compound predicates, loose equality, ranges, and chains that compare different discriminants."
   ],
@@ -14704,7 +14620,8 @@ function discriminantText(sourceCode, test) {
   const leftIsCase = isCaseValue(test.left);
   const rightIsCase = isCaseValue(test.right);
   if (leftIsCase === rightIsCase) return null;
-  return sourceCode.getText(leftIsCase ? test.right : test.left);
+  const discriminant = leftIsCase ? test.right : test.left;
+  return discriminant.type === AST_NODE_TYPES65.Identifier ? sourceCode.getText(discriminant) : null;
 }
 function isCaseValue(node) {
   if (node.type === AST_NODE_TYPES65.Literal) return true;
@@ -15294,7 +15211,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-import { ASTUtils as ASTUtils26 } from "@typescript-eslint/utils";
+import { ASTUtils as ASTUtils28 } from "@typescript-eslint/utils";
 var PREFER_SERVER_ACTIONS_DOCUMENTATION = {
   summary: "Prefer Next.js Server Actions over same-origin API mutations.",
   rationale: "Server Actions can remove a hand-written internal API wrapper while retaining typed application calls. Client invocations still cross a network and serialization boundary.",
@@ -15326,7 +15243,7 @@ function resolvesToGlobalFetch(context, identifier) {
 function resolveNode(node, context) {
   if (!node) return null;
   if (node.type !== "Identifier") return node;
-  const variable = ASTUtils26.findVariable(getScope(context, node), node.name);
+  const variable = ASTUtils28.findVariable(getScope(context, node), node.name);
   const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
   if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || variable?.references.some((reference) => reference.isWrite() && reference.init !== true)) return node;
   if (definition.node.init.type === "ObjectExpression" && variable?.references.some((reference) => reference.identifier !== node && reference.init !== true)) return node;
@@ -15335,7 +15252,7 @@ function resolveNode(node, context) {
 function isAxiosClient(node, context, seen = /* @__PURE__ */ new Set()) {
   if (node.type !== "Identifier" || seen.has(node)) return false;
   seen.add(node);
-  const variable = ASTUtils26.findVariable(getScope(context, node), node.name);
+  const variable = ASTUtils28.findVariable(getScope(context, node), node.name);
   const definition = variable?.defs.length === 1 ? variable.defs[0] : void 0;
   if (definition === void 0 || variable?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
   if (variable?.references.some((reference) => {
@@ -15804,7 +15721,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/repeated-static-call-cases.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES68, ASTUtils as ASTUtils27 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES68, ASTUtils as ASTUtils29 } from "@typescript-eslint/utils";
 var REPEATED_STATIC_CALL_CASES_DOCUMENTATION = {
   summary: "Report three or more consecutive literal call assertions that should be independently named test cases.",
   rationale: "Copy-pasted cases obscure the input table and stop later cases from being reported after the first failure.",
@@ -15830,7 +15747,7 @@ function staticMemberName5(node) {
   return null;
 }
 function importedName6(identifier, context, modules) {
-  const variable = ASTUtils27.findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  const variable = ASTUtils29.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_TYPES68.ImportSpecifier) continue;
@@ -15993,6 +15910,11 @@ var PREFER_ZOD_INFER_DOCUMENTATION = {
   rationale: "A derived type stays synchronized when the runtime schema changes.",
   remediation: "Replace the hand-written twin with `z.infer<typeof Schema>`.",
   category: "correctness",
+  limitations: [
+    "Only module-level const schemas and module-level type declarations are paired; local declarations are excluded rather than matched by spelling across scopes.",
+    "By default every field must positively agree; collection, nested-object and referenced-schema equivalence is not inferred from outer syntax alone.",
+    "This is a bounded syntactic comparison, not general type equivalence. Review schema input versus output, interface augmentation, and separately evolving domain contracts before replacing a declaration."
+  ],
   examples: [
     { id: "inferred-type", title: "Infer the schema type", outcome: "no-match", files: [{ path: "src/user.ts", source: 'import { z } from "zod"; const UserSchema = z.object({ id: z.string() }); type User = z.infer<typeof UserSchema>;' }], focusPath: "src/user.ts", expectedCount: 0, public: true },
     { id: "handwritten-twin", title: "Do not duplicate the schema shape", outcome: "match", files: [{ path: "src/user.ts", source: 'import { z } from "zod"; const UserSchema = z.object({ id: z.string() }); interface User { id: string }' }], focusPath: "src/user.ts", expectedCount: 1, public: true }
@@ -16172,6 +16094,10 @@ function sameDomain(left, right) {
 function isExportedDeclaration(node) {
   return node.parent?.type === AST_NODE_TYPES69.ExportNamedDeclaration;
 }
+function isModuleLevelDeclaration(node) {
+  const parent = node.parent;
+  return parent?.type === AST_NODE_TYPES69.Program || parent?.type === AST_NODE_TYPES69.ExportNamedDeclaration && parent.parent.type === AST_NODE_TYPES69.Program;
+}
 function isModuleLevelConst(node) {
   const declaration = node.parent;
   if (declaration.type !== AST_NODE_TYPES69.VariableDeclaration || declaration.kind !== "const") {
@@ -16222,6 +16148,9 @@ function leafAgrees(field, annotation) {
     return annotationDomain !== null && sameDomain(field.domain, annotationDomain);
   }
   const { leaf } = field;
+  if (leaf !== null && ["array", "tuple", "object", "strictObject", "looseObject", "record", "map", "set", "promise", "intersection"].includes(leaf)) {
+    return false;
+  }
   if (leaf === null || annotation === null) {
     return null;
   }
@@ -16514,7 +16443,6 @@ var prefer_zod_infer_default = createRule({
       if (fields.size !== members.size) {
         return false;
       }
-      let agreements = 0;
       for (const [name, field] of fields) {
         const member = members.get(name);
         if (member === void 0) {
@@ -16533,14 +16461,11 @@ var prefer_zod_infer_default = createRule({
           return false;
         }
         const agrees = leafAgrees(field, member.annotation);
-        if (agrees === false) {
+        if (agrees !== true) {
           return false;
         }
-        if (agrees === true) {
-          agreements += 1;
-        }
       }
-      return agreements > 0;
+      return true;
     }
     return {
       Program(node) {
@@ -16554,7 +16479,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== AST_NODE_TYPES69.Identifier || node.init == null) {
+        if (node.id.type !== AST_NODE_TYPES69.Identifier || node.init == null || !isModuleLevelConst(node)) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -16587,6 +16512,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSInterfaceDeclaration(node) {
+        if (!isModuleLevelDeclaration(node)) return;
         if (node.typeParameters !== void 0 || (node.extends?.length ?? 0) > 0) {
           return;
         }
@@ -16602,6 +16528,7 @@ var prefer_zod_infer_default = createRule({
         );
       },
       TSTypeAliasDeclaration(node) {
+        if (!isModuleLevelDeclaration(node)) return;
         const schemaName = inferredSchemaName(node.typeAnnotation);
         if (schemaName !== null) {
           inferredAliases.push({
@@ -16719,6 +16646,7 @@ var REQUIRE_ASSERT_NEVER_DOCUMENTATION = {
   rationale: "An empty default silently accepts new union members instead of making the compiler identify the missing case.",
   remediation: "Call `assertNever` with the discriminant in the exhaustive switch default.",
   category: "correctness",
+  limitations: ["Requires type information and singleton case values covering the current union. The helper must accept never to provide a compile-time check; its spelling alone is not a proof of that contract. Review the desired runtime behavior for unexpected external values."],
   examples: [
     { id: "assert-never-default", title: "Make the default exhaustive", outcome: "no-match", files: [{ path: "src/render.ts", source: "declare const kind: 'a' | 'b';\nswitch (kind) { case 'a': break; case 'b': break; default: assertNever(kind); }" }], focusPath: "src/render.ts", expectedCount: 0, public: true },
     { id: "empty-default", title: "Do not leave an exhaustive default empty", outcome: "match", files: [{ path: "src/render.ts", source: "declare const kind: 'a' | 'b';\nswitch (kind) { case 'a': break; case 'b': break; default: }" }], focusPath: "src/render.ts", expectedCount: 1, public: true }
@@ -16775,11 +16703,9 @@ function isExhaustiveFiniteSwitch(node, services) {
     if (caseNode.test === null) continue;
     const test = services.esTreeNodeToTSNodeMap.get(caseNode.test);
     const testType = checker.getTypeAtLocation(test);
-    const alternatives = testType.isUnion() ? testType.types : [testType];
-    for (const alternative of alternatives) {
-      const key = finiteTypeKey(alternative, checker);
-      if (key !== null) handled.add(key);
-    }
+    if (testType.isUnion()) continue;
+    const key = finiteTypeKey(testType, checker);
+    if (key !== null) handled.add(key);
   }
   return [...expected].every((key) => handled.has(key));
 }
@@ -16831,7 +16757,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES71, ASTUtils as ASTUtils28 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES71, ASTUtils as ASTUtils30 } from "@typescript-eslint/utils";
 var REQUIRE_FETCH_TIMEOUT_DOCUMENTATION = {
   summary: "Require an explicit abort signal on locally analyzable global fetch calls.",
   rationale: "An unbounded request can occupy work indefinitely when an upstream stalls.",
@@ -16913,7 +16839,7 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = ASTUtils28.findVariable(scope, identifier.name);
+      const variable = ASTUtils30.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
@@ -16923,7 +16849,7 @@ var require_fetch_timeout_default = createRule({
       return callee.type === AST_NODE_TYPES71.MemberExpression && !callee.computed && callee.property.type === AST_NODE_TYPES71.Identifier && callee.property.name === "fetch" && callee.object.type === AST_NODE_TYPES71.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     function localConstInitProvablyLacksSignal(identifier) {
-      const variable = ASTUtils28.findVariable(
+      const variable = ASTUtils30.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -16945,7 +16871,7 @@ var require_fetch_timeout_default = createRule({
     function isForwardedRequest(argument) {
       let value = argument;
       if (value.type === AST_NODE_TYPES71.Identifier) {
-        const binding = ASTUtils28.findVariable(context.sourceCode.getScope(value), value.name);
+        const binding = ASTUtils30.findVariable(context.sourceCode.getScope(value), value.name);
         const definition = binding?.defs.length === 1 ? binding.defs[0] : void 0;
         if (definition?.type !== "Variable" || definition.parent.kind !== "const" || definition.node.init === null || binding?.references.some((reference) => reference.isWrite() && reference.init !== true)) return false;
         value = definition.node.init;
@@ -17434,15 +17360,14 @@ var publicMethodNames = (body2, functionAliases) => {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
       if (member.key.type === AST_NODE_TYPES73.PrivateIdentifier) continue;
       if (member.value?.type !== AST_NODE_TYPES73.ArrowFunctionExpression && member.value?.type !== AST_NODE_TYPES73.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== AST_NODE_TYPES73.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === AST_NODE_TYPES73.Identifier ? member.key.name : "\u2026");
+      names.push(declaredMemberName(member) ?? "\u2026");
       continue;
     }
     if (member.type !== AST_NODE_TYPES73.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
     if (member.key.type === AST_NODE_TYPES73.PrivateIdentifier) continue;
-    if (member.key.type === AST_NODE_TYPES73.Identifier) names.push(member.key.name);
-    else names.push("\u2026");
+    names.push(declaredMemberName(member) ?? "\u2026");
   }
   return names;
 };
@@ -17483,6 +17408,11 @@ function localClassAbstractness(program) {
   }
   return classes;
 }
+function declaredMemberName(member) {
+  if (!member.computed && member.key.type === AST_NODE_TYPES73.Identifier) return member.key.name;
+  if (member.key.type === AST_NODE_TYPES73.Literal && typeof member.key.value === "string") return member.key.value;
+  return null;
+}
 function localInterfaceSurfaces(program) {
   const interfaces = /* @__PURE__ */ new Map();
   const parents = /* @__PURE__ */ new Map();
@@ -17505,14 +17435,15 @@ function localInterfaceSurfaces(program) {
         if (part.type !== AST_NODE_TYPES73.TSTypeLiteral) continue;
         for (const member of part.members) {
           if (member.type !== AST_NODE_TYPES73.TSMethodSignature && member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== AST_NODE_TYPES73.Identifier) continue;
+          const name = declaredMemberName(member);
+          if (name === null) continue;
           if (member.type === AST_NODE_TYPES73.TSMethodSignature) {
-            callables2.add(member.key.name);
+            callables2.add(name);
             continue;
           }
           if (member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === AST_NODE_TYPES73.TSFunctionType || annotation?.type === AST_NODE_TYPES73.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === AST_NODE_TYPES73.TSFunctionType || annotation?.type === AST_NODE_TYPES73.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
@@ -17523,8 +17454,9 @@ function localInterfaceSurfaces(program) {
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
       if (member.type !== AST_NODE_TYPES73.TSMethodSignature && member.type !== AST_NODE_TYPES73.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== AST_NODE_TYPES73.Identifier) continue;
-      if (member.type === AST_NODE_TYPES73.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      const name = declaredMemberName(member);
+      if (name === null) continue;
+      if (member.type === AST_NODE_TYPES73.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES73.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === AST_NODE_TYPES73.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -18022,7 +17954,7 @@ var require_static_next_matcher_default = createRule({
 });
 
 // src/rules/require-use-form-default-values.ts
-import { ASTUtils as ASTUtils29 } from "@typescript-eslint/utils";
+import { ASTUtils as ASTUtils31 } 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.",
@@ -18076,13 +18008,13 @@ var require_use_form_default_values_default = createRule({
         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 = ASTUtils29.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
+          const variable = ASTUtils31.findVariable(context.sourceCode.getScope(specifier.local), specifier.local.name);
           if (variable) importedHooks.add(variable);
         }
       },
       CallExpression(node) {
         if (node.callee.type !== "Identifier") return;
-        const variable = ASTUtils29.findVariable(context.sourceCode.getScope(node.callee), node.callee.name);
+        const variable = ASTUtils31.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;
         context.report({ node, messageId: "requireUseFormDefaultValues" });
@@ -18161,7 +18093,7 @@ var require_use_server_in_actions_file_default = createRule({
 // src/rules/require-zod-form-validation.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES76,
-  ASTUtils as ASTUtils30
+  ASTUtils as ASTUtils32
 } from "@typescript-eslint/utils";
 var REQUIRE_ZOD_FORM_VALIDATION_DOCUMENTATION = {
   summary: "Require Zod validation (`Schema.parse(...)` / `Schema.safeParse(...)`) when reading values out of a `FormData` object.",
@@ -18229,7 +18161,7 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const zodBindings = /* @__PURE__ */ new Set();
-    const resolvedBinding = (identifier) => ASTUtils30.findVariable(
+    const resolvedBinding = (identifier) => ASTUtils32.findVariable(
       context.sourceCode.getScope(identifier),
       identifier.name
     );
@@ -18526,7 +18458,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/stepdown.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils31 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES77, ASTUtils as ASTUtils33 } 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.",
@@ -18731,7 +18663,7 @@ function methodName(node) {
   return !node.computed && node.key.type === AST_NODE_TYPES77.Identifier ? node.key.name : null;
 }
 function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils31.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
+  const objectVariable = node.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils33.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
   const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
   if (node.object.type !== AST_NODE_TYPES77.ThisExpression && !isClassReference) return null;
   if (node.property.type === AST_NODE_TYPES77.PrivateIdentifier) return `#${node.property.name}`;
@@ -18743,15 +18675,15 @@ function referencedPropertyName(node) {
   if (!node.computed && node.property.type === AST_NODE_TYPES77.Identifier) return node.property.name;
   return node.computed && node.property.type === AST_NODE_TYPES77.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
-function walk2(node, visitorKeys, visit, nestedFunction = false) {
+function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
   const nested = nestedFunction || isFunction(node);
   for (const key of visitorKeys[node.type] ?? []) {
     const child = node[key];
     if (Array.isArray(child)) {
-      for (const item of child) if (typeof item === "object" && item !== null && "type" in item) walk2(item, visitorKeys, visit, nested);
+      for (const item of child) if (typeof item === "object" && item !== null && "type" in item) walk(item, visitorKeys, visit, nested);
     } else if (typeof child === "object" && child !== null && "type" in child) {
-      walk2(child, visitorKeys, visit, nested);
+      walk(child, visitorKeys, visit, nested);
     }
   }
 }
@@ -18784,11 +18716,11 @@ function classScope(context, node, computedReferenceNames) {
   const pinned = /* @__PURE__ */ new Set();
   const classVariables = /* @__PURE__ */ new Set();
   if (node.id !== null) {
-    const internal = ASTUtils31.findVariable(context.sourceCode.getScope(node), node.id.name);
+    const internal = ASTUtils33.findVariable(context.sourceCode.getScope(node), node.id.name);
     if (internal !== null) classVariables.add(internal);
   }
   if (node.type === AST_NODE_TYPES77.ClassExpression && node.parent.type === AST_NODE_TYPES77.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES77.Identifier) {
-    const outer = ASTUtils31.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    const outer = ASTUtils33.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
     if (outer !== null) classVariables.add(outer);
   }
   for (const method of methods) {
@@ -18799,7 +18731,7 @@ function classScope(context, node, computedReferenceNames) {
     const parameterDecoratorNodes = /* @__PURE__ */ new Set();
     for (const parameter of method.value.params) {
       for (const decorator of parameter.decorators) {
-        walk2(decorator, context.sourceCode.visitorKeys, (current) => parameterDecoratorNodes.add(current));
+        walk(decorator, context.sourceCode.visitorKeys, (current) => parameterDecoratorNodes.add(current));
       }
     }
     const thisValue = (value) => {
@@ -18824,17 +18756,17 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (binding.type !== AST_NODE_TYPES77.Identifier) return;
-      const variable = ASTUtils31.findVariable(context.sourceCode.getScope(binding), binding.name);
+      const variable = ASTUtils33.findVariable(context.sourceCode.getScope(binding), binding.name);
       if (variable !== null) {
         methodClassVariables.add(variable);
         methodAliases.add(variable);
       }
     };
     for (const parameter of method.value.params) {
-      walk2(parameter, context.sourceCode.visitorKeys, collectAlias);
+      walk(parameter, context.sourceCode.visitorKeys, collectAlias);
     }
     for (const statement of method.value.body.body) {
-      walk2(statement, context.sourceCode.visitorKeys, collectAlias);
+      walk(statement, context.sourceCode.visitorKeys, collectAlias);
     }
     const visitCall = (current, nestedFunction) => {
       if (current.type === AST_NODE_TYPES77.VariableDeclarator && current.id.type === AST_NODE_TYPES77.ObjectPattern && thisValue(current.init)) {
@@ -18854,7 +18786,7 @@ function classScope(context, node, computedReferenceNames) {
         return;
       }
       if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils31.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
+      const objectVariable = current.object.type === AST_NODE_TYPES77.Identifier ? ASTUtils33.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
       if (objectVariable !== null && methodAliases.has(objectVariable)) {
         pinned.add(target);
         return;
@@ -18868,19 +18800,19 @@ function classScope(context, node, computedReferenceNames) {
       calls.set(caller, callees);
     };
     for (const decorator of method.decorators) {
-      walk2(decorator, context.sourceCode.visitorKeys, visitCall, true);
+      walk(decorator, context.sourceCode.visitorKeys, visitCall, true);
     }
-    if (method.computed) walk2(method.key, context.sourceCode.visitorKeys, visitCall, true);
+    if (method.computed) walk(method.key, context.sourceCode.visitorKeys, visitCall, true);
     for (const parameter of method.value.params) {
-      walk2(parameter, context.sourceCode.visitorKeys, visitCall);
+      walk(parameter, context.sourceCode.visitorKeys, visitCall);
     }
     for (const statement of method.value.body.body) {
-      walk2(statement, context.sourceCode.visitorKeys, visitCall);
+      walk(statement, context.sourceCode.visitorKeys, visitCall);
     }
   }
   for (const member of node.body.body) {
     if (member.type === AST_NODE_TYPES77.MethodDefinition || member.type === AST_NODE_TYPES77.TSAbstractMethodDefinition) continue;
-    walk2(member, context.sourceCode.visitorKeys, (current) => {
+    walk(member, context.sourceCode.visitorKeys, (current) => {
       if (current.type !== AST_NODE_TYPES77.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
@@ -18970,7 +18902,7 @@ var stepdown_default = createRule({
       "Program:exit": (program) => {
         moduleScope(context, program);
         const computedReferenceNames = /* @__PURE__ */ new Set();
-        walk2(program, context.sourceCode.visitorKeys, (node) => {
+        walk(program, context.sourceCode.visitorKeys, (node) => {
           if (node.type === AST_NODE_TYPES77.MemberExpression && node.computed && node.property.type === AST_NODE_TYPES77.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
@@ -19441,7 +19373,7 @@ var iac_source_coupled_test_default = createSourceCoupledRule(
 // src/rules/require-pascal-case-zod-schema-name.ts
 import {
   AST_NODE_TYPES as AST_NODE_TYPES80,
-  ASTUtils as ASTUtils32
+  ASTUtils as ASTUtils34
 } from "@typescript-eslint/utils";
 var REQUIRE_PASCAL_CASE_ZOD_SCHEMA_NAME_DOCUMENTATION = {
   summary: "Require confirmed module-level Zod schema contracts to use PascalCase with a `Schema` suffix.",
@@ -19642,7 +19574,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
     const zodBindings = /* @__PURE__ */ new Set();
     const schemaBindings = /* @__PURE__ */ new Set();
     function resolvedBinding(identifier) {
-      return ASTUtils32.findVariable(
+      return ASTUtils34.findVariable(
         context.sourceCode.getScope(identifier),
         identifier.name
       );
@@ -19887,7 +19819,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.17.9"
+  version: "15.17.10"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {