@sarj/eslint-plugin 15.4.0 → 15.6.0

package/dist/index.js

@@ -564,6 +564,9 @@ function isAssertionStatement(statement) {
   const expression = statement.expression;
   return expression.type === AST_NODE_TYPES2.CallExpression && isAssertionCall(expression);
 }
+function isTypeOnlyContractStatement(statement) {
+  return statement.type === AST_NODE_TYPES2.TSTypeAliasDeclaration || statement.type === AST_NODE_TYPES2.TSInterfaceDeclaration;
+}
 function normalizedLiteral(node) {
   if ("regex" in node) {
     return ["Literal", "regex", node.regex.pattern, node.regex.flags];
@@ -621,7 +624,7 @@ var duplicate_test_body_default = createRule({
           return;
         }
         const body2 = candidate.body;
-        if (body2.body.type !== AST_NODE_TYPES2.BlockStatement || body2.body.body.length < MIN_STATEMENTS || body2.body.body.every(isAssertionStatement)) {
+        if (body2.body.type !== AST_NODE_TYPES2.BlockStatement || body2.body.body.length < MIN_STATEMENTS || body2.body.body.every(isAssertionStatement) || body2.body.body.some(isTypeOnlyContractStatement)) {
           return;
         }
         const comments = context.sourceCode.getCommentsInside(body2.body).map((comment) => [comment.type, comment.value]);
@@ -3521,7 +3524,11 @@ var NUMBER_METHODS = /* @__PURE__ */ new Set([
   "lt",
   "lte",
   "max",
-  "min"
+  "min",
+  "negative",
+  "nonnegative",
+  "nonpositive",
+  "positive"
 ]);
 var LENGTH_METHODS = /* @__PURE__ */ new Set(["length", "max", "min"]);
 var RESHAPING_METHODS = /* @__PURE__ */ new Set([
@@ -3658,13 +3665,29 @@ var no_impossible_zod_literal_bounds_default = createRule({
       let upper = null;
       for (const { method, node } of chain.calls) {
         if (!allowed.has(method)) return null;
-        const value = finiteNumber(node.arguments[0]);
+        const semantic = method === "positive" ? { exclusive: true, lower: true, value: 0 } : method === "nonnegative" ? { exclusive: false, lower: true, value: 0 } : method === "negative" ? { exclusive: true, lower: false, value: 0 } : method === "nonpositive" ? { exclusive: false, lower: false, value: 0 } : null;
+        const value = semantic?.value ?? finiteNumber(node.arguments[0]);
         if (value === null) return null;
         if (chain.kind !== "number" && (!Number.isInteger(value) || value < 0)) {
           return null;
         }
         const label = `${method}(${String(value)})`;
-        if (method === "length") {
+        if (semantic !== null) {
+          if (node.arguments.length !== 0) return null;
+          if (semantic.lower) {
+            lower = strongerLower(lower, {
+              exclusive: semantic.exclusive,
+              label: `${method}()`,
+              value
+            });
+          } else {
+            upper = strongerUpper(upper, {
+              exclusive: semantic.exclusive,
+              label: `${method}()`,
+              value
+            });
+          }
+        } else if (method === "length") {
           lower = strongerLower(lower, { exclusive: false, label, value });
           upper = strongerUpper(upper, { exclusive: false, label, value });
         } else if (method === "gt" || method === "gte" || method === "min") {
@@ -4170,7 +4193,7 @@ import { AST_NODE_TYPES as AST_NODE_TYPES16, ASTUtils as ASTUtils4 } from "@type
 var noGenericSingleExportModuleDocumentation = {
   summary: "Disallow generic module stems when one runtime export already names the responsibility.",
   rationale: "A generic filename hides the sole exported responsibility and makes navigation less descriptive.",
-  remediation: "Rename the module after its single runtime export.",
+  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."],
   examples: [
@@ -4179,36 +4202,21 @@ var noGenericSingleExportModuleDocumentation = {
   ]
 };
 var GENERIC_STEMS = /* @__PURE__ */ new Set([
-  "base",
   "common",
-  "constant",
-  "constants",
-  "core",
-  "enum",
-  "enums",
   "helper",
   "helpers",
   "misc",
-  "model",
-  "models",
   "shared",
   "stuff",
-  "type",
-  "types",
   "util",
   "utils"
 ]);
-var CONVENTIONAL_STEMS = /* @__PURE__ */ new Set(["base", "models"]);
 var CJS_OBJECT_EXPORT_METHODS = /* @__PURE__ */ new Set(["assign", "defineProperties", "defineProperty"]);
 function fileParts(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
   const extension = base.match(/(\.[cm]?[jt]sx?)$/u)?.[1] ?? ".ts";
-  const segments = base.slice(0, -extension.length).split(".");
-  return {
-    extension,
-    stem: segments[0]?.toLowerCase() ?? "",
-    suffixes: segments.slice(1)
-  };
+  const [stem3 = "", ...suffixes] = base.slice(0, -extension.length).split(".");
+  return { stem: stem3, suffixes: suffixes.map((suffix) => suffix.toLowerCase()) };
 }
 function declaredNames(declaration) {
   if (declaration.declare === true) return [];
@@ -4224,50 +4232,6 @@ function declaredNames(declaration) {
     (item) => item.id.type === AST_NODE_TYPES16.Identifier ? [item.id.name] : []
   );
 }
-function typeOnlyBindings(program) {
-  const names = /* @__PURE__ */ new Set();
-  const runtimeNames = /* @__PURE__ */ new Set();
-  for (const statement of program.body) {
-    const declaration = statement.type === AST_NODE_TYPES16.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === AST_NODE_TYPES16.TSInterfaceDeclaration || declaration?.type === AST_NODE_TYPES16.TSTypeAliasDeclaration) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (declaration?.type === AST_NODE_TYPES16.TSEnumDeclaration && declaration.const) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (statement.type === AST_NODE_TYPES16.ImportDeclaration) {
-      for (const specifier of statement.specifiers) {
-        if (statement.importKind === "type" || specifier.type === AST_NODE_TYPES16.ImportSpecifier && specifier.importKind === "type") {
-          names.add(specifier.local.name);
-        } else {
-          runtimeNames.add(specifier.local.name);
-        }
-      }
-      continue;
-    }
-    if (declaration?.type === AST_NODE_TYPES16.TSDeclareFunction && declaration.id !== null) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (declaration !== null && declaration.declare === true) {
-      if ((declaration.type === AST_NODE_TYPES16.ClassDeclaration || declaration.type === AST_NODE_TYPES16.FunctionDeclaration || declaration.type === AST_NODE_TYPES16.TSEnumDeclaration || declaration.type === AST_NODE_TYPES16.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === AST_NODE_TYPES16.Identifier) names.add(declaration.id.name);
-      if (declaration.type === AST_NODE_TYPES16.VariableDeclaration) {
-        for (const item of declaration.declarations) {
-          if (item.id.type === AST_NODE_TYPES16.Identifier) names.add(item.id.name);
-        }
-      }
-      continue;
-    }
-    if (declaration !== null && "type" in declaration) {
-      for (const name of declaredNames(declaration)) {
-        runtimeNames.add(name);
-      }
-    }
-  }
-  return new Set([...names].filter((name) => !runtimeNames.has(name)));
-}
 function runtimeExports(program) {
   const exports = [];
   const typeBindings = typeOnlyBindings(program);
@@ -4306,25 +4270,49 @@ function runtimeExports(program) {
   const unique = new Map(exports.map((entry) => [entry.key, entry]));
   return { exports: [...unique.values()], ambiguous };
 }
-function publicTypeExportCount(program) {
+function typeOnlyBindings(program) {
   const names = /* @__PURE__ */ new Set();
-  const typeBindings = typeOnlyBindings(program);
+  const runtimeNames = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
-    if (statement.type !== AST_NODE_TYPES16.ExportNamedDeclaration) continue;
-    const declaration = statement.declaration;
-    if (declaration?.type === AST_NODE_TYPES16.TSInterfaceDeclaration || declaration?.type === AST_NODE_TYPES16.TSTypeAliasDeclaration) names.add(declaration.id.name);
-    for (const specifier of statement.specifiers) {
-      const local = specifier.local.type === AST_NODE_TYPES16.Identifier ? specifier.local.name : specifier.local.value;
-      if (statement.exportKind !== "type" && specifier.exportKind !== "type" && !typeBindings.has(local)) {
-        continue;
+    const declaration = statement.type === AST_NODE_TYPES16.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === AST_NODE_TYPES16.TSInterfaceDeclaration || declaration?.type === AST_NODE_TYPES16.TSTypeAliasDeclaration) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration?.type === AST_NODE_TYPES16.TSEnumDeclaration && declaration.const) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (statement.type === AST_NODE_TYPES16.ImportDeclaration) {
+      for (const specifier of statement.specifiers) {
+        if (statement.importKind === "type" || specifier.type === AST_NODE_TYPES16.ImportSpecifier && specifier.importKind === "type") {
+          names.add(specifier.local.name);
+        } else {
+          runtimeNames.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    if (declaration?.type === AST_NODE_TYPES16.TSDeclareFunction && declaration.id !== null) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration !== null && declaration.declare === true) {
+      if ((declaration.type === AST_NODE_TYPES16.ClassDeclaration || declaration.type === AST_NODE_TYPES16.FunctionDeclaration || declaration.type === AST_NODE_TYPES16.TSEnumDeclaration || declaration.type === AST_NODE_TYPES16.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === AST_NODE_TYPES16.Identifier) names.add(declaration.id.name);
+      if (declaration.type === AST_NODE_TYPES16.VariableDeclaration) {
+        for (const item of declaration.declarations) {
+          if (item.id.type === AST_NODE_TYPES16.Identifier) names.add(item.id.name);
+        }
+      }
+      continue;
+    }
+    if (declaration !== null && "type" in declaration) {
+      for (const name of declaredNames(declaration)) {
+        runtimeNames.add(name);
       }
-      names.add(specifier.exported.type === AST_NODE_TYPES16.Identifier ? specifier.exported.name : specifier.exported.value);
     }
   }
-  return names.size;
-}
-function kebabCase(name) {
-  return name.replaceAll(/oauth/giu, "Oauth").replaceAll(/graphql/giu, "Graphql").replaceAll(/grpc/giu, "Grpc").replaceAll(/([a-z\d])([A-Z])/gu, "$1-$2").replaceAll(/([A-Z]+)([A-Z][a-z])/gu, "$1-$2").replaceAll(/[_\s]+/gu, "-").replaceAll(/-+/gu, "-").replaceAll(/^-|-$/gu, "").toLowerCase();
+  return new Set([...names].filter((name) => !runtimeNames.has(name)));
 }
 function isGlobalIdentifier(context, node) {
   const variable = ASTUtils4.findVariable(context.sourceCode.getScope(node), node.name);
@@ -4346,14 +4334,14 @@ var no_generic_single_export_module_default = createRule({
     docs: { description: "Disallow generic module stems when one runtime export already names the responsibility." },
     schema: [],
     messages: {
-      genericSingleExport: "Module stem `{{stem}}` is generic and its only runtime export is `{{exported}}`; rename the file to `{{expected}}`."
+      genericSingleExport: "Module stem `{{stem}}` is generic and its only runtime export is `{{exported}}`; choose a responsibility-bearing module name or colocate the export with its domain."
     }
   },
   defaultOptions: [],
   create(context) {
     const file = fileParts(context.filename);
     const { stem: stem3 } = file;
-    if (!GENERIC_STEMS.has(stem3) || CONVENTIONAL_STEMS.has(stem3) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    if (!GENERIC_STEMS.has(stem3) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let hasCommonJsExport = false;
     return {
       CallExpression(node) {
@@ -4366,25 +4354,19 @@ var no_generic_single_export_module_default = createRule({
       },
       "Program:exit"(program) {
         if (hasCommonJsExport) return;
-        if ((stem3 === "type" || stem3 === "types") && publicTypeExportCount(program) >= 2) return;
         const exports = runtimeExports(program);
         if (exports.ambiguous || exports.exports.length !== 1) return;
         const onlyExport = exports.exports[0];
         if (onlyExport === void 0) return;
         const { name: exported, node } = onlyExport;
         if (isConventionalFrameworkUtility(context.filename, exported)) return;
-        const expectedStem = kebabCase(exported);
-        const suffixStem = file.suffixes.map(kebabCase).join("-");
-        const currentResponsibility = [stem3, suffixStem].filter(Boolean).join("-");
-        if (expectedStem === currentResponsibility || GENERIC_STEMS.has(expectedStem) || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(expectedStem)) return;
-        const suffixTail = suffixStem === "" ? "" : `-${suffixStem}`;
-        const renameStem = suffixTail !== "" && expectedStem.endsWith(suffixTail) ? expectedStem.slice(0, -suffixTail.length) : expectedStem;
-        if (renameStem === "" || GENERIC_STEMS.has(renameStem)) return;
-        const suffix = file.suffixes.map((part) => `.${kebabCase(part)}`).join("");
+        const exportedRole = exported.replaceAll(/[^a-z0-9]/giu, "").toLowerCase();
+        const pathRole = [stem3, ...file.suffixes].join("").replaceAll(/[^a-z0-9]/giu, "");
+        if (exportedRole === pathRole && file.suffixes.length > 0) return;
         context.report({
           node,
           messageId: "genericSingleExport",
-          data: { stem: stem3, exported, expected: `${renameStem}${suffix}${file.extension}` }
+          data: { stem: stem3, exported }
         });
       }
     };
@@ -6777,6 +6759,13 @@ function nearestEnclosingFunction(node) {
   }
   return null;
 }
+function isImmediatelyConsumedSleep(node) {
+  const parent = node.parent;
+  if (parent?.type === AST_NODE_TYPES25.AwaitExpression || parent?.type === AST_NODE_TYPES25.ReturnStatement || parent?.type === AST_NODE_TYPES25.ExpressionStatement) {
+    return true;
+  }
+  return parent?.type === AST_NODE_TYPES25.ArrowFunctionExpression && parent.body === node;
+}
 function isTestBody(fn) {
   const call = fn.parent;
   if (call?.type !== AST_NODE_TYPES25.CallExpression || !call.arguments.some((argument) => argument === fn)) {
@@ -6819,6 +6808,9 @@ var no_sleep_in_test_body_default = createRule({
       return {};
     }
     const report = (node) => {
+      if (!isImmediatelyConsumedSleep(node)) {
+        return;
+      }
       const enclosing = nearestEnclosingFunction(node);
       if (enclosing === null || !isTestBody(enclosing)) {
         return;
@@ -7116,6 +7108,27 @@ function isSmallStaticForLoop(node) {
   const iterations = node.test.right.value - declaration.init.value + (node.test.operator === "<=" ? 1 : 0);
   return iterations >= 0 && iterations <= 8;
 }
+function isStringSeededReduce(node) {
+  if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier" || node.callee.property.name !== "reduce" || node.arguments.length !== 2) {
+    return false;
+  }
+  const [callback, initial] = node.arguments;
+  if (node.callee.object.type === "ArrayExpression" && node.callee.object.elements.length <= 8) {
+    return false;
+  }
+  if (callback === void 0 || initial === void 0 || callback.type === "SpreadElement" || initial.type === "SpreadElement" || callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression" || callback.params[0]?.type !== "Identifier" || !isStringLiteralInit(initial)) {
+    return false;
+  }
+  const accumulator = callback.params[0].name;
+  if (callback.body.type !== "BlockStatement") {
+    return isConcatOntoTarget(callback.body, accumulator);
+  }
+  if (callback.body.body.length !== 1 || callback.body.body[0]?.type !== "ReturnStatement") {
+    return false;
+  }
+  const returned = callback.body.body[0].argument;
+  return returned !== null && isConcatOntoTarget(returned, accumulator);
+}
 var no_string_concat_in_loop_default = createRule({
   name: "no-string-concat-in-loop",
   documentation: noStringConcatInLoopDocumentation,
@@ -7126,7 +7139,8 @@ var no_string_concat_in_loop_default = createRule({
     },
     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.'
+      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."
     }
   },
   defaultOptions: [],
@@ -7136,6 +7150,11 @@ var no_string_concat_in_loop_default = createRule({
     }
     const reported = /* @__PURE__ */ new WeakMap();
     return {
+      CallExpression(node) {
+        if (isStringSeededReduce(node)) {
+          context.report({ node, messageId: "noStringReduce" });
+        }
+      },
       AssignmentExpression(node) {
         if (node.left.type !== "Identifier") {
           return;
@@ -7240,6 +7259,9 @@ function isLiteral(node) {
       return false;
   }
 }
+function isStructuralLiteral(node) {
+  return node.type === AST_NODE_TYPES27.ArrayExpression || node.type === AST_NODE_TYPES27.ObjectExpression;
+}
 function expectOperand(callee) {
   const receiver = callee.object;
   if (receiver.type !== AST_NODE_TYPES27.CallExpression || receiver.callee.type !== AST_NODE_TYPES27.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
@@ -7296,6 +7318,9 @@ var no_tautological_expect_default = createRule({
         if (!EQUALITY_MATCHERS.has(matcher) || node.arguments.length !== 1 || expected === void 0 || !isLiteral(expected)) {
           return;
         }
+        if (matcher === "toBe" && (isStructuralLiteral(operand) || isStructuralLiteral(expected))) {
+          return;
+        }
         if (context.sourceCode.getText(operand) !== context.sourceCode.getText(expected)) {
           return;
         }
@@ -7609,7 +7634,7 @@ var no_trailing_value_narration_default = createRule({
 });
 
 // src/rules/no-declaration-comment-wall.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES29 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES29, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
 
 // src/rules/_comment-wall.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES28 } from "@typescript-eslint/utils";
@@ -7809,7 +7834,13 @@ var no_declaration_comment_wall_default = createRule({
       const lead = ownsItsLine ? endingOn.get(member.loc.start.line - 1) : void 0;
       if (lead !== void 0) {
         const before = sourceCode.getTokenBefore(lead, { includeComments: false });
-        if (before === null || before.loc.end.line < lead.loc.start.line) return lead;
+        if (before === null || before.loc.end.line < lead.loc.start.line) {
+          const previousLine = endingOn.get(lead.loc.start.line - 1);
+          if (lead.type === AST_TOKEN_TYPES.Line && previousLine?.type === AST_TOKEN_TYPES.Line && previousLine.loc.start.column === lead.loc.start.column) {
+            return void 0;
+          }
+          return lead;
+        }
       }
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
@@ -8048,7 +8079,7 @@ var no_union_in_comment_default = createRule({
 });
 
 // src/rules/no-type-member-comment-wall.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES31 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES31, AST_TOKEN_TYPES as AST_TOKEN_TYPES2 } from "@typescript-eslint/utils";
 var noTypeMemberCommentWallDocumentation = {
   summary: "Flag an object type whose member comments mostly re-spell the members' own names and types.",
   rationale: "Repetitive member comments add scanning cost while hiding the comments that describe facts absent from the type.",
@@ -8111,7 +8142,13 @@ var no_type_member_comment_wall_default = createRule({
       const lead = ownsItsLine ? endingOn.get(member.loc.start.line - 1) : void 0;
       if (lead !== void 0) {
         const before = sourceCode.getTokenBefore(lead, { includeComments: false });
-        if (before === null || before.loc.end.line < lead.loc.start.line) return lead;
+        if (before === null || before.loc.end.line < lead.loc.start.line) {
+          const previousLine = endingOn.get(lead.loc.start.line - 1);
+          if (lead.type === AST_TOKEN_TYPES2.Line && previousLine?.type === AST_TOKEN_TYPES2.Line && previousLine.loc.start.column === lead.loc.start.column) {
+            return void 0;
+          }
+          return lead;
+        }
       }
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
@@ -8411,6 +8448,10 @@ import {
 } from "@typescript-eslint/utils";
 var MOCK_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Mock",
+  "Mocked",
+  "MockedClass",
+  "MockedFunction",
+  "MockedObject",
   "MockInstance",
   "SpyInstance"
 ]);
@@ -8658,9 +8699,9 @@ var no_zod_native_enum_default = createRule({
     }
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === AST_NODE_TYPES34.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES34.Identifier && callee.property.type === AST_NODE_TYPES34.Identifier) {
+      if (callee.type === AST_NODE_TYPES34.MemberExpression && callee.object.type === AST_NODE_TYPES34.Identifier && (callee.property.type === AST_NODE_TYPES34.Identifier && !callee.computed && callee.property.name === api || callee.computed && callee.property.type === AST_NODE_TYPES34.Literal && callee.property.value === api)) {
         const binding = resolvedBinding(callee.object);
-        return binding !== null && zodNamespaceBindings.has(binding) && callee.property.name === api;
+        return binding !== null && zodNamespaceBindings.has(binding);
       }
       if (callee.type === AST_NODE_TYPES34.Identifier) {
         const binding = resolvedBinding(callee);
@@ -9504,6 +9545,27 @@ var prefer_immutable_module_constant_default = createRule({
     }
     const exportedNames2 = /* @__PURE__ */ new Set();
     const typeAliases2 = /* @__PURE__ */ new Map();
+    const mutatesThroughConstAlias = (root) => {
+      const pending = [root];
+      const seen = /* @__PURE__ */ new Set();
+      while (pending.length > 0) {
+        const variable = pending.pop();
+        if (variable === void 0 || seen.has(variable)) continue;
+        seen.add(variable);
+        for (const reference of variable.references) {
+          const identifier = reference.identifier;
+          if (identifier.type !== AST_NODE_TYPES39.Identifier) continue;
+          if (referenceMutates(identifier, isUnshadowedGlobal)) return true;
+          const declarator = identifier.parent;
+          if (declarator.type !== AST_NODE_TYPES39.VariableDeclarator || declarator.init !== identifier || declarator.id.type !== AST_NODE_TYPES39.Identifier || declarator.parent.type !== AST_NODE_TYPES39.VariableDeclaration || declarator.parent.kind !== "const") {
+            continue;
+          }
+          const alias = sourceCode.getDeclaredVariables(declarator)[0];
+          if (alias !== void 0) pending.push(alias);
+        }
+      }
+      return false;
+    };
     return {
       Program(node) {
         for (const statement of node.body) {
@@ -9544,9 +9606,7 @@ var prefer_immutable_module_constant_default = createRule({
           return;
         }
         const variable = sourceCode.getDeclaredVariables(node)[0];
-        if (!directlyExported && !exportedNames2.has(node.id.name) && variable?.references.some(
-          (reference) => reference.identifier.type === AST_NODE_TYPES39.Identifier && referenceMutates(reference.identifier, isUnshadowedGlobal)
-        ) === true) {
+        if (!directlyExported && !exportedNames2.has(node.id.name) && variable !== void 0 && mutatesThroughConstAlias(variable)) {
           return;
         }
         context.report({
@@ -10325,6 +10385,10 @@ var prefer_module_level_schema_default = createRule({
         }
         for (const definition of resolved.defs) {
           if (definition.type === "ImportBinding") {
+            const parent = reference.identifier.parent;
+            if (parent?.type === AST_NODE_TYPES42.CallExpression && parent.callee === reference.identifier && !zodNamespaces.has(reference.identifier.name)) {
+              return false;
+            }
             continue;
           }
           if (definition.node.type === AST_NODE_TYPES42.VariableDeclarator && definition.node.parent.type === AST_NODE_TYPES42.VariableDeclaration && definition.node.parent.kind !== "const") {
@@ -12156,10 +12220,7 @@ var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
 ]);
 var OPTIONAL_MODIFIERS = /* @__PURE__ */ new Set([
   "optional",
-  "nullish",
-  "default",
-  "prefault",
-  "catch"
+  "nullish"
 ]);
 var NULLABLE_MODIFIERS = /* @__PURE__ */ new Set(["nullable", "nullish"]);
 var RESHAPING_MODIFIERS = /* @__PURE__ */ new Set([
@@ -13434,6 +13495,7 @@ var ZOD_PARSE_METHODS = /* @__PURE__ */ new Set([
   "parseAsync",
   "safeParseAsync"
 ]);
+var FORM_VALUE_METHODS = /* @__PURE__ */ new Set(["get", "getAll"]);
 var zodReceiverRoot = (node) => {
   let current = node;
   while (true) {
@@ -13508,7 +13570,7 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormSourceIdentifier = (node) => {
       if (node.type !== AST_NODE_TYPES53.Identifier) return false;
-      if (/formdata/i.test(node.name)) return true;
+      const conventionalName = /formdata/i.test(node.name);
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
@@ -13517,16 +13579,16 @@ var require_zod_form_validation_default = createRule({
           if (def !== void 0 && def.type === "Variable" && def.node.type === AST_NODE_TYPES53.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
-          return false;
+          return def?.type === "Parameter" && conventionalName;
         }
         scope = scope.upper;
       }
-      return false;
+      return conventionalName;
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
       if (callee.type !== AST_NODE_TYPES53.MemberExpression) return false;
-      if (callee.property.type !== AST_NODE_TYPES53.Identifier || callee.property.name !== "get") {
+      if (callee.property.type !== AST_NODE_TYPES53.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -13620,6 +13682,40 @@ var require_zod_form_validation_default = createRule({
       }
       return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === AST_NODE_TYPES53.Literal && parent.right.value === null || parent.right.type === AST_NODE_TYPES53.Identifier && parent.right.name === "undefined");
     };
+    const isDescendantOf = (node, ancestor) => {
+      let current = node;
+      while (current !== void 0 && current !== null) {
+        if (current === ancestor) return true;
+        current = current.parent;
+      }
+      return false;
+    };
+    const blockTerminates = (node) => {
+      if (node.type === AST_NODE_TYPES53.ReturnStatement || node.type === AST_NODE_TYPES53.ThrowStatement) {
+        return true;
+      }
+      if (node.type !== AST_NODE_TYPES53.BlockStatement || node.body.length === 0) return false;
+      const last = node.body.at(-1);
+      return last !== void 0 && blockTerminates(last);
+    };
+    const narrowingIf = (identifier) => {
+      const comparison = identifier.parent;
+      if (comparison?.type !== AST_NODE_TYPES53.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== AST_NODE_TYPES53.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+        return null;
+      }
+      const maybeNegation = comparison.parent;
+      const negated = maybeNegation?.type === AST_NODE_TYPES53.UnaryExpression && maybeNegation.operator === "!";
+      const test = negated ? maybeNegation : comparison;
+      const branch = test.parent;
+      return branch?.type === AST_NODE_TYPES53.IfStatement && branch.test === test ? { branch, positive: !negated } : null;
+    };
+    const useDominatedByNarrowing = (use, narrowings) => narrowings.some(({ branch, positive }) => {
+      if (positive) return isDescendantOf(use, branch.consequent);
+      if (!blockTerminates(branch.consequent)) return false;
+      const branchStatement = containingStatement(branch);
+      const useStatement = containingStatement(use);
+      return branchStatement !== null && useStatement !== null && branchStatement.parent === useStatement.parent && branchStatement.range[1] < useStatement.range[0];
+    });
     const statementWithinBlock = (node, block) => {
       let current = node;
       while (current.parent !== void 0 && current.parent !== block) {
@@ -13634,14 +13730,16 @@ var require_zod_form_validation_default = createRule({
         (identifier) => identifier.type === AST_NODE_TYPES53.Identifier
       );
       if (references.length === 0) return false;
-      if (references.some(isInstanceofNarrowing)) return true;
+      const narrowings = references.map(narrowingIf).filter(
+        (value) => value !== null
+      );
       const validationStatements = references.map((reference) => guaranteedValidationStatement(declarator, reference)).filter(
         (statement) => statement !== null
       );
       const declarationStatement = containingStatement(declarator);
       const declarationBlock = declarationStatement?.parent;
       return references.every((reference) => {
-        if (zodParseAncestor(reference) !== null || isSafePrevalidationInspection(reference)) {
+        if (zodParseAncestor(reference) !== null || isSafePrevalidationInspection(reference) || useDominatedByNarrowing(reference, narrowings)) {
           return true;
         }
         if (declarationBlock === void 0) return false;
@@ -13744,8 +13842,13 @@ import { AST_NODE_TYPES as AST_NODE_TYPES54, ASTUtils as ASTUtils15 } from "@typ
 var stepdownDocumentation = {
   summary: "Place a private helper below its sole direct same-scope caller.",
   rationale: "Caller-first ordering lets a reader follow the main flow before descending into implementation details.",
-  remediation: "Move the private helper immediately below its sole caller.",
+  remediation: "Move the private helper below its sole caller.",
   category: "maintainability",
+  limitations: [
+    "Generated and test files, cycles, dynamic references, overload targets, and helpers with multiple callers are excluded.",
+    "Class methods are reported only when both helper and caller are private so accessibility ordering remains authoritative.",
+    "Runtime class-field, static-block, computed-member, and decorator barriers are never crossed."
+  ],
   examples: [
     { id: "caller-before-helper", title: "Place the caller first", outcome: "no-match", files: [{ path: "src/run.ts", source: "function run() { return load(); }\nfunction load() { return 1; }" }], focusPath: "src/run.ts", expectedCount: 0, public: true },
     { id: "helper-before-caller", title: "Do not lead with a sole-caller helper", outcome: "match", files: [{ path: "src/run.ts", source: "function load() { return 1; }\nfunction run() { return load(); }" }], focusPath: "src/run.ts", expectedCount: 1, public: true }
@@ -13754,7 +13857,7 @@ var stepdownDocumentation = {
 function isFunction(node) {
   return node.type === AST_NODE_TYPES54.ArrowFunctionExpression || node.type === AST_NODE_TYPES54.FunctionDeclaration || node.type === AST_NODE_TYPES54.FunctionExpression;
 }
-function reportMisordered(context, candidates, scopeDefinitions, calls, pinned) {
+function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
   const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
   const cycles = cycleComponents(calls);
   const callers = /* @__PURE__ */ new Map();
@@ -13772,7 +13875,7 @@ function reportMisordered(context, candidates, scopeDefinitions, calls, pinned)
     const callerName2 = helperCallers[0];
     if (callerName2 === void 0 || cycles.has(helper.name) && cycles.get(helper.name) === cycles.get(callerName2)) continue;
     const caller = byName.get(callerName2);
-    if (caller === void 0 || helper.node.range[0] >= caller.node.range[0]) continue;
+    if (caller === void 0 || helper.node.range[0] >= caller.node.range[0] || !canMove(helper, caller)) continue;
     context.report({
       node: helper.node,
       messageId: "helperAboveOnlyCaller",
@@ -13852,8 +13955,10 @@ function moduleScope(context, program) {
     })
   );
   const exported = exportedNames(program);
-  const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1 && !overloadNames.has(node.name));
-  const definitions = scopeDefinitions.filter((definition) => !exported.has(definition.name));
+  const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1);
+  const definitions = scopeDefinitions.filter(
+    (definition) => !exported.has(definition.name) && !overloadNames.has(definition.name)
+  );
   const byFunction = new Map(scopeDefinitions.map((definition) => [definition.functionNode, definition]));
   const calls = /* @__PURE__ */ new Map();
   const pinned = /* @__PURE__ */ new Set();
@@ -14097,11 +14202,36 @@ function classScope(context, node, computedReferenceNames) {
       return [definition.name, accessibility2];
     })
   );
+  const methodByName = new Map(scopeDefinitions.map((definition) => [definition.name, definition.node]));
   for (const [caller, callees] of calls) {
-    if (accessibility.get(caller) === "private") continue;
+    const callerMethod = methodByName.get(caller);
+    if (accessibility.get(caller) === "private" && callerMethod?.type === AST_NODE_TYPES54.MethodDefinition && callerMethod.decorators.length === 0) continue;
     for (const callee of callees) pinned.add(callee);
   }
-  reportMisordered(context, definitions, scopeDefinitions, calls, pinned);
+  const memberIndexes = new Map(node.body.body.map((member, index) => [member, index]));
+  const runtimeBarrierPrefix = [0];
+  for (const member of node.body.body) {
+    runtimeBarrierPrefix.push((runtimeBarrierPrefix.at(-1) ?? 0) + (isClassRuntimeBarrier(member) ? 1 : 0));
+  }
+  reportMisordered(context, definitions, scopeDefinitions, calls, pinned, (helper, caller) => {
+    const helperIndex = memberIndexes.get(helper.node);
+    const callerIndex = memberIndexes.get(caller.node);
+    if (helperIndex === void 0 || callerIndex === void 0) return false;
+    return runtimeBarrierPrefix[callerIndex + 1] === runtimeBarrierPrefix[helperIndex + 1];
+  });
+}
+function isClassRuntimeBarrier(member) {
+  switch (member.type) {
+    case AST_NODE_TYPES54.StaticBlock:
+      return true;
+    case AST_NODE_TYPES54.PropertyDefinition:
+    case AST_NODE_TYPES54.AccessorProperty:
+      return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
+    case AST_NODE_TYPES54.MethodDefinition:
+      return member.computed || member.decorators.length > 0;
+    default:
+      return false;
+  }
 }
 var stepdown_default = createRule({
   name: "stepdown",
@@ -14174,7 +14304,13 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "safeDecodeAsync",
   "toJSONSchema",
   "registry",
-  "implement"
+  "implement",
+  "flattenError",
+  "formatError",
+  "isNullable",
+  "isOptional",
+  "prettifyError",
+  "treeifyError"
 ]);
 var terminalMethodName = (callee) => !callee.computed && callee.property.type === AST_NODE_TYPES55.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
@@ -14423,7 +14559,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.4.0"
+  version: "15.6.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",