@sarj/eslint-plugin 15.17.9 → 15.17.10

package/dist/index.cjs

@@ -2454,7 +2454,7 @@ var no_duplicate_lifecycle_refresh_listeners_default = createRule({
       VariableDeclarator(node) {
         if (node.id.type !== import_utils10.AST_NODE_TYPES.Identifier) return;
         const variable = import_utils10.ASTUtils.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 === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression || node.init?.type === import_utils10.AST_NODE_TYPES.FunctionExpression) {
           functionCallbacks.set(node.init, variable);
         }
@@ -2465,7 +2465,7 @@ var no_duplicate_lifecycle_refresh_listeners_default = createRule({
       FunctionDeclaration(node) {
         if (node.id === null) return;
         const variable = import_utils10.ASTUtils.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);
@@ -4475,105 +4475,9 @@ var ts = __toESM(require("typescript"), 1);
 
 // src/rules/_class-private.ts
 var import_utils21 = require("@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 === import_utils21.AST_NODE_TYPES.ClassDeclaration || current.type === import_utils21.AST_NODE_TYPES.ClassExpression) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
 function memberName2(member) {
   return !member.computed && member.key.type === import_utils21.AST_NODE_TYPES.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 !== import_utils21.AST_NODE_TYPES.MethodDefinition && member.type !== import_utils21.AST_NODE_TYPES.PropertyDefinition && member.type !== import_utils21.AST_NODE_TYPES.AccessorProperty) return false;
-    return member.key.type === import_utils21.AST_NODE_TYPES.PrivateIdentifier && member.key.name === name;
-  })) return void 0;
-  const selectedMembers = new Set(members);
-  if (owner.body.body.some((member) => {
-    if (member.type !== import_utils21.AST_NODE_TYPES.MethodDefinition && member.type !== import_utils21.AST_NODE_TYPES.PropertyDefinition && member.type !== import_utils21.AST_NODE_TYPES.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 === import_utils21.AST_NODE_TYPES.Literal && node.value === name) {
-      unsafe = true;
-      return;
-    }
-    if (node.type !== import_utils21.AST_NODE_TYPES.MemberExpression) return;
-    const propertyName6 = node.property.type === import_utils21.AST_NODE_TYPES.Identifier || node.property.type === import_utils21.AST_NODE_TYPES.PrivateIdentifier ? node.property.name : node.property.type === import_utils21.AST_NODE_TYPES.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 !== import_utils21.AST_NODE_TYPES.Identifier || node.object.type !== import_utils21.AST_NODE_TYPES.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 !== import_utils21.AST_NODE_TYPES.MethodDefinition && member.type !== import_utils21.AST_NODE_TYPES.PropertyDefinition && member.type !== import_utils21.AST_NODE_TYPES.AccessorProperty) return null;
   return memberName2(member);
@@ -5378,9 +5282,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 }
   ]
 };
@@ -5441,6 +5345,7 @@ function runtimeExports(program) {
     }
     if (statement.declaration !== null) {
       const declaration = statement.declaration;
+      if (declaration.type === import_utils28.AST_NODE_TYPES.VariableDeclaration && declaration.declarations.some((item) => item.id.type !== import_utils28.AST_NODE_TYPES.Identifier)) ambiguous = true;
       exports2.push(...declaredNames(declaration).map((name) => ({ key: name, name, node: declaration })));
     }
     for (const specifier of statement.specifiers) {
@@ -5629,7 +5534,7 @@ function tupleReturnType(node, aliases, resolving = /* @__PURE__ */ new Set()) {
     return argument === void 0 ? null : tupleReturnType(argument, aliases, resolving);
   }
   if (node.type === import_utils30.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils30.AST_NODE_TYPES.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 === import_utils30.AST_NODE_TYPES.TSTypeOperator && node.operator === "readonly") {
@@ -5721,20 +5626,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 === import_utils30.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
     if (declaration?.type === import_utils30.AST_NODE_TYPES.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 = import_utils30.ASTUtils.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 === import_utils30.AST_NODE_TYPES.TSFunctionType) return node.returnType?.typeAnnotation ?? null;
   if (node.type === import_utils30.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils30.AST_NODE_TYPES.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]));
     }
@@ -5863,7 +5775,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) => {
@@ -6403,11 +6315,11 @@ var no_raw_fetch_outside_clients_default = createRule({
 // src/rules/no-restricted-library-load.ts
 var import_utils33 = require("@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 }
@@ -6425,7 +6337,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: [
       {
@@ -6451,7 +6363,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: [] }],
@@ -6497,6 +6409,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 !== import_utils33.AST_NODE_TYPES.TSExternalModuleReference) return;
         const source = literalModule(node.moduleReference.expression);
         if (source !== null) report2(node.moduleReference.expression, source);
@@ -7637,7 +7550,7 @@ var NO_SENTINEL_RETURN_ON_CATCH_DOCUMENTATION = {
   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 }
@@ -8052,6 +7965,8 @@ var no_sentinel_return_on_catch_default = createRule({
         if (!isSentinelArgument(last.argument)) {
           return;
         }
+        const returned = unwrapSentinelExpression(last.argument);
+        if (returned?.type === import_utils42.AST_NODE_TYPES.Identifier && returned.name === "undefined" && (import_utils42.ASTUtils.findVariable(context.sourceCode.getScope(returned), returned.name)?.defs.length ?? 0) > 0) return;
         if (containsThrow(node.body)) {
           return;
         }
@@ -8501,12 +8416,13 @@ var no_storage_in_stateless_modules_default = createRule({
 // src/rules/no-string-concat-in-loop.ts
 var import_utils46 = require("@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: [
     {
@@ -8624,6 +8540,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) {
@@ -8635,6 +8552,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;
@@ -8673,12 +8603,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: [],
@@ -8705,6 +8635,7 @@ var no_string_concat_in_loop_default = createRule({
         if (loop === null) {
           return;
         }
+        if (immediatelyExitsLoop(node, loop)) return;
         if (isSmallStaticForLoop(loop)) {
           return;
         }
@@ -10771,13 +10702,12 @@ var import_utils59 = require("@typescript-eslint/utils");
 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: [
@@ -10797,19 +10727,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 === import_utils59.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === import_utils59.AST_NODE_TYPES.ExportDefaultDeclaration;
-  const locallyClosed = !directlyExported && owner.decorators.length === 0 && owner.type === import_utils59.AST_NODE_TYPES.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;
@@ -10822,18 +10744,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 }
     });
   }
 }
@@ -10847,7 +10761,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}}`."
@@ -10864,8 +10777,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)
     };
   }
 });
@@ -10875,10 +10788,10 @@ var import_utils60 = require("@typescript-eslint/utils");
 var import_utils61 = require("@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 }
@@ -10942,7 +10855,7 @@ function looksLikeMutuallyExclusiveState(typeLiteral) {
   return statusMemberCount === REQUIRED_STATUS_MEMBER_COUNT && hasFailurePayload && (hasSuccessPayload || !hasUnrecognizedMember);
 }
 function getMemberName(member) {
-  if (member.type !== import_utils61.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils61.AST_NODE_TYPES.TSPropertySignature || member.computed) {
     return null;
   }
   const { key } = member;
@@ -10978,7 +10891,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: [],
@@ -13128,7 +13041,7 @@ function isLiteralUnion(node) {
 function exportedContract(node) {
   let current = node;
   while (current !== void 0) {
-    if (current.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration) return true;
+    if (current.type === import_utils70.AST_NODE_TYPES.TSTypeAliasDeclaration || current.type === import_utils70.AST_NODE_TYPES.TSInterfaceDeclaration) return current.parent.type === import_utils70.AST_NODE_TYPES.ExportNamedDeclaration;
     if (current.type === import_utils70.AST_NODE_TYPES.Program) return false;
     current = current.parent ?? void 0;
   }
@@ -13226,7 +13139,7 @@ var PREFER_NATIVE_RANDOM_UUID_DOCUMENTATION = {
   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 }
@@ -13246,7 +13159,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."
     }
   },
@@ -13262,15 +13175,17 @@ var prefer_native_random_uuid_default = createRule({
       if (variable !== null) destination.add(variable);
     }
     function report2(node) {
+      const globalBinding = import_utils72.ASTUtils.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 {
@@ -14705,6 +14620,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."
   ],
@@ -14718,7 +14634,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 === import_utils80.AST_NODE_TYPES.Identifier ? sourceCode.getText(discriminant) : null;
 }
 function isCaseValue(node) {
   if (node.type === import_utils80.AST_NODE_TYPES.Literal) return true;
@@ -16007,6 +15924,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 }
@@ -16186,6 +16108,10 @@ function sameDomain(left, right) {
 function isExportedDeclaration(node) {
   return node.parent?.type === import_utils85.AST_NODE_TYPES.ExportNamedDeclaration;
 }
+function isModuleLevelDeclaration(node) {
+  const parent = node.parent;
+  return parent?.type === import_utils85.AST_NODE_TYPES.Program || parent?.type === import_utils85.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent.type === import_utils85.AST_NODE_TYPES.Program;
+}
 function isModuleLevelConst(node) {
   const declaration = node.parent;
   if (declaration.type !== import_utils85.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const") {
@@ -16236,6 +16162,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;
   }
@@ -16528,7 +16457,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) {
@@ -16547,14 +16475,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) {
@@ -16568,7 +16493,7 @@ var prefer_zod_infer_default = createRule({
         recordZodImport(node);
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils85.AST_NODE_TYPES.Identifier || node.init == null || !isModuleLevelConst(node)) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -16601,6 +16526,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSInterfaceDeclaration(node) {
+        if (!isModuleLevelDeclaration(node)) return;
         if (node.typeParameters !== void 0 || (node.extends?.length ?? 0) > 0) {
           return;
         }
@@ -16616,6 +16542,7 @@ var prefer_zod_infer_default = createRule({
         );
       },
       TSTypeAliasDeclaration(node) {
+        if (!isModuleLevelDeclaration(node)) return;
         const schemaName = inferredSchemaName(node.typeAnnotation);
         if (schemaName !== null) {
           inferredAliases.push({
@@ -16730,6 +16657,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 }
@@ -16786,11 +16714,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));
 }
@@ -17445,15 +17371,14 @@ var publicMethodNames = (body2, functionAliases) => {
       if (member.static || member.accessibility === "private" || member.accessibility === "protected") continue;
       if (member.key.type === import_utils89.AST_NODE_TYPES.PrivateIdentifier) continue;
       if (member.value?.type !== import_utils89.AST_NODE_TYPES.ArrowFunctionExpression && member.value?.type !== import_utils89.AST_NODE_TYPES.FunctionExpression && member.typeAnnotation?.typeAnnotation.type !== import_utils89.AST_NODE_TYPES.TSFunctionType && !(member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name))) continue;
-      names.push(member.key.type === import_utils89.AST_NODE_TYPES.Identifier ? member.key.name : "\u2026");
+      names.push(declaredMemberName(member) ?? "\u2026");
       continue;
     }
     if (member.type !== import_utils89.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
     if (member.key.type === import_utils89.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils89.AST_NODE_TYPES.Identifier) names.push(member.key.name);
-    else names.push("\u2026");
+    names.push(declaredMemberName(member) ?? "\u2026");
   }
   return names;
 };
@@ -17494,6 +17419,11 @@ function localClassAbstractness(program) {
   }
   return classes;
 }
+function declaredMemberName(member) {
+  if (!member.computed && member.key.type === import_utils89.AST_NODE_TYPES.Identifier) return member.key.name;
+  if (member.key.type === import_utils89.AST_NODE_TYPES.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();
@@ -17516,14 +17446,15 @@ function localInterfaceSurfaces(program) {
         if (part.type !== import_utils89.AST_NODE_TYPES.TSTypeLiteral) continue;
         for (const member of part.members) {
           if (member.type !== import_utils89.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
-          if (member.computed || member.key.type !== import_utils89.AST_NODE_TYPES.Identifier) continue;
+          const name = declaredMemberName(member);
+          if (name === null) continue;
           if (member.type === import_utils89.AST_NODE_TYPES.TSMethodSignature) {
-            callables2.add(member.key.name);
+            callables2.add(name);
             continue;
           }
           if (member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
           const annotation = member.typeAnnotation?.typeAnnotation;
-          if (annotation?.type === import_utils89.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils89.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(member.key.name);
+          if (annotation?.type === import_utils89.AST_NODE_TYPES.TSFunctionType || annotation?.type === import_utils89.AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(annotation.typeName.name)) callables2.add(name);
         }
       }
       interfaces.set(declaration.id.name, callables2);
@@ -17534,8 +17465,9 @@ function localInterfaceSurfaces(program) {
     const callables = interfaces.get(declaration.id.name) ?? /* @__PURE__ */ new Set();
     for (const member of declaration.body.body) {
       if (member.type !== import_utils89.AST_NODE_TYPES.TSMethodSignature && member.type !== import_utils89.AST_NODE_TYPES.TSPropertySignature) continue;
-      if (member.computed || member.key.type !== import_utils89.AST_NODE_TYPES.Identifier) continue;
-      if (member.type === import_utils89.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(member.key.name);
+      const name = declaredMemberName(member);
+      if (name === null) continue;
+      if (member.type === import_utils89.AST_NODE_TYPES.TSMethodSignature || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSFunctionType || member.typeAnnotation?.typeAnnotation.type === import_utils89.AST_NODE_TYPES.TSTypeReference && member.typeAnnotation.typeAnnotation.typeName.type === import_utils89.AST_NODE_TYPES.Identifier && functionAliases.has(member.typeAnnotation.typeAnnotation.typeName.name)) callables.add(name);
     }
     interfaces.set(declaration.id.name, callables);
     parents.set(
@@ -18751,15 +18683,15 @@ function referencedPropertyName(node) {
   if (!node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Identifier) return node.property.name;
   return node.computed && node.property.type === import_utils96.AST_NODE_TYPES.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);
     }
   }
 }
@@ -18807,7 +18739,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) => {
@@ -18839,10 +18771,10 @@ function classScope(context, node, computedReferenceNames) {
       }
     };
     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 === import_utils96.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils96.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
@@ -18876,19 +18808,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 === import_utils96.AST_NODE_TYPES.MethodDefinition || member.type === import_utils96.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
-    walk2(member, context.sourceCode.visitorKeys, (current) => {
+    walk(member, context.sourceCode.visitorKeys, (current) => {
       if (current.type !== import_utils96.AST_NODE_TYPES.MemberExpression) return;
       const target = referencedMethod(context, current, classVariables);
       const possibleTarget = target ?? referencedPropertyName(current);
@@ -18978,7 +18910,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 === import_utils96.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils96.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
         });
         for (const node of classes) classScope(context, node, computedReferenceNames);
@@ -19892,7 +19824,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", {