@sarj/eslint-plugin 15.28.1 → 16.0.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");
@@ -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,139 +7534,152 @@ 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;
 }
+
+// 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,
@@ -7693,16 +7695,11 @@ var no_generic_single_export_module_default = createRule({
   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;
@@ -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) };
@@ -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.",
     "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,6 +22046,43 @@ function cycleComponents(graph) {
   }
   return components;
 }
+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 moduleScope(context, program) {
   const declarations = moduleDefinitions(program);
   const counts = /* @__PURE__ */ new Map();
@@ -22064,6 +22098,26 @@ function moduleScope(context, program) {
   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 statementIndex = (definition) => {
+    let current = definition.node;
+    while (current.parent !== void 0 && current.parent.type !== import_utils119.AST_NODE_TYPES.Program) current = current.parent;
+    return statementIndexes.get(current);
+  };
+  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];
+  };
+  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 +22125,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 +22185,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 +22206,21 @@ 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;
+  if (unwrapped.type !== import_utils119.AST_NODE_TYPES.Identifier) return null;
+  const variable = import_utils119.ASTUtils.findVariable(context.sourceCode.getScope(unwrapped), unwrapped.name);
+  return variable === null ? null : receivers.get(variable) ?? null;
+}
+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,7 +22229,7 @@ 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) {
@@ -22168,123 +22237,127 @@ function classScope(context, node, computedReferenceNames) {
     (member) => member.type === import_utils119.AST_NODE_TYPES.MethodDefinition
   );
   const counts = classMethodCounts(node.body, methods);
-  const scopeDefinitions = 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);
-    return name !== null && counts.get(name) === 1 ? [{ name, node: method }] : [];
-  });
-  const definitions = methods.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) 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);
+        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 === 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);
+      pinNames(referencedPropertyName(current));
     });
   }
-  for (const name of privateNames) if (computedReferenceNames.has(name)) pinned.add(name);
+  for (const definition of definitions) {
+    if (computedReferenceNames.has(definition.name)) pinned.add(definition.key);
+  }
   const memberIndexes = new Map(node.body.body.map((member, index) => [member, index]));
   const runtimeBarrierPrefix = [0];
   for (const member of node.body.body) {
@@ -22298,6 +22371,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:
@@ -22348,12 +22442,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;
 }
@@ -22686,14 +22786,14 @@ function importedAssertionKind(specifier) {
 // src/rules/sole-export-matches-filename.ts
 var import_utils121 = require("@typescript-eslint/utils");
 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.",
+    "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."
   ],
   examples: [
@@ -22702,39 +22802,16 @@ 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 +22820,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 +22835,24 @@ 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) || /(?:^|\/)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 {};
+    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 (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 +23067,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;
@@ -23109,7 +23118,7 @@ var require_pascal_case_zod_schema_name_default = createRule({
       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;
@@ -23154,7 +23163,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 +23172,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 +23364,7 @@ var RULES = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "15.28.1"
+  version: "16.0.0"
 };
 var APPLICATION_ONLY_RULES = [];
 var LIBRARY_IMPORT_POLICY = ["error", {
@@ -23380,8 +23389,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 +23501,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 +23619,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 +23642,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,