@sarj/eslint-plugin 15.28.1 → 16.1.0

package/dist/index.cjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
   ADVISORY_RULES: () => ADVISORY_RULES,
   APPLICATION_ONLY_RULES: () => APPLICATION_ONLY_RULES,
   RECOMMENDED_RULES: () => RECOMMENDED_RULES,
@@ -39,7 +39,7 @@ __export(index_exports, {
   STRICT_RULES: () => STRICT_RULES,
   advisoryRules: () => ADVISORY_RULES,
   applicationOnlyRules: () => APPLICATION_ONLY_RULES,
-  default: () => index_default,
+  default: () => src_default,
   publicDocumentation: () => publicDocumentation,
   recommendedRules: () => RECOMMENDED_RULES,
   renamedRules: () => RENAMED_RULES,
@@ -47,7 +47,7 @@ __export(index_exports, {
   rules: () => RULES,
   strictRules: () => STRICT_RULES
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/rules/no-conditional-empty-object-spread.ts
 var import_utils2 = require("@typescript-eslint/utils");
@@ -489,8 +489,8 @@ var prefer_typed_reflection_default = createRule({
     const services = import_utils3.ESLintUtils.getParserServices(context);
     if (!services.program) return {};
     const checker = services.program.getTypeChecker();
-    const globalName = (node, name) => node.type === import_utils3.AST_NODE_TYPES.Identifier && node.name === name && !import_utils3.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
     const isReflect = (node) => globalName(node, "Reflect") || node.type === import_utils3.AST_NODE_TYPES.MemberExpression && propertyName(node) === "Reflect" && globalName(node.object, "globalThis");
+    const globalName = (node, name) => node.type === import_utils3.AST_NODE_TYPES.Identifier && node.name === name && !import_utils3.ASTUtils.findVariable(context.sourceCode.getScope(node), name)?.defs.length;
     const closedObject = (type) => {
       if (type.isUnion()) return type.types.every(closedObject);
       return knownType(type) && type.getProperties().length > 0 && checker.getIndexInfosOfType(type).length === 0;
@@ -727,6 +727,14 @@ var no_reduce_accumulator_copy_default = createRule({
         const accumulator = context.sourceCode.getDeclaredVariables(callback).find((variable) => variable.identifiers.includes(parameter));
         if (!accumulator || accumulator.references.some((reference) => reference.isWrite())) return;
         const referencesAccumulator = (value) => value.type === import_utils5.AST_NODE_TYPES.Identifier && import_utils5.ASTUtils.findVariable(context.sourceCode.getScope(value), value.name) === accumulator;
+        const inspect = (current) => {
+          if (current !== callback.body && [import_utils5.AST_NODE_TYPES.ArrowFunctionExpression, import_utils5.AST_NODE_TYPES.FunctionExpression, import_utils5.AST_NODE_TYPES.FunctionDeclaration].some((kind) => kind === current.type)) return;
+          if (current.type === import_utils5.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils5.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils5.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
+            context.report({ node: current, messageId: "copy" });
+          }
+          if (current.type === import_utils5.AST_NODE_TYPES.CallExpression) inspectCall(current);
+          forEachAstChild(current, context.sourceCode.visitorKeys, inspect);
+        };
         const inspectCall = (current) => {
           if (current.callee.type !== import_utils5.AST_NODE_TYPES.MemberExpression) return;
           const member = current.callee;
@@ -739,14 +747,6 @@ var no_reduce_accumulator_copy_default = createRule({
           const assignCopy = objectSeed && name === "assign" && globalObject && target?.type === import_utils5.AST_NODE_TYPES.ObjectExpression && current.arguments.slice(1).some(referencesAccumulator);
           if (directCopy || fromCopy || assignCopy) context.report({ node: current, messageId: "copy" });
         };
-        const inspect = (current) => {
-          if (current !== callback.body && [import_utils5.AST_NODE_TYPES.ArrowFunctionExpression, import_utils5.AST_NODE_TYPES.FunctionExpression, import_utils5.AST_NODE_TYPES.FunctionDeclaration].some((kind) => kind === current.type)) return;
-          if (current.type === import_utils5.AST_NODE_TYPES.SpreadElement && (arraySeed && current.parent.type === import_utils5.AST_NODE_TYPES.ArrayExpression || objectSeed && current.parent.type === import_utils5.AST_NODE_TYPES.ObjectExpression) && referencesAccumulator(current.argument)) {
-            context.report({ node: current, messageId: "copy" });
-          }
-          if (current.type === import_utils5.AST_NODE_TYPES.CallExpression) inspectCall(current);
-          forEachAstChild(current, context.sourceCode.visitorKeys, inspect);
-        };
         inspect(callback.body);
       }
     };
@@ -3650,28 +3650,6 @@ var no_cors_wildcard_with_credentials_default = createRule({
     const scopeHeaderSets = /* @__PURE__ */ new Map();
     const variableIds = /* @__PURE__ */ new WeakMap();
     let nextVariableId = 0;
-    function variableId(variable) {
-      const existing = variableIds.get(variable);
-      if (existing !== void 0) return existing;
-      const value = nextVariableId++;
-      variableIds.set(variable, value);
-      return value;
-    }
-    function receiverIdentity(node) {
-      if (node.type === import_utils23.AST_NODE_TYPES.Identifier) {
-        const variable = import_utils23.ASTUtils.findVariable(
-          context.sourceCode.getScope(node),
-          node.name
-        );
-        return variable === null ? `global:${node.name}` : `variable:${variableId(variable)}`;
-      }
-      if (node.type === import_utils23.AST_NODE_TYPES.ThisExpression) return "this";
-      if (node.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Identifier) {
-        const owner = receiverIdentity(node.object);
-        return owner === null ? null : `${owner}.${node.property.name}`;
-      }
-      return null;
-    }
     function recordHeaderSet(node, kind) {
       if (node.callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) return;
       const receiver = receiverIdentity(node.callee.object);
@@ -3693,6 +3671,28 @@ var no_cors_wildcard_with_credentials_default = createRule({
         entry.credentialsNodes.push(node);
       }
     }
+    function receiverIdentity(node) {
+      if (node.type === import_utils23.AST_NODE_TYPES.Identifier) {
+        const variable = import_utils23.ASTUtils.findVariable(
+          context.sourceCode.getScope(node),
+          node.name
+        );
+        return variable === null ? `global:${node.name}` : `variable:${variableId(variable)}`;
+      }
+      if (node.type === import_utils23.AST_NODE_TYPES.ThisExpression) return "this";
+      if (node.type === import_utils23.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils23.AST_NODE_TYPES.Identifier) {
+        const owner = receiverIdentity(node.object);
+        return owner === null ? null : `${owner}.${node.property.name}`;
+      }
+      return null;
+    }
+    function variableId(variable) {
+      const existing = variableIds.get(variable);
+      if (existing !== void 0) return existing;
+      const value = nextVariableId++;
+      variableIds.set(variable, value);
+      return value;
+    }
     return {
       NewExpression(node) {
         if (isCorsWildcardCredentialsCall(node)) {
@@ -4482,20 +4482,6 @@ function functionComplexity(fn, visitorKeys) {
   function add(node, nesting, construct) {
     points.push({ line: node.loc.start.line, amount: nesting + 1, construct });
   }
-  function logical(node, nesting) {
-    let previous;
-    function flatten(expression) {
-      if (expression.type !== import_utils29.AST_NODE_TYPES.LogicalExpression || expression.operator === "??") {
-        visit(expression, nesting);
-        return;
-      }
-      flatten(expression.left);
-      if (previous !== expression.operator) add(expression, 0, expression.operator);
-      previous = expression.operator;
-      flatten(expression.right);
-    }
-    flatten(node);
-  }
   function conditional(node, nesting) {
     add(node, nesting, "if");
     let branch = node;
@@ -4574,6 +4560,20 @@ function functionComplexity(fn, visitorKeys) {
     }
     visitChildren(node, nesting);
   }
+  function logical(node, nesting) {
+    let previous;
+    function flatten(expression) {
+      if (expression.type !== import_utils29.AST_NODE_TYPES.LogicalExpression || expression.operator === "??") {
+        visit(expression, nesting);
+        return;
+      }
+      flatten(expression.left);
+      if (previous !== expression.operator) add(expression, 0, expression.operator);
+      previous = expression.operator;
+      flatten(expression.right);
+    }
+    flatten(node);
+  }
   function visitChildren(node, nesting) {
     forEachAstChild(node, visitorKeys, (child) => visit(child, nesting));
   }
@@ -5196,6 +5196,14 @@ var no_hand_rolled_sleep_default = createRule({
       const callee = callback.type === import_utils31.AST_NODE_TYPES.Identifier ? callback : callback.type === import_utils31.AST_NODE_TYPES.ArrowFunctionExpression || callback.type === import_utils31.AST_NODE_TYPES.FunctionExpression ? soleCall(callback)?.callee : null;
       return callee?.type === import_utils31.AST_NODE_TYPES.Identifier && bindingOf(callee) === bindingOf(parameter);
     };
+    let clientModule = null;
+    const reportsSleepHere = () => {
+      if (checkClientModules) {
+        return true;
+      }
+      clientModule ??= isClientModule2();
+      return !clientModule;
+    };
     function isClientModule2() {
       if (/\.[cm]?[jt]sx$/.test(filename)) {
         return true;
@@ -5211,14 +5219,6 @@ var no_hand_rolled_sleep_default = createRule({
       }
       return false;
     }
-    let clientModule = null;
-    const reportsSleepHere = () => {
-      if (checkClientModules) {
-        return true;
-      }
-      clientModule ??= isClientModule2();
-      return !clientModule;
-    };
     return {
       NewExpression(node) {
         if (node.callee.type !== import_utils31.AST_NODE_TYPES.Identifier || node.callee.name !== "Promise" || !isGlobal(node.callee)) {
@@ -5648,13 +5648,6 @@ var no_detached_global_fetch_default = createRule({
       const variable = bindingOf(identifier);
       if (variable !== null && isStableAlias(variable)) aliases.add(variable);
     }
-    function isGlobalFetchMember(node) {
-      if (!isGlobalReceiver(node.object)) return false;
-      if (!node.computed) {
-        return node.property.type === import_utils34.AST_NODE_TYPES.Identifier && node.property.name === "fetch";
-      }
-      return node.property.type === import_utils34.AST_NODE_TYPES.Literal && node.property.value === "fetch";
-    }
     function staticMemberName9(node) {
       if (!node.computed) {
         return node.property.type === import_utils34.AST_NODE_TYPES.Identifier ? node.property.name : null;
@@ -5683,6 +5676,13 @@ var no_detached_global_fetch_default = createRule({
       }
       return false;
     }
+    function isGlobalFetchMember(node) {
+      if (!isGlobalReceiver(node.object)) return false;
+      if (!node.computed) {
+        return node.property.type === import_utils34.AST_NODE_TYPES.Identifier && node.property.name === "fetch";
+      }
+      return node.property.type === import_utils34.AST_NODE_TYPES.Literal && node.property.value === "fetch";
+    }
     function recordAliasFromValue(identifier, value) {
       if (mayBeRawFetch(value)) recordAlias(identifier);
     }
@@ -6241,17 +6241,6 @@ var no_impossible_zod_literal_bounds_default = createRule({
       }
       return false;
     }
-    function baseKind(node) {
-      const callee = node.callee;
-      if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
-        return resolvesToTrackedImport(callee) ? constructors.get(callee.name) ?? null : null;
-      }
-      if (callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils37.AST_NODE_TYPES.Identifier || !namespaces.has(callee.object.name) || !resolvesToTrackedImport(callee.object)) {
-        return null;
-      }
-      const name = memberName(callee);
-      return name !== null && KINDS.has(name) ? name : null;
-    }
     function readChain(node) {
       const calls = [];
       let current = node;
@@ -6268,6 +6257,17 @@ var no_impossible_zod_literal_bounds_default = createRule({
         current = callee.object;
       }
     }
+    function baseKind(node) {
+      const callee = node.callee;
+      if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
+        return resolvesToTrackedImport(callee) ? constructors.get(callee.name) ?? null : null;
+      }
+      if (callee.type !== import_utils37.AST_NODE_TYPES.MemberExpression || callee.object.type !== import_utils37.AST_NODE_TYPES.Identifier || !namespaces.has(callee.object.name) || !resolvesToTrackedImport(callee.object)) {
+        return null;
+      }
+      const name = memberName(callee);
+      return name !== null && KINDS.has(name) ? name : null;
+    }
     function isInsideReshapingCall(node) {
       let child = node;
       let parent = child.parent;
@@ -6581,30 +6581,30 @@ var no_redundant_optional_array_default_default = createRule({
       }
       return false;
     }
-    function isZodSchemaExpression(node) {
+    function isArraySchemaExpression(node) {
       if (node.type !== import_utils39.AST_NODE_TYPES.CallExpression) return false;
       const { callee } = node;
       if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
-        return resolvesToTrackedImport(callee);
+        return arrayConstructors.has(callee.name) && resolvesToTrackedImport(callee);
       }
       if (callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object)) {
+      const method = memberName2(callee);
+      if (method === "array" && (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier ? namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object) : isZodSchemaExpression(callee.object))) {
         return true;
       }
-      return isZodSchemaExpression(callee.object);
+      return isArraySchemaExpression(callee.object);
     }
-    function isArraySchemaExpression(node) {
+    function isZodSchemaExpression(node) {
       if (node.type !== import_utils39.AST_NODE_TYPES.CallExpression) return false;
       const { callee } = node;
       if (callee.type === import_utils39.AST_NODE_TYPES.Identifier) {
-        return arrayConstructors.has(callee.name) && resolvesToTrackedImport(callee);
+        return resolvesToTrackedImport(callee);
       }
       if (callee.type !== import_utils39.AST_NODE_TYPES.MemberExpression) return false;
-      const method = memberName2(callee);
-      if (method === "array" && (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier ? namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object) : isZodSchemaExpression(callee.object))) {
+      if (callee.object.type === import_utils39.AST_NODE_TYPES.Identifier && namespaces.has(callee.object.name) && resolvesToTrackedImport(callee.object)) {
         return true;
       }
-      return isArraySchemaExpression(callee.object);
+      return isZodSchemaExpression(callee.object);
     }
     return {
       ImportDeclaration(node) {
@@ -7036,10 +7036,6 @@ var no_log_only_catch_default = createRule({
       }
       return matcher.isLoggingCall(statement.expression);
     }
-    function hasCommentDirectlyAbove(node) {
-      const above = sourceCode.getCommentsBefore(node).at(-1);
-      return above !== void 0 && above.loc.end.line === node.loc.start.line - 1;
-    }
     function hasAdjacentRationale(node) {
       const tryStatement = node.parent;
       if (hasCommentDirectlyAbove(tryStatement) || hasCommentDirectlyAbove(node)) return true;
@@ -7049,6 +7045,10 @@ var no_log_only_catch_default = createRule({
       }
       return hasCommentDirectlyAbove(block.parent);
     }
+    function hasCommentDirectlyAbove(node) {
+      const above = sourceCode.getCommentsBefore(node).at(-1);
+      return above !== void 0 && above.loc.end.line === node.loc.start.line - 1;
+    }
     if (isTestFile(filename) || BENCHMARK_DIR_RE.test(filename.replaceAll("\\", "/"))) {
       return {};
     }
@@ -7521,20 +7521,9 @@ var no_vague_suppression_description_default = createRule({
   }
 });
 
-// src/rules/no-generic-single-export-module.ts
+// src/rules/_runtime-exports.ts
 var import_utils47 = require("@typescript-eslint/utils");
-var NO_GENERIC_SINGLE_EXPORT_MODULE_DOCUMENTATION = {
-  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: "Choose a responsibility-bearing module name or colocate the export with its domain.",
-  category: "maintainability",
-  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/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 }
-  ]
-};
-var GENERIC_STEMS = /* @__PURE__ */ new Set([
+var GENERIC_MODULE_STEMS = /* @__PURE__ */ new Set([
   "common",
   "helper",
   "helpers",
@@ -7545,164 +7534,172 @@ var GENERIC_STEMS = /* @__PURE__ */ new Set([
   "utils"
 ]);
 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 [stem4 = "", ...suffixes] = base.slice(0, -extension.length).split(".");
-  return { stem: stem4, suffixes: suffixes.map((suffix) => suffix.toLowerCase()) };
-}
-function declaredNames(declaration) {
-  if (declaration.declare === true) return [];
-  if (declaration.type === import_utils47.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.TSEnumDeclaration) {
-    if (declaration.type === import_utils47.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) return [];
-    return declaration.id === null ? [] : [declaration.id.name];
-  }
-  if (declaration.type === import_utils47.AST_NODE_TYPES.TSModuleDeclaration && declaration.id.type === import_utils47.AST_NODE_TYPES.Identifier) {
-    return [declaration.id.name];
-  }
-  if (declaration.type !== import_utils47.AST_NODE_TYPES.VariableDeclaration) return [];
-  return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils47.AST_NODE_TYPES.Identifier ? [item.id.name] : []
-  );
-}
 function runtimeExports(program) {
-  const exports2 = [];
-  const typeBindings = typeOnlyBindings(program);
+  const bindings = localBindings(program);
+  const exports2 = /* @__PURE__ */ new Map();
   let ambiguous = false;
-  function collectRuntimeExport(statement) {
-    if (statement.type === import_utils47.AST_NODE_TYPES.ExportAllDeclaration) {
-      if (statement.exportKind !== "type") ambiguous = true;
-      return;
-    }
-    if (statement.type === import_utils47.AST_NODE_TYPES.ExportDefaultDeclaration) {
-      collectDefaultExport(statement);
-      return;
-    }
-    if (statement.type !== import_utils47.AST_NODE_TYPES.ExportNamedDeclaration || statement.exportKind === "type") return;
+  function add(key, name, node, emission) {
+    if (emission === "unknown") ambiguous = true;
+    if (emission === "runtime") exports2.set(key, { key, name, node });
+  }
+  function collectDefault(statement) {
+    const declaration = statement.declaration;
+    if (declaration.type === import_utils47.AST_NODE_TYPES.Identifier) {
+      add("default", declaration.name, statement, bindings.get(declaration.name) ?? "unknown");
+    } else if ("id" in declaration && declaration.id?.type === import_utils47.AST_NODE_TYPES.Identifier) {
+      add("default", declaration.id.name, declaration, declarationEmission(declaration));
+    } else ambiguous = true;
+  }
+  function collectNamed(statement) {
+    if (statement.exportKind === "type") return;
     if (statement.source !== null) {
       if (statement.specifiers.some((specifier) => specifier.exportKind !== "type")) ambiguous = true;
       return;
     }
-    if (statement.declaration !== null) {
-      const declaration = statement.declaration;
+    const declaration = statement.declaration;
+    if (declaration !== null) {
       if (declaration.type === import_utils47.AST_NODE_TYPES.VariableDeclaration && declaration.declarations.some((item) => item.id.type !== import_utils47.AST_NODE_TYPES.Identifier)) ambiguous = true;
-      exports2.push(...declaredNames(declaration).map((name) => ({ key: name, name, node: declaration })));
+      const names = declarationNames(declaration);
+      if (names.length === 0 && declarationEmission(declaration) !== "erased") ambiguous = true;
+      for (const name of names) add(name, name, declaration, bindings.get(name) ?? "unknown");
     }
-    collectExportSpecifiers(statement);
-  }
-  function collectExportSpecifiers(statement) {
     for (const specifier of statement.specifiers) {
-      if (specifier.exportKind === "type" || typeBindings.has(specifier.local.name)) continue;
-      const exported = specifier.exported.type === import_utils47.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+      if (specifier.exportKind === "type") continue;
+      const key = specifier.exported.type === import_utils47.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
       const local = specifier.local.name;
-      exports2.push({ key: exported, name: exported === "default" ? local : exported, node: specifier });
+      add(key, key === "default" ? local : key, specifier, bindings.get(local) ?? "unknown");
     }
   }
-  function collectDefaultExport(statement) {
-    const declaration = statement.declaration;
-    if (declaration.type === import_utils47.AST_NODE_TYPES.Identifier) {
-      if (!typeBindings.has(declaration.name)) {
-        exports2.push({ key: "default", name: declaration.name, node: statement });
-      }
-    } else if ((declaration.type === import_utils47.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.ClassDeclaration) && declaration.id !== null && declaration.declare !== true) exports2.push({ key: "default", name: declaration.id.name, node: declaration });
-    else if (declaration.type !== import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration && declaration.type !== import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration) ambiguous = true;
-  }
   for (const statement of program.body) {
-    collectRuntimeExport(statement);
+    if (statement.type === import_utils47.AST_NODE_TYPES.ExportAllDeclaration && statement.exportKind !== "type") ambiguous = true;
+    if (statement.type === import_utils47.AST_NODE_TYPES.TSExportAssignment) ambiguous = true;
+    if (statement.type === import_utils47.AST_NODE_TYPES.ExportDefaultDeclaration) collectDefault(statement);
+    if (statement.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration) collectNamed(statement);
   }
-  const unique = new Map(exports2.map((entry) => [entry.key, entry]));
-  return { exports: [...unique.values()], ambiguous };
+  return { exports: [...exports2.values()], ambiguous };
 }
-function typeOnlyBindings(program) {
-  const names = /* @__PURE__ */ new Set();
-  const runtimeNames = /* @__PURE__ */ new Set();
-  function collectTypeBinding(statement) {
-    const declaration = statement.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration || declaration?.type === import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      names.add(declaration.id.name);
-      return;
-    }
-    if (declaration?.type === import_utils47.AST_NODE_TYPES.TSEnumDeclaration && declaration.const) {
-      names.add(declaration.id.name);
-      return;
-    }
-    if (statement.type === import_utils47.AST_NODE_TYPES.ImportDeclaration) {
-      collectImportBindings(statement);
-      return;
-    }
-    if (declaration?.type === import_utils47.AST_NODE_TYPES.TSDeclareFunction && declaration.id !== null) {
-      names.add(declaration.id.name);
-      return;
-    }
-    if (declaration !== null && declaration.declare === true) {
-      collectDeclaredNames(declaration);
-      return;
-    }
-    if (declaration !== null && "type" in declaration) {
-      for (const name of declaredNames(declaration)) {
-        runtimeNames.add(name);
-      }
-    }
+function localBindings(program) {
+  const bindings = /* @__PURE__ */ new Map();
+  function register(name, emission) {
+    const previous = bindings.get(name);
+    if (previous === "runtime" || emission === "runtime") bindings.set(name, "runtime");
+    else if (previous === "unknown" || emission === "unknown") bindings.set(name, "unknown");
+    else bindings.set(name, "erased");
   }
-  function collectImportBindings(statement) {
-    for (const specifier of statement.specifiers) {
-      if (statement.importKind === "type" || specifier.type === import_utils47.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type") {
-        names.add(specifier.local.name);
-      } else {
-        runtimeNames.add(specifier.local.name);
+  for (const statement of program.body) {
+    if (statement.type === import_utils47.AST_NODE_TYPES.ImportDeclaration) {
+      for (const specifier of statement.specifiers) {
+        const typeOnly = statement.importKind === "type" || specifier.type === import_utils47.AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type";
+        register(specifier.local.name, typeOnly ? "erased" : "unknown");
       }
+      continue;
     }
+    const declaration = statement.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils47.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+    if (declaration === null) continue;
+    for (const name of declarationNames(declaration)) register(name, declarationEmission(declaration));
   }
-  function collectDeclaredNames(declaration) {
-    if ((declaration.type === import_utils47.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.TSEnumDeclaration || declaration.type === import_utils47.AST_NODE_TYPES.TSModuleDeclaration) && declaration.id !== null && declaration.id.type === import_utils47.AST_NODE_TYPES.Identifier) names.add(declaration.id.name);
-    if (declaration.type === import_utils47.AST_NODE_TYPES.VariableDeclaration) {
-      for (const item of declaration.declarations) {
-        if (item.id.type === import_utils47.AST_NODE_TYPES.Identifier) names.add(item.id.name);
-      }
-    }
+  return bindings;
+}
+function declarationNames(declaration) {
+  if ("id" in declaration && declaration.id !== null) {
+    let id = declaration.id;
+    while (id.type === import_utils47.AST_NODE_TYPES.TSQualifiedName) id = id.left;
+    if (id.type === import_utils47.AST_NODE_TYPES.Identifier) return [id.name];
   }
-  for (const statement of program.body) {
-    collectTypeBinding(statement);
+  if (declaration.type !== import_utils47.AST_NODE_TYPES.VariableDeclaration) return [];
+  return declaration.declarations.flatMap((item) => item.id.type === import_utils47.AST_NODE_TYPES.Identifier ? [item.id.name] : []);
+}
+function declarationEmission(declaration) {
+  if ("declare" in declaration && declaration.declare === true) return "erased";
+  switch (declaration.type) {
+    case import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils47.AST_NODE_TYPES.TSDeclareFunction:
+      return "erased";
+    case import_utils47.AST_NODE_TYPES.ClassDeclaration:
+    case import_utils47.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils47.AST_NODE_TYPES.VariableDeclaration:
+      return "runtime";
+    case import_utils47.AST_NODE_TYPES.TSEnumDeclaration:
+      return declaration.const ? "unknown" : "runtime";
+    case import_utils47.AST_NODE_TYPES.TSModuleDeclaration:
+      return namespaceEmission(declaration);
+    default:
+      return "unknown";
   }
-  return new Set([...names].filter((name) => !runtimeNames.has(name)));
 }
-function isGlobalIdentifier2(context, node) {
-  const variable = import_utils47.ASTUtils.findVariable(context.sourceCode.getScope(node), node.name);
-  return variable === null || variable.defs.length === 0;
+function namespaceEmission(declaration) {
+  const { body: body2 } = declaration;
+  if (body2 === void 0) return "unknown";
+  if (body2.body.length === 0) return "unknown";
+  let ambiguous = false;
+  for (const statement of body2.body) {
+    if (statement.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration && statement.exportKind === "type") continue;
+    const inner = statement.type === import_utils47.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    const emission = inner === null ? "unknown" : declarationEmission(inner);
+    if (emission === "runtime") return "runtime";
+    if (emission === "unknown") ambiguous = true;
+  }
+  return ambiguous ? "unknown" : "erased";
 }
-function isConventionalFrameworkUtility(filename, exported) {
-  const normalized = filename.replaceAll("\\", "/");
-  return exported === "cn" && /(?:^|\/)lib\/utils\.[cm]?[jt]sx?$/u.test(normalized);
+function isCommonJsExportReference(node, sourceCode) {
+  function isGlobal(node2) {
+    const variable = import_utils47.ASTUtils.findVariable(sourceCode.getScope(node2), node2.name);
+    return variable === null || variable.defs.length === 0;
+  }
+  if (node.type === import_utils47.AST_NODE_TYPES.MemberExpression) {
+    return node.object.type === import_utils47.AST_NODE_TYPES.Identifier && isGlobal(node.object) && (node.object.name === "exports" || node.object.name === "module" && memberPropertyName(node) === "exports");
+  }
+  const first = node.arguments[0];
+  return first?.type === import_utils47.AST_NODE_TYPES.Identifier && first.name === "exports" && isGlobal(first) && node.callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils47.AST_NODE_TYPES.Identifier && node.callee.object.name === "Object" && isGlobal(node.callee.object) && CJS_OBJECT_EXPORT_METHODS.has(memberPropertyName(node.callee) ?? "");
 }
 function memberPropertyName(node) {
   if (!node.computed && node.property.type === import_utils47.AST_NODE_TYPES.Identifier) return node.property.name;
   return node.computed && node.property.type === import_utils47.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
 }
-var no_generic_single_export_module_default = createRule({
-  name: "no-generic-single-export-module",
-  documentation: NO_GENERIC_SINGLE_EXPORT_MODULE_DOCUMENTATION,
-  meta: {
-    type: "suggestion",
-    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}}`; choose a responsibility-bearing module name or colocate the export with its domain."
-    }
+
+// src/rules/no-generic-single-export-module.ts
+var NO_GENERIC_SINGLE_EXPORT_MODULE_DOCUMENTATION = {
+  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: "Choose a responsibility-bearing module name or colocate the export with its domain.",
+  category: "maintainability",
+  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/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 }
+  ]
+};
+function fileParts(filename) {
+  const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
+  const extension = base.match(/(\.[cm]?[jt]sx?)$/u)?.[1] ?? ".ts";
+  const [stem4 = "", ...suffixes] = base.slice(0, -extension.length).split(".");
+  return { stem: stem4, suffixes: suffixes.map((suffix) => suffix.toLowerCase()) };
+}
+function isConventionalFrameworkUtility(filename, exported) {
+  const normalized = filename.replaceAll("\\", "/");
+  return exported === "cn" && /(?:^|\/)lib\/utils\.[cm]?[jt]sx?$/u.test(normalized);
+}
+var no_generic_single_export_module_default = createRule({
+  name: "no-generic-single-export-module",
+  documentation: NO_GENERIC_SINGLE_EXPORT_MODULE_DOCUMENTATION,
+  meta: {
+    type: "suggestion",
+    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}}`; choose a responsibility-bearing module name or colocate the export with its domain."
+    }
   },
   defaultOptions: [],
   create(context) {
     const file = fileParts(context.filename);
     const { stem: stem4 } = file;
-    if (!GENERIC_STEMS.has(stem4) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    if (!GENERIC_MODULE_STEMS.has(stem4) || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     let hasCommonJsExport = false;
     return {
-      CallExpression(node) {
-        const first = node.arguments[0];
-        if (first?.type === import_utils47.AST_NODE_TYPES.Identifier && first.name === "exports" && isGlobalIdentifier2(context, first) && node.callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils47.AST_NODE_TYPES.Identifier && node.callee.object.name === "Object" && isGlobalIdentifier2(context, node.callee.object) && memberPropertyName(node.callee) !== null && CJS_OBJECT_EXPORT_METHODS.has(memberPropertyName(node.callee))) hasCommonJsExport = true;
-      },
-      MemberExpression(node) {
-        if (node.object.type === import_utils47.AST_NODE_TYPES.Identifier && node.object.name === "exports" && isGlobalIdentifier2(context, node.object)) hasCommonJsExport = true;
-        if (node.object.type === import_utils47.AST_NODE_TYPES.Identifier && node.object.name === "module" && isGlobalIdentifier2(context, node.object) && memberPropertyName(node) === "exports") hasCommonJsExport = true;
+      "CallExpression, MemberExpression"(node) {
+        if (isCommonJsExportReference(node, context.sourceCode)) hasCommonJsExport = true;
       },
       "Program:exit"(program) {
         if (hasCommonJsExport) return;
@@ -8052,6 +8049,10 @@ var no_positional_tuple_return_default = createRule({
         data: { name, count: String(tuple.elements.length) }
       });
     };
+    const enterFunction = (node) => {
+      functionStack.push(node);
+      check(node);
+    };
     const check = (node) => {
       if (isQueryKeyFactory(node)) return;
       const annotation = node.returnType?.typeAnnotation;
@@ -8067,10 +8068,6 @@ var no_positional_tuple_return_default = createRule({
       }
       report2(annotation, name);
     };
-    const enterFunction = (node) => {
-      functionStack.push(node);
-      check(node);
-    };
     const exitFunction = () => {
       functionStack.pop();
     };
@@ -8517,32 +8514,16 @@ var no_raw_fetch_outside_clients_default = createRule({
       const definition = variable.defs[0];
       return definition?.type === "Variable" && definition.parent.kind === "const" && definition.node.init !== null && !variable.references.some((reference) => reference.isWrite() && reference.init !== true) && !(definition.node.init.type === import_utils51.AST_NODE_TYPES.ObjectExpression && variable.references.some((reference) => reference.identifier !== node && reference.init !== true)) ? definition.node.init : node;
     }
-    function propertyValue(node, name) {
-      if (node?.type !== import_utils51.AST_NODE_TYPES.ObjectExpression) return null;
-      if (node.properties.some((property) => property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed)) return null;
-      for (const property of [...node.properties].reverse()) {
-        if (property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed) continue;
-        const key = property.key;
-        const keyName = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
-        if (keyName !== name) continue;
-        return property.value.type === import_utils51.AST_NODE_TYPES.AssignmentPattern || property.value.type === import_utils51.AST_NODE_TYPES.ArrayPattern || property.value.type === import_utils51.AST_NODE_TYPES.ObjectPattern ? null : property.value;
-      }
-      return null;
-    }
-    function isInternalApiUrl(node) {
-      const resolved = resolveNode2(node ?? void 0);
-      if (resolved?.type === import_utils51.AST_NODE_TYPES.Literal) {
-        return typeof resolved.value === "string" && internalApiPrefixes.some(
-          (prefix) => resolved.value === prefix || resolved.value.startsWith(`${prefix}/`)
-        );
+    function serverActionOwns(node) {
+      if (node.callee.type !== import_utils51.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
+        return false;
       }
-      if (resolved?.type === import_utils51.AST_NODE_TYPES.TemplateLiteral) {
-        const prefix = resolved.quasis[0]?.value.cooked;
-        return typeof prefix === "string" && internalApiPrefixes.some(
-          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
-        );
+      const url = node.arguments[0];
+      const init = node.arguments[1];
+      if (url === void 0 || url.type === import_utils51.AST_NODE_TYPES.SpreadElement || init === void 0 || init.type === import_utils51.AST_NODE_TYPES.SpreadElement || !isInternalApiUrl(url)) {
+        return false;
       }
-      return resolved?.type === import_utils51.AST_NODE_TYPES.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
+      return isMutationMethod2(propertyValue(resolveNode2(init), "method"));
     }
     function isMutationMethod2(node) {
       const resolved = resolveNode2(node ?? void 0);
@@ -8559,16 +8540,32 @@ var no_raw_fetch_outside_clients_default = createRule({
       }
       return resolved?.type === import_utils51.AST_NODE_TYPES.LogicalExpression && resolved.operator === "||" && (isMutationMethod2(resolved.left) || isMutationMethod2(resolved.right));
     }
-    function serverActionOwns(node) {
-      if (node.callee.type !== import_utils51.AST_NODE_TYPES.Identifier || !hasUseClientDirective || hasUseServerDirective || importsServerOnly || SERVER_ACTION_SKIP_FILE_RE.test(filename) || nonReactFramework) {
-        return false;
+    function isInternalApiUrl(node) {
+      const resolved = resolveNode2(node ?? void 0);
+      if (resolved?.type === import_utils51.AST_NODE_TYPES.Literal) {
+        return typeof resolved.value === "string" && internalApiPrefixes.some(
+          (prefix) => resolved.value === prefix || resolved.value.startsWith(`${prefix}/`)
+        );
       }
-      const url = node.arguments[0];
-      const init = node.arguments[1];
-      if (url === void 0 || url.type === import_utils51.AST_NODE_TYPES.SpreadElement || init === void 0 || init.type === import_utils51.AST_NODE_TYPES.SpreadElement || !isInternalApiUrl(url)) {
-        return false;
+      if (resolved?.type === import_utils51.AST_NODE_TYPES.TemplateLiteral) {
+        const prefix = resolved.quasis[0]?.value.cooked;
+        return typeof prefix === "string" && internalApiPrefixes.some(
+          (apiPrefix) => prefix === apiPrefix || prefix.startsWith(`${apiPrefix}/`)
+        );
       }
-      return isMutationMethod2(propertyValue(resolveNode2(init), "method"));
+      return resolved?.type === import_utils51.AST_NODE_TYPES.BinaryExpression && resolved.operator === "+" && isInternalApiUrl(resolved.left);
+    }
+    function propertyValue(node, name) {
+      if (node?.type !== import_utils51.AST_NODE_TYPES.ObjectExpression) return null;
+      if (node.properties.some((property) => property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed)) return null;
+      for (const property of [...node.properties].reverse()) {
+        if (property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed) continue;
+        const key = property.key;
+        const keyName = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        if (keyName !== name) continue;
+        return property.value.type === import_utils51.AST_NODE_TYPES.AssignmentPattern || property.value.type === import_utils51.AST_NODE_TYPES.ArrayPattern || property.value.type === import_utils51.AST_NODE_TYPES.ObjectPattern ? null : property.value;
+      }
+      return null;
     }
     if (allowed.some((re) => re.test(filename))) {
       return {};
@@ -9243,19 +9240,19 @@ var no_restated_jsdoc_default = createRule({
 function enclosingDeclarationNames(node) {
   let declaration = null;
   while (node != null && node.type !== import_utils57.AST_NODE_TYPES.Program) {
-    declaration = declarationNames(node);
+    declaration = declarationNames2(node);
     if (declaration !== null) break;
     node = node.parent ?? null;
   }
   return declaration;
 }
-function declarationNames(node) {
+function declarationNames2(node) {
   switch (node.type) {
     // `export function f()` — the JSDoc sits above the `export`, so the token
     // after it resolves to the wrapper, not to the thing being documented.
     case import_utils57.AST_NODE_TYPES.ExportNamedDeclaration:
     case import_utils57.AST_NODE_TYPES.ExportDefaultDeclaration:
-      return node.declaration == null ? null : declarationNames(node.declaration);
+      return node.declaration == null ? null : declarationNames2(node.declaration);
     case import_utils57.AST_NODE_TYPES.FunctionDeclaration:
     case import_utils57.AST_NODE_TYPES.TSDeclareFunction:
       return node.id === null ? null : { name: node.id.name, params: paramNames(node.params) };
@@ -9667,35 +9664,30 @@ var no_secret_in_log_default = createRule({
   create(context, [loggingOptions]) {
     const matcher = createLogMatcher(loggingOptions);
     const blobArmApplies = !isTestFile(context.filename);
-    function reportSecretArgument(arg) {
-      const name = valueName(arg);
-      if (name === null || !isSecretKeyword(name)) {
-        return false;
+    function inspectLoggedValue(value) {
+      if (value.type === "ObjectExpression") {
+        for (const property of literalProperties(value)) {
+          if (reportSecretProperty(property) || reportRawBlob(property, property.value)) continue;
+          inspectLoggedValue(property.value);
+        }
+        return;
       }
-      context.report({ node: arg, messageId: "noSecretInLog", data: { name } });
-      return true;
-    }
-    function reportSecretProperty(prop) {
-      const keyName = propertyKeyName2(prop);
-      const value = valueName(prop.value);
-      if (value !== null && hasRedactionMarker(value)) return false;
-      const name = value !== null && isSecretKeyword(value) ? value : keyName;
-      if (name === null || !isSecretKeyword(name) || !isRawSecretValue(prop)) {
-        return false;
+      if (value.type === "ArrayExpression") {
+        for (const element of value.elements) {
+          if (element !== null && element.type !== "SpreadElement") inspectLoggedValue(element);
+        }
+        return;
       }
-      context.report({ node: prop, messageId: "noSecretInLog", data: { name } });
-      return true;
-    }
-    function reportRawBlob(node, value) {
-      if (!blobArmApplies) {
-        return false;
+      if (value.type === "TemplateLiteral") {
+        for (const expression of value.expressions) inspectLoggedValue(expression);
+        return;
       }
-      const name = rawBlobValueName(value);
-      if (name !== null) {
-        context.report({ node, messageId: "noRawBodyInLog", data: { name } });
-        return true;
+      if (value.type === "BinaryExpression" && value.operator === "+") {
+        inspectLoggedValue(value.left);
+        inspectLoggedValue(value.right);
+        return;
       }
-      return false;
+      if (!reportSecretArgument(value)) reportRawBlob(value, value);
     }
     function literalProperties(value) {
       const effective = /* @__PURE__ */ new Map();
@@ -9720,30 +9712,35 @@ var no_secret_in_log_default = createRule({
       }
       return [...effective.values()];
     }
-    function inspectLoggedValue(value) {
-      if (value.type === "ObjectExpression") {
-        for (const property of literalProperties(value)) {
-          if (reportSecretProperty(property) || reportRawBlob(property, property.value)) continue;
-          inspectLoggedValue(property.value);
-        }
-        return;
+    function reportRawBlob(node, value) {
+      if (!blobArmApplies) {
+        return false;
       }
-      if (value.type === "ArrayExpression") {
-        for (const element of value.elements) {
-          if (element !== null && element.type !== "SpreadElement") inspectLoggedValue(element);
-        }
-        return;
+      const name = rawBlobValueName(value);
+      if (name !== null) {
+        context.report({ node, messageId: "noRawBodyInLog", data: { name } });
+        return true;
       }
-      if (value.type === "TemplateLiteral") {
-        for (const expression of value.expressions) inspectLoggedValue(expression);
-        return;
+      return false;
+    }
+    function reportSecretProperty(prop) {
+      const keyName = propertyKeyName2(prop);
+      const value = valueName(prop.value);
+      if (value !== null && hasRedactionMarker(value)) return false;
+      const name = value !== null && isSecretKeyword(value) ? value : keyName;
+      if (name === null || !isSecretKeyword(name) || !isRawSecretValue(prop)) {
+        return false;
       }
-      if (value.type === "BinaryExpression" && value.operator === "+") {
-        inspectLoggedValue(value.left);
-        inspectLoggedValue(value.right);
-        return;
+      context.report({ node: prop, messageId: "noSecretInLog", data: { name } });
+      return true;
+    }
+    function reportSecretArgument(arg) {
+      const name = valueName(arg);
+      if (name === null || !isSecretKeyword(name)) {
+        return false;
       }
-      if (!reportSecretArgument(value)) reportRawBlob(value, value);
+      context.report({ node: arg, messageId: "noSecretInLog", data: { name } });
+      return true;
     }
     return {
       CallExpression(node) {
@@ -10041,9 +10038,6 @@ function bindsName(param, name) {
 }
 function subtreeReadsName(node, name) {
   let found = false;
-  const shadowsName = (fn) => isFunctionNode(fn) && fn.params.some(
-    (param) => bindsName(param, name)
-  );
   const recurse = (current) => {
     if (found) {
       return;
@@ -10060,6 +10054,9 @@ function subtreeReadsName(node, name) {
       return found;
     }, (key) => !isNonReadingProperty(current, key));
   };
+  const shadowsName = (fn) => isFunctionNode(fn) && fn.params.some(
+    (param) => bindsName(param, name)
+  );
   recurse(node);
   return found;
 }
@@ -11921,14 +11918,6 @@ var no_declaration_comment_wall_default = createRule({
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
     }
-    function isGroupLabel(comment, member, headsRun) {
-      if (comment.loc.end.line >= member.node.loc.start.line) return false;
-      const body2 = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body2)) return false;
-      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
-      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
-      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
-    }
     function check(node, members) {
       const judged = members.map(named).filter((member) => member !== void 0);
       if (judged.length === 0) return;
@@ -11967,6 +11956,14 @@ var no_declaration_comment_wall_default = createRule({
         data: { restated: String(restated), commented: String(commented) }
       });
     }
+    function isGroupLabel(comment, member, headsRun) {
+      if (comment.loc.end.line >= member.node.loc.start.line) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
+      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
+      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
+    }
     return {
       ClassBody: (node) => {
         check(node, node.body);
@@ -12202,14 +12199,6 @@ var no_type_member_comment_wall_default = createRule({
       const trail = startingOn.get(member.loc.end.line);
       return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
     }
-    function isGroupLabel(comment, member, headsRun) {
-      if (comment.loc.end.line >= member.loc.start.line) return false;
-      const body2 = commentBody(comment);
-      if (!BARE_LABEL_RE.test(body2)) return false;
-      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
-      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
-      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
-    }
     function check(node) {
       const members = node.type === import_utils71.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
       const named2 = members.filter(isNamedMember);
@@ -12245,6 +12234,14 @@ var no_type_member_comment_wall_default = createRule({
         data: { restated: String(restated), commented: String(commented) }
       });
     }
+    function isGroupLabel(comment, member, headsRun) {
+      if (comment.loc.end.line >= member.loc.start.line) return false;
+      const body2 = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body2)) return false;
+      if (labelStems(body2) === labelStems(sourceCode.getText(member.key))) return false;
+      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
+      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
+    }
     return {
       TSInterfaceBody: check,
       TSTypeLiteral: check
@@ -12560,6 +12557,11 @@ var no_unsafe_mock_casting_default = createRule({
       const binding = resolve2(identifier);
       if (binding !== null) destination.add(binding);
     }
+    function checkAssertion(node) {
+      if (isMockTypeReference(node.typeAnnotation)) {
+        context.report({ node, messageId: "unsafeMockCast" });
+      }
+    }
     function isMockTypeReference(node) {
       if (node.type !== import_utils73.AST_NODE_TYPES.TSTypeReference) return false;
       const typeName = node.typeName;
@@ -12573,11 +12575,6 @@ var no_unsafe_mock_casting_default = createRule({
       }
       return false;
     }
-    function checkAssertion(node) {
-      if (isMockTypeReference(node.typeAnnotation)) {
-        context.report({ node, messageId: "unsafeMockCast" });
-      }
-    }
     return {
       ImportDeclaration(node) {
         if (!MOCK_MODULES.has(node.source.value)) return;
@@ -17888,7 +17885,7 @@ var staticallyImportsExternalRenderer = (program) => program.body.some((statemen
 var semanticForegroundRoles = (filename) => {
   const packageRoot = nearestPackageRoot((0, import_path.dirname)(filename));
   if (packageRoot === null) return /* @__PURE__ */ new Set();
-  const candidates = CSS_DETECTION_FILES.map((relative2) => (0, import_path.join)(packageRoot, relative2));
+  const candidates = CSS_DETECTION_FILES.map((relative3) => (0, import_path.join)(packageRoot, relative3));
   const fingerprint = candidates.map(fileFingerprint2).join("|");
   const cached = SEMANTIC_DECLARATIONS_CACHE.get(packageRoot);
   if (cached?.fingerprint === fingerprint) return cached.value;
@@ -17971,37 +17968,6 @@ var prefer_semantic_colors_default = createRule({
       const key = `${node.range[0]}:${node.range[1]}:${messageId}:${JSON.stringify(data)}`;
       pendingReports.set(key, { node, messageId, data });
     };
-    const reportClasses = (value, node) => {
-      const tokens = classTokens(value);
-      for (const token of tokens) {
-        const base = tailwindBase(token);
-        if (RAW_PALETTE_RE.test(base)) {
-          report2(node, "rawPalette", { class: token });
-        } else if (ARBITRARY_COLOR_RE.test(base) && !CSS_VAR_REFERENCE_RE.test(base)) {
-          report2(node, "arbitraryColor", { class: token });
-        }
-      }
-      if (!checkOpaqueForegroundPairs || isInsideSvg(node)) return;
-      for (const token of tokens) {
-        const prefix = tailwindVariantPrefix(token);
-        if (prefix.split(":").includes("print")) continue;
-        const base = tailwindBase(token);
-        if (!OPAQUE_FOREGROUND_RE.test(base)) continue;
-        const semanticBackground = tokens.find((candidate2) => {
-          if (tailwindVariantPrefix(candidate2) !== prefix) return false;
-          const match = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(candidate2));
-          return match?.[1] !== void 0 && foregroundRoles.has(match[1]);
-        });
-        if (semanticBackground === void 0) continue;
-        const role = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(semanticBackground))?.[1];
-        if (role === void 0) continue;
-        report2(node, "opaqueForegroundPair", {
-          background: semanticBackground,
-          class: token,
-          replacement: `${prefix}text-${role}-foreground`
-        });
-      }
-    };
     const checkClassNode = (node, objectKeys = false) => {
       if (node === null) return;
       switch (node.type) {
@@ -18030,6 +17996,37 @@ var prefer_semantic_colors_default = createRule({
           break;
       }
     };
+    const reportClasses = (value, node) => {
+      const tokens = classTokens(value);
+      for (const token of tokens) {
+        const base = tailwindBase(token);
+        if (RAW_PALETTE_RE.test(base)) {
+          report2(node, "rawPalette", { class: token });
+        } else if (ARBITRARY_COLOR_RE.test(base) && !CSS_VAR_REFERENCE_RE.test(base)) {
+          report2(node, "arbitraryColor", { class: token });
+        }
+      }
+      if (!checkOpaqueForegroundPairs || isInsideSvg(node)) return;
+      for (const token of tokens) {
+        const prefix = tailwindVariantPrefix(token);
+        if (prefix.split(":").includes("print")) continue;
+        const base = tailwindBase(token);
+        if (!OPAQUE_FOREGROUND_RE.test(base)) continue;
+        const semanticBackground = tokens.find((candidate2) => {
+          if (tailwindVariantPrefix(candidate2) !== prefix) return false;
+          const match = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(candidate2));
+          return match?.[1] !== void 0 && foregroundRoles.has(match[1]);
+        });
+        if (semanticBackground === void 0) continue;
+        const role = SEMANTIC_BACKGROUND_RE.exec(tailwindBase(semanticBackground))?.[1];
+        if (role === void 0) continue;
+        report2(node, "opaqueForegroundPair", {
+          background: semanticBackground,
+          class: token,
+          replacement: `${prefix}text-${role}-foreground`
+        });
+      }
+    };
     function checkClassProperties(node, objectKeys) {
       for (const property of node.properties) {
         if (property.type !== import_utils103.AST_NODE_TYPES.Property) continue;
@@ -18463,80 +18460,6 @@ var prefer_whole_object_assertion_default = createRule({
       return {};
     }
     const { sourceCode } = context;
-    function parseAssertion(statement) {
-      if (statement.type !== import_utils105.AST_NODE_TYPES.ExpressionStatement) {
-        return null;
-      }
-      const call = statement.expression;
-      if (call.type !== import_utils105.AST_NODE_TYPES.CallExpression) {
-        return null;
-      }
-      const callee = call.callee;
-      if (callee.type !== import_utils105.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils105.AST_NODE_TYPES.Identifier) {
-        return null;
-      }
-      const matcher = callee.property.name;
-      const expectCall = callee.object;
-      if (expectCall.type !== import_utils105.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils105.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
-        return null;
-      }
-      const actual = expectCall.arguments[0];
-      if (!isTestExpect(expectCall.callee)) return null;
-      if (actual === void 0 || actual.type !== import_utils105.AST_NODE_TYPES.MemberExpression || actual.optional) {
-        return null;
-      }
-      if (!isPureReceiver(actual.object)) {
-        return null;
-      }
-      let key;
-      let receiver;
-      if (actual.computed) {
-        const index = literalIndex(actual.property);
-        if (index === null) {
-          return null;
-        }
-        key = { kind: "index", index };
-        receiver = actual.object;
-      } else {
-        const access = propertyAccess(actual);
-        if (access === null) return null;
-        key = { kind: "property", path: access.path };
-        receiver = access.receiver;
-      }
-      return assertionExpectation(statement, call, receiver, key, matcher);
-    }
-    function assertionExpectation(statement, call, receiver, key, matcher) {
-      const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
-      if (synthetic !== void 0 && call.arguments.length === 0) {
-        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
-      }
-      if (!MERGEABLE_MATCHERS.has(matcher)) {
-        return null;
-      }
-      const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils105.AST_NODE_TYPES.SpreadElement) {
-        return null;
-      }
-      const literal = literalText(expected, (node) => sourceCode.getText(node));
-      return {
-        statement,
-        receiver,
-        key,
-        matcher,
-        expectedText: literal ?? sourceCode.getText(expected),
-        expectedIsLiteral: literal !== null
-      };
-    }
-    function isTestExpect(callee) {
-      const variable = import_utils105.ASTUtils.findVariable(sourceCode.getScope(callee), callee.name);
-      if (variable !== null && variable.defs.some((definition) => {
-        if (definition.node.type !== import_utils105.AST_NODE_TYPES.ImportSpecifier) return true;
-        const declaration = definition.node.parent;
-        const imported = definition.node.imported;
-        return declaration.type !== import_utils105.AST_NODE_TYPES.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === import_utils105.AST_NODE_TYPES.Identifier ? imported.name : imported.value) !== "expect";
-      })) return false;
-      return true;
-    }
     function reportPropertyRun(run) {
       const tree = /* @__PURE__ */ new Map();
       const paths = [];
@@ -18646,6 +18569,80 @@ var prefer_whole_object_assertion_default = createRule({
       }
       flush();
     }
+    function parseAssertion(statement) {
+      if (statement.type !== import_utils105.AST_NODE_TYPES.ExpressionStatement) {
+        return null;
+      }
+      const call = statement.expression;
+      if (call.type !== import_utils105.AST_NODE_TYPES.CallExpression) {
+        return null;
+      }
+      const callee = call.callee;
+      if (callee.type !== import_utils105.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils105.AST_NODE_TYPES.Identifier) {
+        return null;
+      }
+      const matcher = callee.property.name;
+      const expectCall = callee.object;
+      if (expectCall.type !== import_utils105.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils105.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+        return null;
+      }
+      const actual = expectCall.arguments[0];
+      if (!isTestExpect(expectCall.callee)) return null;
+      if (actual === void 0 || actual.type !== import_utils105.AST_NODE_TYPES.MemberExpression || actual.optional) {
+        return null;
+      }
+      if (!isPureReceiver(actual.object)) {
+        return null;
+      }
+      let key;
+      let receiver;
+      if (actual.computed) {
+        const index = literalIndex(actual.property);
+        if (index === null) {
+          return null;
+        }
+        key = { kind: "index", index };
+        receiver = actual.object;
+      } else {
+        const access = propertyAccess(actual);
+        if (access === null) return null;
+        key = { kind: "property", path: access.path };
+        receiver = access.receiver;
+      }
+      return assertionExpectation(statement, call, receiver, key, matcher);
+    }
+    function isTestExpect(callee) {
+      const variable = import_utils105.ASTUtils.findVariable(sourceCode.getScope(callee), callee.name);
+      if (variable !== null && variable.defs.some((definition) => {
+        if (definition.node.type !== import_utils105.AST_NODE_TYPES.ImportSpecifier) return true;
+        const declaration = definition.node.parent;
+        const imported = definition.node.imported;
+        return declaration.type !== import_utils105.AST_NODE_TYPES.ImportDeclaration || !["vitest", "@jest/globals", "@playwright/test", "bun:test"].includes(String(declaration.source.value)) || (imported.type === import_utils105.AST_NODE_TYPES.Identifier ? imported.name : imported.value) !== "expect";
+      })) return false;
+      return true;
+    }
+    function assertionExpectation(statement, call, receiver, key, matcher) {
+      const synthetic = SYNTHETIC_LITERAL_MATCHERS.get(matcher);
+      if (synthetic !== void 0 && call.arguments.length === 0) {
+        return { statement, receiver, key, matcher, expectedText: synthetic, expectedIsLiteral: true };
+      }
+      if (!MERGEABLE_MATCHERS.has(matcher)) {
+        return null;
+      }
+      const expected = call.arguments[0];
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils105.AST_NODE_TYPES.SpreadElement) {
+        return null;
+      }
+      const literal = literalText(expected, (node) => sourceCode.getText(node));
+      return {
+        statement,
+        receiver,
+        key,
+        matcher,
+        expectedText: literal ?? sourceCode.getText(expected),
+        expectedIsLiteral: literal !== null
+      };
+    }
     return {
       BlockStatement: (node) => {
         checkBody(node.body);
@@ -21385,6 +21382,11 @@ var require_use_form_default_values_default = createRule({
       const value = unwrapExpression6(node);
       return value.type === import_utils115.AST_NODE_TYPES.UnaryExpression && value.operator === "void" || value.type === import_utils115.AST_NODE_TYPES.Identifier && value.name === "undefined" && (bindingOf(value)?.defs.length ?? 0) === 0;
     };
+    const uninitializedUseFormCall = (node) => {
+      if (node.type !== import_utils115.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils115.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useForm") return false;
+      const options = node.arguments[0];
+      return options?.type !== import_utils115.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
+    };
     const initializationState = (node) => {
       if (node === void 0) return "uninitialized";
       if (node.type !== import_utils115.AST_NODE_TYPES.ObjectExpression) return "unknown";
@@ -21397,11 +21399,6 @@ var require_use_form_default_values_default = createRule({
       }
       return [...initialization.values()].some(Boolean) ? "initialized" : "uninitialized";
     };
-    const uninitializedUseFormCall = (node) => {
-      if (node.type !== import_utils115.AST_NODE_TYPES.CallExpression || node.callee.type !== import_utils115.AST_NODE_TYPES.Identifier || importedKind(node.callee) !== "useForm") return false;
-      const options = node.arguments[0];
-      return options?.type !== import_utils115.AST_NODE_TYPES.SpreadElement && initializationState(options) === "uninitialized";
-    };
     const isUninitializedForm = (node) => {
       if (node.type !== import_utils115.AST_NODE_TYPES.Identifier) return false;
       const variable = bindingOf(node);
@@ -21630,28 +21627,13 @@ var require_zod_form_validation_default = createRule({
       context.sourceCode.getScope(identifier),
       identifier.name
     );
-    const isProvablyNonZodLocal = (identifier) => {
-      const binding = resolvedBinding(identifier);
-      if (binding === null || zodBindings.has(binding) || binding.defs.length !== 1) {
-        return false;
-      }
-      const definition = binding.defs[0];
-      if (definition?.type !== "Variable" || definition.node.type !== import_utils117.AST_NODE_TYPES.VariableDeclarator) {
-        return false;
-      }
-      const init = definition.node.init;
-      return init?.type === import_utils117.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils117.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils117.AST_NODE_TYPES.Literal || init?.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils117.AST_NODE_TYPES.FunctionExpression;
-    };
-    const isZodParseCall = (node) => {
-      if (node.type !== import_utils117.AST_NODE_TYPES.CallExpression) return false;
+    const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
         return false;
       }
-      const root = zodReceiverRoot(callee.object);
-      if (root === null) return false;
-      const binding = resolvedBinding(root);
-      return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
+      return isFormSourceIdentifier(callee.object);
     };
     const isFormSourceIdentifier = (node) => {
       if (node.type !== import_utils117.AST_NODE_TYPES.Identifier) return false;
@@ -21670,14 +21652,6 @@ var require_zod_form_validation_default = createRule({
       }
       return conventionalName;
     };
-    const isFormDataGetCall = (node) => {
-      const callee = node.callee;
-      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !FORM_VALUE_METHODS.has(callee.property.name)) {
-        return false;
-      }
-      return isFormSourceIdentifier(callee.object);
-    };
     const zodParseAncestor = (node) => {
       let parent = node.parent;
       while (parent !== null && parent !== void 0) {
@@ -21695,6 +21669,29 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
+    const isZodParseCall = (node) => {
+      if (node.type !== import_utils117.AST_NODE_TYPES.CallExpression) return false;
+      const callee = node.callee;
+      if (callee.type !== import_utils117.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils117.AST_NODE_TYPES.Identifier || !ZOD_PARSE_METHODS.has(callee.property.name)) {
+        return false;
+      }
+      const root = zodReceiverRoot(callee.object);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding) || (root.name === "z" || ZOD_SCHEMA_NAME_RE.test(root.name)) && !isProvablyNonZodLocal(root);
+    };
+    const isProvablyNonZodLocal = (identifier) => {
+      const binding = resolvedBinding(identifier);
+      if (binding === null || zodBindings.has(binding) || binding.defs.length !== 1) {
+        return false;
+      }
+      const definition = binding.defs[0];
+      if (definition?.type !== "Variable" || definition.node.type !== import_utils117.AST_NODE_TYPES.VariableDeclarator) {
+        return false;
+      }
+      const init = definition.node.init;
+      return init?.type === import_utils117.AST_NODE_TYPES.ObjectExpression || init?.type === import_utils117.AST_NODE_TYPES.ArrayExpression || init?.type === import_utils117.AST_NODE_TYPES.Literal || init?.type === import_utils117.AST_NODE_TYPES.ArrowFunctionExpression || init?.type === import_utils117.AST_NODE_TYPES.FunctionExpression;
+    };
     const hasZodParseAncestor = (node) => zodParseAncestor(node) !== null;
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
@@ -21723,28 +21720,6 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
-    const zodParseMethod = (call) => {
-      const callee = call.callee;
-      return callee.type === import_utils117.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils117.AST_NODE_TYPES.Identifier ? callee.property.name : null;
-    };
-    const hasConditionalAncestorBeforeStatement = (node, statement) => {
-      let current = node.parent;
-      while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils117.AST_NODE_TYPES.LogicalExpression || current.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
-          return true;
-        }
-        current = current.parent;
-      }
-      return false;
-    };
-    const isAwaitedBeforeStatement = (node, statement) => {
-      let current = node.parent;
-      while (current !== void 0 && current !== statement) {
-        if (current.type === import_utils117.AST_NODE_TYPES.AwaitExpression) return true;
-        current = current.parent;
-      }
-      return false;
-    };
     const guaranteedValidationStatement = (declarator, reference) => {
       const parse2 = zodParseAncestor(reference);
       if (parse2 === null) return null;
@@ -21763,6 +21738,28 @@ var require_zod_form_validation_default = createRule({
       }
       return null;
     };
+    const isAwaitedBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === import_utils117.AST_NODE_TYPES.AwaitExpression) return true;
+        current = current.parent;
+      }
+      return false;
+    };
+    const hasConditionalAncestorBeforeStatement = (node, statement) => {
+      let current = node.parent;
+      while (current !== void 0 && current !== statement) {
+        if (current.type === import_utils117.AST_NODE_TYPES.LogicalExpression || current.type === import_utils117.AST_NODE_TYPES.ConditionalExpression) {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    };
+    const zodParseMethod = (call) => {
+      const callee = call.callee;
+      return callee.type === import_utils117.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils117.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+    };
     const isSafePrevalidationInspection = (identifier) => {
       const parent = identifier.parent;
       if (parent.type === import_utils117.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof") {
@@ -21943,9 +21940,9 @@ var STEPDOWN_DOCUMENTATION = {
   remediation: "Consider moving the private helper below its sole caller after reviewing initialization and reflection dependencies.",
   category: "maintainability",
   limitations: [
-    "Generated and test files, cycles, dynamic references, overload targets, and helpers with multiple callers are excluded.",
+    "Generated and test files, cycles, dynamic or escaped references, overload targets, and helpers with multiple callers are excluded; immutable local callable aliases are followed only when every use stays in the caller. Function bodies include nested sibling helpers.",
     "Class helpers must be private; their sole caller may be public, protected, or private.",
-    "Runtime class-field, static-block, computed-member, and decorator barriers are never crossed.",
+    "Runtime class-field, static-block, computed-member, and decorator barriers are never crossed; non-hoisted module helpers also cannot cross eager execution or unrelated initialization.",
     "This rule is report-only: reordering methods can change reflective property order, and moving module declarations can change initialization behavior or introduce temporal-dead-zone failures. Review module cycles and eager callers manually."
   ],
   examples: [
@@ -21957,7 +21954,7 @@ function isFunction(node) {
   return node.type === import_utils119.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils119.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils119.AST_NODE_TYPES.FunctionExpression;
 }
 function reportMisordered(context, candidates, scopeDefinitions, calls, pinned, canMove = () => true) {
-  const byName = new Map(scopeDefinitions.map((definition) => [definition.name, definition]));
+  const byName = new Map(scopeDefinitions.map((definition) => [definition.key, definition]));
   const cycles = cycleComponents(calls);
   const callers = /* @__PURE__ */ new Map();
   for (const [caller, callees] of calls) {
@@ -21969,16 +21966,16 @@ function reportMisordered(context, candidates, scopeDefinitions, calls, pinned,
     }
   }
   for (const helper of candidates) {
-    const helperCallers = [...callers.get(helper.name) ?? []];
-    if (pinned.has(helper.name) || helperCallers.length !== 1) continue;
+    const helperCallers = [...callers.get(helper.key) ?? []];
+    if (pinned.has(helper.key) || helperCallers.length !== 1) continue;
     const callerName2 = helperCallers[0];
-    if (callerName2 === void 0 || cycles.has(helper.name) && cycles.get(helper.name) === cycles.get(callerName2)) continue;
+    if (callerName2 === void 0 || cycles.has(helper.key) && cycles.get(helper.key) === cycles.get(callerName2)) continue;
     const caller = byName.get(callerName2);
     if (caller === void 0 || helper.node.range[0] >= caller.node.range[0] || !canMove(helper, caller)) continue;
     context.report({
       node: helper.node,
       messageId: "helperAboveOnlyCaller",
-      data: { helper: helper.name, caller: callerName2 }
+      data: { helper: helper.name, caller: caller.name }
     });
   }
 }
@@ -22049,8 +22046,46 @@ function cycleComponents(graph) {
   }
   return components;
 }
-function moduleScope(context, program) {
+function isErasedExpression(node) {
+  return node.type === import_utils119.AST_NODE_TYPES.TSAsExpression || node.type === import_utils119.AST_NODE_TYPES.TSTypeAssertion || node.type === import_utils119.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils119.AST_NODE_TYPES.TSNonNullExpression || node.type === import_utils119.AST_NODE_TYPES.TSInstantiationExpression;
+}
+function unwrapExpression7(node) {
+  let current = node;
+  while (isErasedExpression(current)) current = current.expression;
+  return current;
+}
+function wrappedExpression(node) {
+  let current = node;
+  while (current.parent !== void 0 && isErasedExpression(current.parent) && current.parent.expression === current) current = current.parent;
+  return current;
+}
+function enclosingFunction5(context, node) {
+  return [...context.sourceCode.getAncestors(node)].reverse().find(isFunction);
+}
+function localCallCount(context, node, owner) {
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [node];
+  let count = 0;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current === void 0 || enclosingFunction5(context, current) !== owner) return null;
+    const expression = wrappedExpression(current);
+    const parent = expression.parent;
+    if (parent?.type === import_utils119.AST_NODE_TYPES.CallExpression && parent.callee === expression) {
+      count += 1;
+      continue;
+    }
+    if (parent?.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator || parent.init !== expression || parent.id.type !== import_utils119.AST_NODE_TYPES.Identifier || parent.parent.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || parent.parent.kind !== "const") return null;
+    const variable = context.sourceCode.getDeclaredVariables(parent)[0];
+    if (variable === void 0 || seen.has(variable) || !stableVariable(variable)) return null;
+    seen.add(variable);
+    pending.push(...variable.references.filter((reference) => reference.isRead()).map((reference) => reference.identifier));
+  }
+  return count;
+}
+function declarationScope(context, program) {
   const declarations = moduleDefinitions(program);
+  if (declarations.length < 2) return;
   const counts = /* @__PURE__ */ new Map();
   for (const node of declarations) counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
   const overloadNames = new Set(
@@ -22059,11 +22094,31 @@ function moduleScope(context, program) {
       return node?.type === import_utils119.AST_NODE_TYPES.TSDeclareFunction && node.id !== null ? [node.id.name] : [];
     })
   );
-  const exported = exportedNames(program);
+  const exported = program.type === import_utils119.AST_NODE_TYPES.Program ? exportedNames(program) : /* @__PURE__ */ new Set();
   const scopeDefinitions = declarations.filter((node) => counts.get(node.name) === 1);
   const definitions = scopeDefinitions.filter(
     (definition) => !exported.has(definition.name) && !overloadNames.has(definition.name)
   );
+  const { calls, pinned } = moduleCallGraph(context, scopeDefinitions);
+  const statementIndexes = new Map(program.body.map((statement, index) => [statement, index]));
+  const runtimeBarrierPrefix = [0];
+  for (const statement of program.body) {
+    runtimeBarrierPrefix.push((runtimeBarrierPrefix.at(-1) ?? 0) + (isDeferredModuleStatement(statement) ? 0 : 1));
+  }
+  const canMove = (helper, caller) => {
+    if (helper.node.type === import_utils119.AST_NODE_TYPES.FunctionDeclaration) return true;
+    const helperIndex = statementIndex(helper);
+    const callerIndex = statementIndex(caller);
+    return helperIndex !== void 0 && callerIndex !== void 0 && runtimeBarrierPrefix[callerIndex + 1] === runtimeBarrierPrefix[helperIndex + 1];
+  };
+  const statementIndex = (definition) => {
+    let current = definition.node;
+    while (current.parent !== void 0 && current.parent !== program) current = current.parent;
+    return statementIndexes.get(current);
+  };
+  reportMisordered(context, definitions, scopeDefinitions, calls, pinned, canMove);
+}
+function moduleCallGraph(context, scopeDefinitions) {
   const byFunction = new Map(scopeDefinitions.map((definition) => [definition.functionNode, definition]));
   const calls = /* @__PURE__ */ new Map();
   const pinned = /* @__PURE__ */ new Set();
@@ -22071,26 +22126,33 @@ function moduleScope(context, program) {
     const variable = context.sourceCode.getDeclaredVariables(definition.bindingNode)[0];
     for (const reference of variable?.references ?? []) {
       if (reference.isWrite() && reference.init !== true) {
-        pinned.add(definition.name);
+        pinned.add(definition.key);
         continue;
       }
       if (!reference.isRead()) continue;
-      const identifier = reference.identifier;
-      const ancestors = context.sourceCode.getAncestors(identifier);
-      const nearestFunction2 = [...ancestors].reverse().find(isFunction);
-      const parent = identifier.parent;
-      const callerDefinition = nearestFunction2 === void 0 ? void 0 : byFunction.get(nearestFunction2);
-      if (callerDefinition === void 0 || parent.type !== import_utils119.AST_NODE_TYPES.CallExpression || parent.callee !== identifier) {
-        pinned.add(definition.name);
+      const callerDefinition = byFunction.get(enclosingFunction5(context, reference.identifier));
+      if (callerDefinition?.functionNode === void 0) {
+        pinned.add(definition.key);
         continue;
       }
-      const caller = callerDefinition.name;
-      const callees = calls.get(caller) ?? /* @__PURE__ */ new Set();
-      callees.add(definition.name);
-      calls.set(caller, callees);
+      const count = localCallCount(context, reference.identifier, callerDefinition.functionNode);
+      if (count === null) {
+        pinned.add(definition.key);
+      } else if (count > 0) {
+        const callees = calls.get(callerDefinition.key) ?? /* @__PURE__ */ new Set();
+        callees.add(definition.key);
+        calls.set(callerDefinition.key, callees);
+      }
     }
   }
-  reportMisordered(context, definitions, scopeDefinitions, calls, pinned);
+  return { calls, pinned };
+}
+function isDeferredModuleStatement(statement) {
+  const node = statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils119.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
+  if (node === null || node.type === import_utils119.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils119.AST_NODE_TYPES.TSDeclareFunction || node.type === import_utils119.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils119.AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === import_utils119.AST_NODE_TYPES.ImportDeclaration || node.type === import_utils119.AST_NODE_TYPES.ExportAllDeclaration || node.type === import_utils119.AST_NODE_TYPES.EmptyStatement) return true;
+  return node.type === import_utils119.AST_NODE_TYPES.VariableDeclaration && node.declarations.every(
+    (declaration) => declaration.id.type === import_utils119.AST_NODE_TYPES.Identifier && declaration.init !== null && isFunction(unwrapExpression7(declaration.init))
+  );
 }
 function exportedNames(program) {
   const names = /* @__PURE__ */ new Set();
@@ -22124,16 +22186,18 @@ function moduleDefinitions(program) {
   for (const statement of program.body) {
     const node = statement.type === import_utils119.AST_NODE_TYPES.ExportNamedDeclaration || statement.type === import_utils119.AST_NODE_TYPES.ExportDefaultDeclaration ? statement.declaration : statement;
     if (node?.type === import_utils119.AST_NODE_TYPES.FunctionDeclaration && node.id !== null && node.body !== null) {
-      definitions.push({ name: node.id.name, node, functionNode: node, bindingNode: node });
+      definitions.push({ key: node.id.name, name: node.id.name, node, functionNode: node, bindingNode: node });
       continue;
     }
-    if (node?.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const") continue;
+    if (node?.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || node.kind !== "const" || node.declarations.length !== 1) continue;
     for (const declarator of node.declarations) {
-      if (declarator.id.type === import_utils119.AST_NODE_TYPES.Identifier && declarator.init !== null && isFunction(declarator.init)) {
+      const initializer = declarator.init === null ? null : unwrapExpression7(declarator.init);
+      if (declarator.id.type === import_utils119.AST_NODE_TYPES.Identifier && initializer !== null && isFunction(initializer)) {
         definitions.push({
+          key: declarator.id.name,
           name: declarator.id.name,
           node: declarator,
-          functionNode: declarator.init,
+          functionNode: initializer,
           bindingNode: declarator
         });
       }
@@ -22143,15 +22207,50 @@ function moduleDefinitions(program) {
 }
 function methodName2(node) {
   if (node.key.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) return `#${node.key.name}`;
-  return !node.computed && node.key.type === import_utils119.AST_NODE_TYPES.Identifier ? node.key.name : null;
+  if (!node.computed && node.key.type === import_utils119.AST_NODE_TYPES.Identifier) return node.key.name;
+  return node.key.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.key.value === "string" ? node.key.value : null;
 }
-function referencedMethod(context, node, classVariables) {
-  const objectVariable = node.object.type === import_utils119.AST_NODE_TYPES.Identifier ? import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(node.object), node.object.name) : null;
-  const isClassReference = objectVariable !== null && classVariables.has(objectVariable);
-  if (node.object.type !== import_utils119.AST_NODE_TYPES.ThisExpression && !isClassReference) return null;
-  if (node.property.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
-  if (!node.computed && node.property.type === import_utils119.AST_NODE_TYPES.Identifier) return node.property.name;
-  return node.computed && node.property.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.property.value === "string" ? node.property.value : null;
+function methodKey(name, isStatic2) {
+  return `${isStatic2 ? "static" : "instance"}:${name}`;
+}
+function receiverDomain(context, object, receivers, thisIsStatic) {
+  const unwrapped = unwrapExpression7(object);
+  if (unwrapped.type === import_utils119.AST_NODE_TYPES.ThisExpression) return thisIsStatic;
+  return externalReceiverDomain(context, unwrapped, receivers);
+}
+function externalReceiverDomain(context, object, receivers) {
+  const origin = receiverOrigin(context, object, receivers);
+  if (origin === null || typeof origin === "boolean") return origin;
+  if (origin.type === import_utils119.AST_NODE_TYPES.NewExpression) {
+    return receiverOrigin(context, origin.callee, receivers) === true ? false : null;
+  }
+  if (origin.type === import_utils119.AST_NODE_TYPES.ObjectExpression || origin.type === import_utils119.AST_NODE_TYPES.ArrayExpression || origin.type === import_utils119.AST_NODE_TYPES.Literal || origin.type === import_utils119.AST_NODE_TYPES.ArrowFunctionExpression || origin.type === import_utils119.AST_NODE_TYPES.FunctionExpression) return "unrelated";
+  return null;
+}
+function receiverOrigin(context, object, receivers) {
+  let current = object;
+  const seen = /* @__PURE__ */ new Set();
+  while (true) {
+    const unwrapped = unwrapExpression7(current);
+    if (unwrapped.type !== import_utils119.AST_NODE_TYPES.Identifier) return unwrapped;
+    const variable = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
+    if (variable === null) return null;
+    const known = receivers.get(variable);
+    if (known !== void 0) return known;
+    const initializer = immutableInitializer(variable, seen);
+    if (initializer === null) return null;
+    current = initializer;
+  }
+}
+function immutableInitializer(variable, seen) {
+  if (seen.has(variable) || !stableVariable(variable) || variable.defs.length !== 1) return null;
+  seen.add(variable);
+  const definition = variable.defs[0];
+  if (definition?.node.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator || definition.node.parent.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || definition.node.parent.kind !== "const") return null;
+  return definition.node.init;
+}
+function stableVariable(variable) {
+  return !variable.references.some((reference) => reference.isWrite() && reference.init !== true);
 }
 function referencedPropertyName(node) {
   if (node.property.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) return `#${node.property.name}`;
@@ -22160,131 +22259,145 @@ function referencedPropertyName(node) {
 }
 function walk(node, visitorKeys, visit, nestedFunction = false) {
   visit(node, nestedFunction);
-  const nested = nestedFunction || isFunction(node);
+  const nested = nestedFunction || isFunction(node) || node.type === import_utils119.AST_NODE_TYPES.ClassDeclaration || node.type === import_utils119.AST_NODE_TYPES.ClassExpression;
   forEachAstChild(node, visitorKeys, (child) => walk(child, visitorKeys, visit, nested));
 }
-function classScope(context, node, computedReferenceNames) {
+function classScope(context, node, computedReferences) {
   const methods = node.body.body.filter(
     (member) => member.type === import_utils119.AST_NODE_TYPES.MethodDefinition
   );
   const counts = classMethodCounts(node.body, methods);
-  const scopeDefinitions = methods.flatMap((method) => {
-    const name = methodName2(method);
-    return name !== null && counts.get(name) === 1 ? [{ name, node: method }] : [];
-  });
-  const definitions = methods.flatMap((method) => {
+  const implementations = methods.filter((method) => isFunction(method.value));
+  const implementationCounts = classMethodCounts(node.body, implementations);
+  const scopeDefinitions = implementations.flatMap((method) => {
     const name = methodName2(method);
-    const isPrivate = method.accessibility === "private" || method.key.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier;
-    return name !== null && isPrivate && counts.get(name) === 1 && method.decorators.length === 0 ? [{ name, node: method }] : [];
+    const key = name === null ? null : methodKey(name, method.static);
+    return name !== null && key !== null && implementationCounts.get(key) === 1 ? [{ key, name, node: method }] : [];
   });
+  const definitions = scopeDefinitions.filter(
+    ({ key, node: method }) => (method.accessibility === "private" || method.key.type === import_utils119.AST_NODE_TYPES.PrivateIdentifier) && counts.get(key) === 1 && method.decorators.length === 0 && !method.computed && method.kind === "method"
+  );
   if (definitions.length === 0) return;
-  const privateNames = new Set(definitions.map((definition) => definition.name));
+  const methodKeys = new Set(scopeDefinitions.map((definition) => definition.key));
   const calls = /* @__PURE__ */ new Map();
   const pinned = /* @__PURE__ */ new Set();
-  const classVariables = /* @__PURE__ */ new Set();
-  if (node.id !== null) {
-    const internal = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
-    if (internal !== null) classVariables.add(internal);
-  }
-  if (node.type === import_utils119.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils119.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils119.AST_NODE_TYPES.Identifier) {
-    const outer = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
-    if (outer !== null) classVariables.add(outer);
+  const classReceivers = classReceiverBindings(context, node);
+  const pinNames = (name, domain = null) => {
+    for (const definition of definitions) {
+      if ((name === null || definition.name === name) && (domain === null || definition.node.static === domain)) {
+        pinned.add(definition.key);
+      }
+    }
+  };
+  function pinDestructuredMembers(binding, domain) {
+    for (const property of binding.properties) {
+      if (property.type === import_utils119.AST_NODE_TYPES.RestElement || property.computed) {
+        pinNames(null, domain);
+      } else if (property.key.type === import_utils119.AST_NODE_TYPES.Identifier) {
+        pinNames(property.key.name, domain);
+      } else if (property.key.type === import_utils119.AST_NODE_TYPES.Literal && typeof property.key.value === "string") {
+        pinNames(property.key.value, domain);
+      }
+    }
   }
   function collectMethodCalls(method) {
-    const caller = methodName2(method);
-    if (caller === null || method.value.body === null) return;
-    const methodClassVariables = new Set(classVariables);
-    const methodAliases = /* @__PURE__ */ new Set();
+    const name = methodName2(method);
+    if (name === null) {
+      pinNames(null);
+      return;
+    }
+    if (!isFunction(method.value)) return;
+    const methodFunction = method.value;
+    const caller = methodKey(name, method.static);
+    const receivers = new Map(classReceivers);
     const parameterDecoratorNodes = /* @__PURE__ */ new Set();
     for (const parameter of method.value.params) {
       for (const decorator of parameter.decorators) {
         walk(decorator, context.sourceCode.visitorKeys, (current) => parameterDecoratorNodes.add(current));
       }
     }
-    const thisValue = (value) => {
-      let current = value;
-      while (current?.type === import_utils119.AST_NODE_TYPES.TSAsExpression || current?.type === import_utils119.AST_NODE_TYPES.TSSatisfiesExpression || current?.type === import_utils119.AST_NODE_TYPES.TSNonNullExpression) current = current.expression;
-      return current?.type === import_utils119.AST_NODE_TYPES.ThisExpression;
-    };
     const collectAlias = (current, nestedFunction) => {
-      if (nestedFunction || current.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator && current.type !== import_utils119.AST_NODE_TYPES.AssignmentPattern) return;
-      if (current.type === import_utils119.AST_NODE_TYPES.VariableDeclarator && (current.parent.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const")) return;
-      const binding = current.type === import_utils119.AST_NODE_TYPES.VariableDeclarator ? current.id : current.left;
-      const value = current.type === import_utils119.AST_NODE_TYPES.VariableDeclarator ? current.init : current.right;
-      if (!thisValue(value)) return;
-      if (binding.type === import_utils119.AST_NODE_TYPES.ObjectPattern) {
-        pinDestructuredMembers(binding);
+      if (nestedFunction || current.type !== import_utils119.AST_NODE_TYPES.VariableDeclarator || current.init === null) return;
+      const domain = receiverDomain(context, current.init, receivers, method.static);
+      if (domain === null || domain === "unrelated") return;
+      if (current.id.type === import_utils119.AST_NODE_TYPES.ObjectPattern) {
+        pinDestructuredMembers(current.id, domain);
         return;
       }
-      if (binding.type !== import_utils119.AST_NODE_TYPES.Identifier) return;
-      const variable = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(binding), binding.name);
-      if (variable !== null) {
-        methodClassVariables.add(variable);
-        methodAliases.add(variable);
+      if (current.id.type !== import_utils119.AST_NODE_TYPES.Identifier) return;
+      if (current.parent.type !== import_utils119.AST_NODE_TYPES.VariableDeclaration || current.parent.kind !== "const") {
+        pinNames(null, domain);
+        return;
       }
+      const variable = context.sourceCode.getDeclaredVariables(current)[0];
+      if (variable === void 0 || !stableVariable(variable)) return;
+      const local = variable.references.every((reference) => {
+        if (!reference.isRead()) return true;
+        const expression = wrappedExpression(reference.identifier);
+        return enclosingFunction5(context, reference.identifier) === methodFunction && expression.parent?.type === import_utils119.AST_NODE_TYPES.MemberExpression && expression.parent.object === expression;
+      });
+      if (local) receivers.set(variable, domain);
+      else pinNames(null, domain);
     };
-    for (const parameter of method.value.params) {
-      walk(parameter, context.sourceCode.visitorKeys, collectAlias);
-    }
-    for (const statement of method.value.body.body) {
-      walk(statement, context.sourceCode.visitorKeys, collectAlias);
-    }
-    function pinDestructuredMembers(binding) {
-      for (const property of binding.properties) {
-        if (property.type === import_utils119.AST_NODE_TYPES.RestElement) {
-          for (const name of privateNames) pinned.add(name);
-        } else if (property.key.type === import_utils119.AST_NODE_TYPES.Identifier && privateNames.has(property.key.name)) {
-          pinned.add(property.key.name);
-        }
-      }
-    }
+    for (const statement of method.value.body.body) walk(statement, context.sourceCode.visitorKeys, collectAlias);
     const visitCall = (current, nestedFunction) => {
-      if (current.type === import_utils119.AST_NODE_TYPES.VariableDeclarator && current.id.type === import_utils119.AST_NODE_TYPES.ObjectPattern && thisValue(current.init)) {
-        pinDestructuredMembers(current.id);
+      const destructuring = receiverDestructuring(current);
+      if (destructuring !== null) {
+        const domain2 = receiverDomain(context, destructuring.value, receivers, method.static);
+        if (domain2 !== "unrelated") pinDestructuredMembers(destructuring.binding, domain2);
       }
       if (current.type !== import_utils119.AST_NODE_TYPES.MemberExpression) return;
-      const target = referencedMethod(context, current, methodClassVariables);
-      if (target === null) {
-        const possibleTarget = referencedPropertyName(current);
-        if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
+      const domain = receiverDomain(context, current.object, receivers, method.static);
+      const targetName = referencedPropertyName(current);
+      if (domain === "unrelated") return;
+      if (domain === null) {
+        pinNames(targetName);
         return;
       }
-      if (!privateNames.has(target)) return;
-      const objectVariable = current.object.type === import_utils119.AST_NODE_TYPES.Identifier ? import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(current.object), current.object.name) : null;
-      if (objectVariable !== null && methodAliases.has(objectVariable)) {
-        pinned.add(target);
+      if (targetName === null) {
+        if (current.computed) pinNames(null, domain);
         return;
       }
-      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current) || current.parent.type !== import_utils119.AST_NODE_TYPES.CallExpression || current.parent.callee !== current) {
+      const target = methodKey(targetName, domain);
+      if (!methodKeys.has(target)) return;
+      if (current.computed || nestedFunction || parameterDecoratorNodes.has(current)) {
         pinned.add(target);
         return;
       }
-      const callees = calls.get(caller) ?? /* @__PURE__ */ new Set();
-      callees.add(target);
-      calls.set(caller, callees);
+      const count = localCallCount(context, current, methodFunction);
+      if (count === null) {
+        pinned.add(target);
+      } else if (count > 0) {
+        const callees = calls.get(caller) ?? /* @__PURE__ */ new Set();
+        callees.add(target);
+        calls.set(caller, callees);
+      }
     };
-    for (const decorator of method.decorators) {
-      walk(decorator, context.sourceCode.visitorKeys, visitCall, true);
-    }
+    for (const decorator of method.decorators) walk(decorator, context.sourceCode.visitorKeys, visitCall, true);
     if (method.computed) walk(method.key, context.sourceCode.visitorKeys, visitCall, true);
-    for (const parameter of method.value.params) {
-      walk(parameter, context.sourceCode.visitorKeys, visitCall);
-    }
-    for (const statement of method.value.body.body) {
-      walk(statement, context.sourceCode.visitorKeys, visitCall);
-    }
+    for (const parameter of method.value.params) walk(parameter, context.sourceCode.visitorKeys, visitCall);
+    for (const statement of method.value.body.body) walk(statement, context.sourceCode.visitorKeys, visitCall);
   }
   for (const method of methods) collectMethodCalls(method);
   for (const member of node.body.body) {
     if (member.type === import_utils119.AST_NODE_TYPES.MethodDefinition || member.type === import_utils119.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     walk(member, context.sourceCode.visitorKeys, (current) => {
       if (current.type !== import_utils119.AST_NODE_TYPES.MemberExpression) return;
-      const target = referencedMethod(context, current, classVariables);
-      const possibleTarget = target ?? referencedPropertyName(current);
-      if (possibleTarget !== null && privateNames.has(possibleTarget)) pinned.add(possibleTarget);
+      if (externalReceiverDomain(context, current.object, classReceivers) === "unrelated") return;
+      pinNames(referencedPropertyName(current));
     });
   }
-  for (const name of privateNames) if (computedReferenceNames.has(name)) pinned.add(name);
+  const externalReceivers = new Map(classReceivers);
+  for (const variable of context.sourceCode.getDeclaredVariables(node)) {
+    if (stableVariable(variable)) externalReceivers.set(variable, true);
+  }
+  for (const reference of computedReferences) {
+    if (context.sourceCode.getAncestors(reference).includes(node)) continue;
+    const domain = externalReceiverDomain(context, reference.object, externalReceivers);
+    if (domain === "unrelated") continue;
+    const name = referencedPropertyName(reference);
+    if (name !== null || domain !== null) pinNames(name, domain);
+  }
   const memberIndexes = new Map(node.body.body.map((member, index) => [member, index]));
   const runtimeBarrierPrefix = [0];
   for (const member of node.body.body) {
@@ -22298,6 +22411,27 @@ function classScope(context, node, computedReferenceNames) {
   };
   reportMisordered(context, definitions, scopeDefinitions, calls, pinned, canMove);
 }
+function classReceiverBindings(context, node) {
+  const classReceivers = /* @__PURE__ */ new Map();
+  if (node.id !== null) {
+    const internal = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(node), node.id.name);
+    if (internal !== null && stableVariable(internal)) classReceivers.set(internal, true);
+  }
+  if (node.type === import_utils119.AST_NODE_TYPES.ClassExpression && node.parent.type === import_utils119.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils119.AST_NODE_TYPES.Identifier && node.parent.parent.type === import_utils119.AST_NODE_TYPES.VariableDeclaration && node.parent.parent.kind === "const") {
+    const outer = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(node.parent), node.parent.id.name);
+    if (outer !== null && stableVariable(outer)) classReceivers.set(outer, true);
+  }
+  return classReceivers;
+}
+function receiverDestructuring(node) {
+  if (node.type === import_utils119.AST_NODE_TYPES.VariableDeclarator && node.id.type === import_utils119.AST_NODE_TYPES.ObjectPattern && node.init !== null) {
+    return { binding: node.id, value: node.init };
+  }
+  if ((node.type === import_utils119.AST_NODE_TYPES.AssignmentPattern || node.type === import_utils119.AST_NODE_TYPES.AssignmentExpression) && node.left.type === import_utils119.AST_NODE_TYPES.ObjectPattern) {
+    return { binding: node.left, value: node.right };
+  }
+  return null;
+}
 function isClassRuntimeBarrier(member) {
   switch (member.type) {
     case import_utils119.AST_NODE_TYPES.StaticBlock:
@@ -22326,6 +22460,7 @@ var stepdown_default = createRule({
   create(context) {
     if (isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
     const classes = [];
+    const functionBodies = [];
     return {
       ClassDeclaration: (node) => {
         classes.push(node);
@@ -22333,13 +22468,17 @@ var stepdown_default = createRule({
       ClassExpression: (node) => {
         classes.push(node);
       },
+      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression": (node) => {
+        if (isFunction(node) && node.body?.type === import_utils119.AST_NODE_TYPES.BlockStatement) functionBodies.push(node.body);
+      },
       "Program:exit": (program) => {
-        moduleScope(context, program);
-        const computedReferenceNames = /* @__PURE__ */ new Set();
+        declarationScope(context, program);
+        for (const body2 of functionBodies) declarationScope(context, body2);
+        const computedReferences = [];
         walk(program, context.sourceCode.visitorKeys, (node) => {
-          if (node.type === import_utils119.AST_NODE_TYPES.MemberExpression && node.computed && node.property.type === import_utils119.AST_NODE_TYPES.Literal && typeof node.property.value === "string") computedReferenceNames.add(node.property.value);
+          if (node.type === import_utils119.AST_NODE_TYPES.MemberExpression && node.computed) computedReferences.push(node);
         });
-        for (const node of classes) classScope(context, node, computedReferenceNames);
+        for (const node of classes) classScope(context, node, computedReferences);
       }
     };
   }
@@ -22348,12 +22487,18 @@ function classMethodCounts(body2, methods) {
   const counts = /* @__PURE__ */ new Map();
   for (const method of methods) {
     const name = methodName2(method);
-    if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
+    if (name !== null) {
+      const key = methodKey(name, method.static);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
   }
   for (const member of body2.body) {
     if (member.type !== import_utils119.AST_NODE_TYPES.TSAbstractMethodDefinition) continue;
     const name = !member.computed && member.key.type === import_utils119.AST_NODE_TYPES.Identifier ? member.key.name : null;
-    if (name !== null) counts.set(name, (counts.get(name) ?? 0) + 1);
+    if (name !== null) {
+      const key = methodKey(name, member.static);
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
   }
   return counts;
 }
@@ -22685,16 +22830,70 @@ function importedAssertionKind(specifier) {
 
 // src/rules/sole-export-matches-filename.ts
 var import_utils121 = require("@typescript-eslint/utils");
+
+// src/rules/_is-framework-entrypoint.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]);
+var NEXT_COMPONENT = /^(?:src\/)?app\/(?:.*\/)?(?:page|layout|loading|not-found|template|error|global-error|default|forbidden|unauthorized)\.[jt]sx?$/u;
+var NEXT_ROUTE = /^(?:src\/)?app\/(?:.*\/)?route\.[jt]s$/u;
+function isFrameworkEntrypoint(filename, exportKey) {
+  const normalized = filename.replaceAll("\\", "/");
+  if (!/(?:^|\/)(?:app|pages)\/|(?:^|\/)(?:middleware|proxy)\.[jt]s$/u.test(normalized)) return false;
+  const owner = packageOwner(normalized);
+  if (owner === null) return false;
+  const path = (0, import_node_path2.relative)(owner.root, normalized).replaceAll("\\", "/");
+  if (declaresFramework(owner.metadata, "next") && isNextEntrypoint(path, exportKey)) return true;
+  return declaresFramework(owner.metadata, "astro") && isAstroEntrypoint(path, exportKey);
+}
+function isNextEntrypoint(path, exportKey) {
+  const privateAppFolder = /^(?:src\/)?app\/(?:.*\/)?_[^/]+\//u.test(path);
+  if (!privateAppFolder && NEXT_COMPONENT.test(path) && exportKey === "default") return true;
+  if (!privateAppFolder && NEXT_ROUTE.test(path) && HTTP_METHODS.has(exportKey)) return true;
+  if (/^(?:src\/)?pages\/.*\.[jt]sx?$/u.test(path) && exportKey === "default") return true;
+  const middleware = /^(?:src\/)?(middleware|proxy)\.[jt]s$/u.exec(path);
+  return middleware !== null && (exportKey === "default" || exportKey === middleware[1]);
+}
+function isAstroEntrypoint(path, exportKey) {
+  return (
+    // Astro pages implicitly export their rendered component, including when only a routing hook is explicit.
+    /^src\/pages\/.*\.astro$/u.test(path) || /^src\/pages\/.*\.[jt]s$/u.test(path) && (HTTP_METHODS.has(exportKey) || exportKey === "ALL") || /^src\/middleware\.[jt]s$/u.test(path) && exportKey === "onRequest"
+  );
+}
+function packageOwner(filename) {
+  let root = (0, import_node_path2.dirname)(filename);
+  while (true) {
+    try {
+      return { root, metadata: JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(root, "package.json"), "utf8")) };
+    } catch (error) {
+      if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") return null;
+    }
+    const parent = (0, import_node_path2.dirname)(root);
+    if (parent === root) return null;
+    root = parent;
+  }
+}
+function declaresFramework(metadata, name) {
+  if (typeof metadata !== "object" || metadata === null) return false;
+  for (const section of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+    const dependencies = Reflect.get(metadata, section);
+    if (typeof dependencies === "object" && dependencies !== null && typeof Reflect.get(dependencies, name) === "string") return true;
+  }
+  return false;
+}
+
+// src/rules/sole-export-matches-filename.ts
 var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
-  defaultLevel: "warning",
+  defaultLevel: "error",
   summary: "Make a module filename reflect its sole named public runtime export.",
   rationale: "When a module owns one runtime responsibility, matching names make that responsibility directly discoverable.",
-  remediation: "Name the module for the exported responsibility, using either the full export name or a clear leading or trailing domain phrase; otherwise colocate genuinely related exports.",
+  remediation: "Name the module for the exported responsibility, using the full kebab-case export name; otherwise colocate genuinely related exports.",
   category: "maintainability",
   limitations: [
-    "Framework entrypoints, generic stems covered by no-generic-single-export-module, tests, generated files, anonymous defaults, CommonJS, and re-exports are excluded.",
-    "The rule compares the primary filename stem and preserves a single private underscore prefix and conventional suffixes such as .server or .worker. A leading or trailing export-name phrase is accepted only at token boundaries; multi-token stems also tolerate established acronym spelling such as github versus GitHub.",
-    "Exported destructuring patterns are excluded rather than undercounted as public exports."
+    "Framework entrypoints, generic stems covered by no-generic-single-export-module, tests, generated files, anonymous defaults, CommonJS, unresolved re-exports, and emission-dependent exports are excluded.",
+    "The rule compares the primary filename stem and preserves a single private underscore prefix and conventional suffixes such as .server or .worker. Supporting types do not exempt a sole runtime export; public runtime aliases count as distinct exports.",
+    "Exported destructuring patterns are excluded rather than undercounted as public exports.",
+    "Next.js and Astro routing exemptions require the nearest package.json to declare the framework, a conventional entrypoint path, and its expected runtime export. Custom routing roots and pageExtensions are not inferred."
   ],
   examples: [
     { id: "matching-class", title: "Match a class and module", outcome: "no-match", files: [{ path: "src/artifact-store.ts", source: "export class ArtifactStore {}" }], focusPath: "src/artifact-store.ts", expectedCount: 0, public: true },
@@ -22702,39 +22901,9 @@ var SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION = {
   ]
 };
 var EXCLUDED_STEMS = /* @__PURE__ */ new Set([
-  "common",
   "global",
-  "helpers",
   "index",
-  "layout",
-  "loading",
-  "middleware",
-  "misc",
-  "not-found",
-  "page",
-  "route",
-  "shared",
-  "template",
-  "types",
-  "util",
-  "utils"
-]);
-var WEAK_DOMAIN_TOKENS = /* @__PURE__ */ new Set([
-  "adapter",
-  "client",
-  "config",
-  "controller",
-  "factory",
-  "handler",
-  "manager",
-  "provider",
-  "record",
-  "repository",
-  "router",
-  "schema",
-  "service",
-  "store",
-  "worker"
+  "types"
 ]);
 function stem3(filename) {
   const base = filename.replaceAll("\\", "/").split("/").at(-1) ?? "";
@@ -22743,34 +22912,6 @@ function stem3(filename) {
 function kebabCase(name) {
   return name.replace(/([A-Z]{2,})([A-Z][a-z])/gu, "$1-$2").replace(/([a-z0-9])([A-Z])/gu, "$1-$2").replaceAll(/[^a-z0-9]+/giu, "-").replaceAll(/^-+|-+$/gu, "").toLowerCase();
 }
-function reflectsExportName(fileStem, exportedStem) {
-  if (fileStem.startsWith("_")) return false;
-  const visibleFileStem = fileStem.toLowerCase();
-  const fileTokens = visibleFileStem.split("-").filter(Boolean);
-  const exportTokens = exportedStem.split("-").filter(Boolean);
-  if (fileTokens.length === 0 || exportTokens.length === 0) return false;
-  if (fileTokens.length === 1) {
-    const [token] = fileTokens;
-    return token !== void 0 && token.length >= 4 && !WEAK_DOMAIN_TOKENS.has(token) && (exportTokens[0] === token || exportTokens.at(-1) === token);
-  }
-  const compactFile = fileTokens.join("");
-  if (compactFile.length < 6) return false;
-  const boundaryPhrases = /* @__PURE__ */ new Set();
-  for (let index = 1; index <= exportTokens.length; index += 1) {
-    boundaryPhrases.add(exportTokens.slice(0, index).join(""));
-    boundaryPhrases.add(exportTokens.slice(-index).join(""));
-  }
-  return boundaryPhrases.has(compactFile);
-}
-function declarationExport(statement) {
-  const declaration = statement.declaration;
-  if (declaration === null || declaration.declare === true) return [];
-  if (declaration.type === import_utils121.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils121.AST_NODE_TYPES.FunctionDeclaration || declaration.type === import_utils121.AST_NODE_TYPES.TSEnumDeclaration) return declaration.id === null ? [] : [{ name: declaration.id.name, node: declaration }];
-  if (declaration.type !== import_utils121.AST_NODE_TYPES.VariableDeclaration) return [];
-  return declaration.declarations.flatMap(
-    (item) => item.id.type === import_utils121.AST_NODE_TYPES.Identifier ? [{ name: item.id.name, node: item }] : []
-  );
-}
 var sole_export_matches_filename_default = createRule({
   name: "sole-export-matches-filename",
   documentation: SOLE_EXPORT_MATCHES_FILENAME_DOCUMENTATION,
@@ -22786,64 +22927,25 @@ var sole_export_matches_filename_default = createRule({
   create(context) {
     const fileStem = stem3(context.filename);
     const normalizedFilename = context.filename.replaceAll("\\", "/");
-    if (EXCLUDED_STEMS.has(fileStem) || /(?:^|\/)app\/(?:.*\/)?(?:global-)?error\.[jt]sx?$/u.test(normalizedFilename) || normalizedFilename.includes("/pages/") || context.filename.endsWith(".d.ts") || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    if (EXCLUDED_STEMS.has(fileStem) || GENERIC_MODULE_STEMS.has(fileStem) || context.filename.endsWith(".d.ts") || isTestFile(context.filename) || isGeneratedFile(context.filename, context.sourceCode.text)) return {};
+    let hasCommonJsExport = false;
     return {
+      "CallExpression, MemberExpression"(node) {
+        if (isCommonJsExportReference(node, context.sourceCode)) hasCommonJsExport = true;
+      },
       "Program:exit"(program) {
-        const exports2 = [];
-        const publicExports = /* @__PURE__ */ new Set();
-        function collectPublicExport(statement) {
-          if (statement.type === import_utils121.AST_NODE_TYPES.ExportAllDeclaration || statement.type === import_utils121.AST_NODE_TYPES.ExportNamedDeclaration && statement.source !== null) return false;
-          if (statement.type === import_utils121.AST_NODE_TYPES.ExportDefaultDeclaration) {
-            publicExports.add("default");
-            const declaration = statement.declaration;
-            if ((declaration.type === import_utils121.AST_NODE_TYPES.ClassDeclaration || declaration.type === import_utils121.AST_NODE_TYPES.FunctionDeclaration) && declaration.id !== null) exports2.push({ name: declaration.id.name, node: declaration });
-            else return false;
-          }
-          if (statement.type !== import_utils121.AST_NODE_TYPES.ExportNamedDeclaration) return true;
-          return collectNamedExport(statement);
-        }
-        function collectNamedExport(statement) {
-          const declaration = statement.declaration;
-          if (declaration !== null && "id" in declaration && declaration.id?.type === import_utils121.AST_NODE_TYPES.Identifier) {
-            publicExports.add(declaration.id.name);
-          }
-          if (declaration?.type === import_utils121.AST_NODE_TYPES.VariableDeclaration) {
-            if (declaration.declarations.some((item) => item.id.type !== import_utils121.AST_NODE_TYPES.Identifier)) return false;
-            for (const item of declaration.declarations) {
-              if (item.id.type === import_utils121.AST_NODE_TYPES.Identifier) publicExports.add(item.id.name);
-            }
-          }
-          for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === import_utils121.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
-            publicExports.add(String(exported));
-          }
-          if (statement.exportKind === "type") return true;
-          exports2.push(...declarationExport(statement));
-          collectRuntimeSpecifiers(statement);
-          return true;
-        }
-        function collectRuntimeSpecifiers(statement) {
-          for (const specifier of statement.specifiers) {
-            const exported = specifier.exported.type === import_utils121.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
-            publicExports.add(String(exported));
-            if (specifier.exportKind === "type") continue;
-            if (exported === "default") exports2.push({ name: specifier.local.name, node: specifier });
-            else exports2.push({ name: String(exported), node: specifier });
-          }
-        }
-        for (const statement of program.body) {
-          if (!collectPublicExport(statement)) return;
-        }
-        const unique = new Map(exports2.map((item) => [item.name, item]));
-        if (unique.size !== 1 || publicExports.size !== 1) return;
-        const only = [...unique.values()][0];
+        if (hasCommonJsExport) return;
+        const exports2 = runtimeExports(program);
+        if (exports2.ambiguous || exports2.exports.length !== 1) return;
+        const only = exports2.exports[0];
         if (only === void 0) return;
+        if (isFrameworkEntrypoint(normalizedFilename, only.key)) return;
         if (only.name === "onRouterTransitionStart" && /(?:^|\/)instrumentation-client\.[jt]s$/u.test(normalizedFilename)) return;
         if (only.name === "collections" && /(?:^|\/)src\/content\.config\.(?:ts|js|mjs)$/u.test(normalizedFilename) && program.body.some((statement) => statement.type === import_utils121.AST_NODE_TYPES.ImportDeclaration && statement.source.value === "astro:content")) return;
         const exportedStem = kebabCase(only.name);
         if (exportedStem === "") return;
         const expected = `${fileStem.startsWith("_") ? "_" : ""}${exportedStem}`;
-        if (expected === fileStem.toLowerCase() || reflectsExportName(fileStem, exportedStem)) return;
+        if (expected === fileStem.toLowerCase()) return;
         context.report({ node: only.node, messageId: "matchSoleExport", data: { exported: only.name, expected } });
       }
     };
@@ -23058,7 +23160,7 @@ var chainMemberNames2 = (node) => {
   names.reverse();
   return names;
 };
-var unwrapExpression7 = (node) => {
+var unwrapExpression8 = (node) => {
   let current = node;
   while (current.type === import_utils122.AST_NODE_TYPES.TSAsExpression || current.type === import_utils122.AST_NODE_TYPES.TSSatisfiesExpression || current.type === import_utils122.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils122.AST_NODE_TYPES.TSTypeAssertion) {
     current = current.expression;
@@ -23098,18 +23200,8 @@ var require_pascal_case_zod_schema_name_default = createRule({
       const binding = resolvedBinding(identifier);
       if (binding !== null) zodBindings.add(binding);
     }
-    function isZodChain(node) {
-      const root = calleeChainRoot2(node);
-      if (root === null) return false;
-      const binding = resolvedBinding(root);
-      return binding !== null && zodBindings.has(binding);
-    }
-    function isSchemaBinding(identifier) {
-      const binding = resolvedBinding(identifier);
-      return binding !== null && schemaBindings.has(binding);
-    }
     function isConfirmedSchema(expression) {
-      const init = unwrapExpression7(expression);
+      const init = unwrapExpression8(expression);
       if (init.type === import_utils122.AST_NODE_TYPES.Identifier) return isSchemaBinding(init);
       if (init.type !== import_utils122.AST_NODE_TYPES.CallExpression || init.callee.type !== import_utils122.AST_NODE_TYPES.MemberExpression) {
         return false;
@@ -23124,6 +23216,16 @@ var require_pascal_case_zod_schema_name_default = createRule({
       const root = calleeChainRoot2(init.callee);
       return root !== null && isSchemaBinding(root) && SCHEMA_RETURNING_METHODS.has(terminal);
     }
+    function isSchemaBinding(identifier) {
+      const binding = resolvedBinding(identifier);
+      return binding !== null && schemaBindings.has(binding);
+    }
+    function isZodChain(node) {
+      const root = calleeChainRoot2(node);
+      if (root === null) return false;
+      const binding = resolvedBinding(root);
+      return binding !== null && zodBindings.has(binding);
+    }
     if (isTestFile(context.filename) || BENCHMARK_PATH_RE2.test(context.filename.replaceAll("\\", "/")) || isGeneratedFile(context.filename, context.sourceCode.text)) {
       return {};
     }
@@ -23154,7 +23256,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
   }
 });
 
-// src/rules/_renames.ts
+// src/rules/_renamed-rules.ts
 var RENAMED_RULES = {
   "jsdoc-restates-signature": "no-restated-jsdoc",
   "zod-naming-convention": "require-pascal-case-zod-schema-name",
@@ -23163,7 +23265,7 @@ var RENAMED_RULES = {
   "trailing-value-narration": "no-trailing-value-narration"
 };
 
-// src/rules/_retired.ts
+// src/rules/_retired-rules.ts
 var RETIRED_RULES = {
   "ban-loose-type-guards-in-tests": {
     removedIn: "5.0.0",
@@ -23355,7 +23457,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.28.1"
+  version: "16.1.0"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {
@@ -23380,8 +23482,7 @@ var ADVISORY_RULES = [
   "@sarj/prefer-whole-object-assertion",
   "@sarj/require-camelcase-properties",
   "@sarj/require-interface-for-exported-class",
-  "@sarj/require-sql-access-class",
-  "@sarj/sole-export-matches-filename"
+  "@sarj/require-sql-access-class"
 ];
 var RECOMMENDED_RULES = {
   "@sarj/no-conditional-empty-object-spread": "error",
@@ -23493,7 +23594,7 @@ var RECOMMENDED_RULES = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "error",
-  "@sarj/sole-export-matches-filename": "warn",
+  "@sarj/sole-export-matches-filename": "error",
   "@sarj/test-phase-label-comment": "error",
   "@sarj/require-pascal-case-zod-schema-name": "error"
 };
@@ -23611,7 +23712,7 @@ var STRICT_RULES = {
   "@sarj/store-insert-requires-on-conflict": "error",
   "@sarj/stepdown": "error",
   "@sarj/source-coupled-test": "error",
-  "@sarj/sole-export-matches-filename": "warn",
+  "@sarj/sole-export-matches-filename": "error",
   "@sarj/test-phase-label-comment": "error",
   "@sarj/require-pascal-case-zod-schema-name": "error"
 };
@@ -23634,7 +23735,7 @@ var PLUGIN = {
     };
   }
 };
-var index_default = PLUGIN;
+var src_default = PLUGIN;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ADVISORY_RULES,