@sarj/eslint-plugin 15.4.0 → 15.6.0

package/dist/index.cjs

@@ -607,6 +607,9 @@ function isAssertionStatement(statement) {
   const expression = statement.expression;
   return expression.type === import_utils3.AST_NODE_TYPES.CallExpression && isAssertionCall(expression);
 }
+function isTypeOnlyContractStatement(statement) {
+  return statement.type === import_utils3.AST_NODE_TYPES.TSTypeAliasDeclaration || statement.type === import_utils3.AST_NODE_TYPES.TSInterfaceDeclaration;
+}
 function normalizedLiteral(node) {
   if ("regex" in node) {
     return ["Literal", "regex", node.regex.pattern, node.regex.flags];
@@ -664,7 +667,7 @@ var duplicate_test_body_default = createRule({
           return;
         }
         const body2 = candidate.body;
-        if (body2.body.type !== import_utils3.AST_NODE_TYPES.BlockStatement || body2.body.body.length < MIN_STATEMENTS || body2.body.body.every(isAssertionStatement)) {
+        if (body2.body.type !== import_utils3.AST_NODE_TYPES.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]);
@@ -3559,7 +3562,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([
@@ -3696,13 +3703,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") {
@@ -4208,7 +4231,7 @@ var import_utils21 = require("@typescript-eslint/utils");
 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: [
@@ -4217,36 +4240,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 [];
@@ -4262,50 +4270,6 @@ function declaredNames(declaration) {
     (item) => item.id.type === import_utils21.AST_NODE_TYPES.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 === import_utils21.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils21.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (statement.type === import_utils21.AST_NODE_TYPES.ImportDeclaration) {
-      for (const specifier of statement.specifiers) {
-        if (statement.importKind === "type" || specifier.type === import_utils21.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") {
-          names.add(specifier.local.name);
-        } else {
-          runtimeNames.add(specifier.local.name);
-        }
-      }
-      continue;
-    }
-    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSDeclareFunction && declaration.id !== null) {
-      names.add(declaration.id.name);
-      continue;
-    }
-    if (declaration !== null && declaration.declare === true) {
-      if ((declaration.type === import_utils21.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.TSEnumDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === import_utils21.AST_NODE_TYPES.Identifier) names.add(declaration.id.name);
-      if (declaration.type === import_utils21.AST_NODE_TYPES.VariableDeclaration) {
-        for (const item of declaration.declarations) {
-          if (item.id.type === import_utils21.AST_NODE_TYPES.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 exports2 = [];
   const typeBindings = typeOnlyBindings(program);
@@ -4344,25 +4308,49 @@ function runtimeExports(program) {
   const unique = new Map(exports2.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 !== import_utils21.AST_NODE_TYPES.ExportNamedDeclaration) continue;
-    const declaration = statement.declaration;
-    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils21.AST_NODE_TYPES.TSTypeAliasDeclaration) names.add(declaration.id.name);
-    for (const specifier of statement.specifiers) {
-      const local = specifier.local.type === import_utils21.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
-      if (statement.exportKind !== "type" && specifier.exportKind !== "type" && !typeBindings.has(local)) {
-        continue;
+    const declaration = statement.type === import_utils21.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils21.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (statement.type === import_utils21.AST_NODE_TYPES.ImportDeclaration) {
+      for (const specifier of statement.specifiers) {
+        if (statement.importKind === "type" || specifier.type === import_utils21.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") {
+          names.add(specifier.local.name);
+        } else {
+          runtimeNames.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    if (declaration?.type === import_utils21.AST_NODE_TYPES.TSDeclareFunction && declaration.id !== null) {
+      names.add(declaration.id.name);
+      continue;
+    }
+    if (declaration !== null && declaration.declare === true) {
+      if ((declaration.type === import_utils21.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.TSEnumDeclaration || declaration.type === import_utils21.AST_NODE_TYPES.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === import_utils21.AST_NODE_TYPES.Identifier) names.add(declaration.id.name);
+      if (declaration.type === import_utils21.AST_NODE_TYPES.VariableDeclaration) {
+        for (const item of declaration.declarations) {
+          if (item.id.type === import_utils21.AST_NODE_TYPES.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 === import_utils21.AST_NODE_TYPES.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 = import_utils21.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
@@ -4384,14 +4372,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) {
@@ -4404,25 +4392,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 exports2 = runtimeExports(program);
         if (exports2.ambiguous || exports2.exports.length !== 1) return;
         const onlyExport = exports2.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 }
         });
       }
     };
@@ -6815,6 +6797,13 @@ function nearestEnclosingFunction(node) {
   }
   return null;
 }
+function isImmediatelyConsumedSleep(node) {
+  const parent = node.parent;
+  if (parent?.type === import_utils34.AST_NODE_TYPES.AwaitExpression || parent?.type === import_utils34.AST_NODE_TYPES.ReturnStatement || parent?.type === import_utils34.AST_NODE_TYPES.ExpressionStatement) {
+    return true;
+  }
+  return parent?.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression && parent.body === node;
+}
 function isTestBody(fn) {
   const call = fn.parent;
   if (call?.type !== import_utils34.AST_NODE_TYPES.CallExpression || !call.arguments.some((argument) => argument === fn)) {
@@ -6857,6 +6846,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;
@@ -7154,6 +7146,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,
@@ -7164,7 +7177,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: [],
@@ -7174,6 +7188,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;
@@ -7278,6 +7297,9 @@ function isLiteral(node) {
       return false;
   }
 }
+function isStructuralLiteral(node) {
+  return node.type === import_utils37.AST_NODE_TYPES.ArrayExpression || node.type === import_utils37.AST_NODE_TYPES.ObjectExpression;
+}
 function expectOperand(callee) {
   const receiver = callee.object;
   if (receiver.type !== import_utils37.AST_NODE_TYPES.CallExpression || receiver.callee.type !== import_utils37.AST_NODE_TYPES.Identifier || receiver.callee.name !== "expect" || receiver.arguments.length !== 1) {
@@ -7334,6 +7356,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;
         }
@@ -7847,7 +7872,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 === import_utils40.AST_TOKEN_TYPES.Line && previousLine?.type === import_utils40.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;
@@ -8149,7 +8180,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 === import_utils42.AST_TOKEN_TYPES.Line && previousLine?.type === import_utils42.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;
@@ -8446,6 +8483,10 @@ var no_unnecessary_use_client_default = createRule({
 var import_utils44 = require("@typescript-eslint/utils");
 var MOCK_TYPE_NAMES = /* @__PURE__ */ new Set([
   "Mock",
+  "Mocked",
+  "MockedClass",
+  "MockedFunction",
+  "MockedObject",
   "MockInstance",
   "SpyInstance"
 ]);
@@ -8689,9 +8730,9 @@ var no_zod_native_enum_default = createRule({
     }
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && (callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && !callee.computed && callee.property.name === api || callee.computed && callee.property.type === import_utils45.AST_NODE_TYPES.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 === import_utils45.AST_NODE_TYPES.Identifier) {
         const binding = resolvedBinding(callee);
@@ -9535,6 +9576,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 !== import_utils51.AST_NODE_TYPES.Identifier) continue;
+          if (referenceMutates(identifier, isUnshadowedGlobal)) return true;
+          const declarator = identifier.parent;
+          if (declarator.type !== import_utils51.AST_NODE_TYPES.VariableDeclarator || declarator.init !== identifier || declarator.id.type !== import_utils51.AST_NODE_TYPES.Identifier || declarator.parent.type !== import_utils51.AST_NODE_TYPES.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) {
@@ -9575,9 +9637,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 === import_utils51.AST_NODE_TYPES.Identifier && referenceMutates(reference.identifier, isUnshadowedGlobal)
-        ) === true) {
+        if (!directlyExported && !exportedNames2.has(node.id.name) && variable !== void 0 && mutatesThroughConstAlias(variable)) {
           return;
         }
         context.report({
@@ -10356,6 +10416,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 === import_utils54.AST_NODE_TYPES.CallExpression && parent.callee === reference.identifier && !zodNamespaces.has(reference.identifier.name)) {
+              return false;
+            }
             continue;
           }
           if (definition.node.type === import_utils54.AST_NODE_TYPES.VariableDeclarator && definition.node.parent.type === import_utils54.AST_NODE_TYPES.VariableDeclaration && definition.node.parent.kind !== "const") {
@@ -12187,10 +12251,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([
@@ -13459,6 +13520,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) {
@@ -13533,7 +13595,7 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormSourceIdentifier = (node) => {
       if (node.type !== import_utils66.AST_NODE_TYPES.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);
@@ -13542,16 +13604,16 @@ var require_zod_form_validation_default = createRule({
           if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils66.AST_NODE_TYPES.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 !== import_utils66.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.property.type !== import_utils66.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -13645,6 +13707,40 @@ var require_zod_form_validation_default = createRule({
       }
       return ["===", "!==", "==", "!="].includes(parent.operator) && (parent.right.type === import_utils66.AST_NODE_TYPES.Literal && parent.right.value === null || parent.right.type === import_utils66.AST_NODE_TYPES.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 === import_utils66.AST_NODE_TYPES.ReturnStatement || node.type === import_utils66.AST_NODE_TYPES.ThrowStatement) {
+        return true;
+      }
+      if (node.type !== import_utils66.AST_NODE_TYPES.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 !== import_utils66.AST_NODE_TYPES.BinaryExpression || comparison.operator !== "instanceof" || comparison.left !== identifier || comparison.right.type !== import_utils66.AST_NODE_TYPES.Identifier || comparison.right.name !== "File" && comparison.right.name !== "Blob") {
+        return null;
+      }
+      const maybeNegation = comparison.parent;
+      const negated = maybeNegation?.type === import_utils66.AST_NODE_TYPES.UnaryExpression && maybeNegation.operator === "!";
+      const test = negated ? maybeNegation : comparison;
+      const branch = test.parent;
+      return branch?.type === import_utils66.AST_NODE_TYPES.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) {
@@ -13659,14 +13755,16 @@ var require_zod_form_validation_default = createRule({
         (identifier) => identifier.type === import_utils66.AST_NODE_TYPES.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;
@@ -13769,8 +13867,13 @@ var import_utils68 = require("@typescript-eslint/utils");
 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 }
@@ -13779,7 +13882,7 @@ var stepdownDocumentation = {
 function isFunction(node) {
   return node.type === import_utils68.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils68.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils68.AST_NODE_TYPES.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();
@@ -13797,7 +13900,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",
@@ -13877,8 +13980,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();
@@ -14122,11 +14227,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 === import_utils68.AST_NODE_TYPES.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 import_utils68.AST_NODE_TYPES.StaticBlock:
+      return true;
+    case import_utils68.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils68.AST_NODE_TYPES.AccessorProperty:
+      return member.static || member.computed || member.decorators.length > 0 || member.value !== null;
+    case import_utils68.AST_NODE_TYPES.MethodDefinition:
+      return member.computed || member.decorators.length > 0;
+    default:
+      return false;
+  }
 }
 var stepdown_default = createRule({
   name: "stepdown",
@@ -14196,7 +14326,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 === import_utils69.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainRoot = (node) => {
@@ -14445,7 +14581,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.4.0"
+  version: "15.6.0"
 };
 var applicationOnlyRules = [
   "no-restricted-library-load",