@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.97

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -152,6 +152,232 @@ function hasOverloadSignatures(node) {
         return !hasBody && key.name === targetName;
     });
 }
+function getClassOf(node) {
+    const classBody = node.parent;
+    if (!classBody || classBody.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+        return null;
+    }
+    const classNode = classBody.parent;
+    if (classNode &&
+        (classNode.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            classNode.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
+        return classNode;
+    }
+    return null;
+}
+/**
+ * A member typed as a function is as binding as a method signature: a getter
+ * returning the function's *result* is not assignable to the function type, so
+ * such a member is a contract match too.
+ */
+function isFunctionTypeNode(node) {
+    if (!node)
+        return false;
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSFunctionType:
+        case utils_1.AST_NODE_TYPES.TSConstructorType:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            return node.types.some(isFunctionTypeNode);
+        default:
+            return false;
+    }
+}
+function knownMemberName(key, computed) {
+    if (!key || computed)
+        return null;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier)
+        return key.name;
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return null;
+}
+function findVariableInScopeChain(scope, name) {
+    let current = scope;
+    while (current) {
+        const variable = current.variables.find((entry) => entry.name === name);
+        if (variable) {
+            return variable;
+        }
+        current = current.upper;
+    }
+    return null;
+}
+function collectTypeElementMembers(elements, out) {
+    for (const element of elements) {
+        if (element.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+            // A `get`/`set` signature already describes property access, so a getter
+            // implementation satisfies it — only call signatures bind.
+            if (element.kind === 'get' || element.kind === 'set')
+                continue;
+            const name = knownMemberName(element.key, element.computed);
+            if (name)
+                out.instance.add(name);
+            continue;
+        }
+        if (element.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+            isFunctionTypeNode(element.typeAnnotation?.typeAnnotation)) {
+            const name = knownMemberName(element.key, element.computed);
+            if (name)
+                out.instance.add(name);
+        }
+    }
+}
+function collectClassContractMembers(classNode, out) {
+    for (const member of classNode.body.body) {
+        if (member.type === utils_1.AST_NODE_TYPES.StaticBlock)
+            continue;
+        const isStatic = member.static ?? false;
+        const target = isStatic ? out.staticSide : out.instance;
+        if (member.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+            member.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+            if (member.kind !== 'method')
+                continue;
+            const name = knownMemberName(member.key, member.computed);
+            if (name)
+                target.add(name);
+            continue;
+        }
+        if ((member.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+            member.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition) &&
+            isFunctionTypeNode(member.typeAnnotation?.typeAnnotation)) {
+            const name = knownMemberName(member.key, member.computed);
+            if (name)
+                target.add(name);
+        }
+    }
+}
+function collectContractFromName(name, scope, seen, out) {
+    if (seen.has(name))
+        return;
+    seen.add(name);
+    const variable = findVariableInScopeChain(scope, name);
+    // No binding at all (a global/ambient type) or a binding with no declaration
+    // node (a lib type) leaves the contract unknowable from this file.
+    if (!variable || variable.defs.length === 0) {
+        out.resolved = false;
+        return;
+    }
+    for (const def of variable.defs) {
+        const declaration = def.node;
+        switch (declaration.type) {
+            case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+                collectContractFromInterface(declaration, scope, seen, out);
+                break;
+            case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+                collectContractFromTypeNode(declaration.typeAnnotation, scope, seen, out);
+                break;
+            case utils_1.AST_NODE_TYPES.ClassDeclaration:
+            case utils_1.AST_NODE_TYPES.ClassExpression:
+                collectContractFromClass(declaration, scope, seen, out);
+                break;
+            default:
+                // An import binding, an enum, a value — nothing whose members this file
+                // can enumerate.
+                out.resolved = false;
+        }
+    }
+}
+function collectContractFromHeritage(heritage, scope, seen, out) {
+    // A qualified reference (`ns.Type`) names a declaration this lookup cannot
+    // reach, so the contract stays unresolved.
+    if (heritage.expression.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        out.resolved = false;
+        return;
+    }
+    collectContractFromName(heritage.expression.name, scope, seen, out);
+}
+function collectContractFromInterface(declaration, scope, seen, out) {
+    collectTypeElementMembers(declaration.body.body, out);
+    for (const heritage of [
+        ...(declaration.extends ?? []),
+        ...(declaration.implements ?? []),
+    ]) {
+        collectContractFromHeritage(heritage, scope, seen, out);
+    }
+}
+function collectContractFromClass(declaration, scope, seen, out) {
+    collectClassContractMembers(declaration, out);
+    if (declaration.superClass) {
+        if (declaration.superClass.type === utils_1.AST_NODE_TYPES.Identifier) {
+            collectContractFromName(declaration.superClass.name, scope, seen, out);
+        }
+        else {
+            // A mixin call or member expression base class: unknowable members.
+            out.resolved = false;
+        }
+    }
+    for (const heritage of declaration.implements ?? []) {
+        collectContractFromHeritage(heritage, scope, seen, out);
+    }
+}
+function collectContractFromTypeNode(typeNode, scope, seen, out) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            collectTypeElementMembers(typeNode.members, out);
+            return;
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            for (const part of typeNode.types) {
+                collectContractFromTypeNode(part, scope, seen, out);
+            }
+            return;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                collectContractFromName(typeNode.typeName.name, scope, seen, out);
+                return;
+            }
+            out.resolved = false;
+            return;
+        default:
+            // Mapped, conditional, indexed-access and utility-type shapes describe
+            // members this rule cannot enumerate syntactically.
+            out.resolved = false;
+    }
+}
+/**
+ * Resolves what the class's `extends`/`implements` clauses oblige its members
+ * to look like, using only declarations visible in the file being linted.
+ */
+function resolveHeritageContract(classNode, scope) {
+    const heritageNames = [];
+    let hasOpaqueHeritage = false;
+    if (classNode.superClass) {
+        if (classNode.superClass.type === utils_1.AST_NODE_TYPES.Identifier) {
+            heritageNames.push(classNode.superClass.name);
+        }
+        else {
+            hasOpaqueHeritage = true;
+        }
+    }
+    for (const implemented of classNode.implements ?? []) {
+        if (implemented.expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+            heritageNames.push(implemented.expression.name);
+        }
+        else {
+            hasOpaqueHeritage = true;
+        }
+    }
+    if (!heritageNames.length && !hasOpaqueHeritage) {
+        return { status: 'none' };
+    }
+    if (hasOpaqueHeritage) {
+        return { status: 'unresolvable' };
+    }
+    const members = {
+        instance: new Set(),
+        staticSide: new Set(),
+        resolved: true,
+    };
+    const seen = new Set();
+    for (const name of heritageNames) {
+        collectContractFromName(name, scope, seen, members);
+    }
+    return members.resolved
+        ? { status: 'resolved', members }
+        : { status: 'unresolvable' };
+}
 exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
     name: 'prefer-getter-over-parameterless-method',
     meta: {
@@ -535,6 +761,37 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                 }
             }
         }
+        const heritageContracts = new WeakMap();
+        /**
+         * A method that satisfies an `implements` clause or overrides a base-class
+         * member cannot become a getter: the heritage type declares a *method*, so
+         * the conversion the rule prescribes is a TS2416/TS2417 compile error. When
+         * every heritage reference resolves in-file the exemption is per method —
+         * only names the contract declares are spared. When any reference leaves
+         * the file (an import, a global, a third-party `.d.ts`, a mixin call) the
+         * contract's members are unknowable, so no method of that class can be
+         * proven safe and the whole class is spared: a false negative is preferable
+         * to prescribing a remedy that does not compile.
+         */
+        function isConstrainedByHeritage(node) {
+            const classNode = getClassOf(node);
+            if (!classNode)
+                return false;
+            let contract = heritageContracts.get(classNode);
+            if (!contract) {
+                contract = resolveHeritageContract(classNode, context.getScope());
+                heritageContracts.set(classNode, contract);
+            }
+            if (contract.status === 'none')
+                return false;
+            if (contract.status === 'unresolvable')
+                return true;
+            const name = node.key.name;
+            const isStatic = node.static ?? false;
+            return isStatic
+                ? contract.members.staticSide.has(name)
+                : contract.members.instance.has(name);
+        }
         const callUsedNamesByClass = new WeakMap();
         const callUsedNamesInFile = new Set();
         const candidates = [];
@@ -594,6 +851,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                     return;
                 if (!node.value.body)
                     return;
+                if (isConstrainedByHeritage(node))
+                    return;
                 const name = node.key.name;
                 if (ignoredMethods.has(name))
                     return;

package/lib/rules/prefer-type-alias-over-typeof-constant.js

@@ -100,7 +100,8 @@ function collectReferencedTypeNames(node, acc = new Set()) {
                 collectReferencedTypeNames(mapped.typeAnnotation, acc);
             if (mapped.nameType)
                 collectReferencedTypeNames(mapped.nameType, acc);
-            if (mapped.typeParameter && mapped.typeParameter.constraint) {
+            if (mapped.typeParameter &&
+                mapped.typeParameter.constraint) {
                 collectReferencedTypeNames(mapped.typeParameter.constraint, acc);
             }
             break;
@@ -162,6 +163,61 @@ function collectReferencedTypeNames(node, acc = new Set()) {
     }
     return acc;
 }
+/**
+ * Type-level operators that keep a `typeof` query in the position where the
+ * alias derives its own type from the constant, rather than moving the query
+ * into a member, parameter or declaration slot. Unions, intersections, `keyof`,
+ * element extraction, array wrappers and utility application all still describe
+ * "this alias IS the constant's type", which is the remedy this rule asks for.
+ *
+ * Utility application belongs here for a convergence reason: the remedy for a
+ * reported `function f(x: Readonly<typeof CONST>)` is to name that type once as
+ * `type T = Readonly<typeof CONST>`. Reporting the extracted alias too would
+ * make the remedy its own violation, leaving that class of code with nowhere to
+ * land.
+ */
+function isAliasDerivationWrapper(parent, child) {
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+        case utils_1.AST_NODE_TYPES.TSTypeOperator:
+        case utils_1.AST_NODE_TYPES.TSArrayType:
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+        case utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+            // Only the object side derives from the constant. `Foo[typeof KEY]` reads
+            // the constant as a lookup key, which is a consumer position like any
+            // other annotation.
+            return parent.objectType === child;
+        default:
+            return isParenthesizedType(parent);
+    }
+}
+/**
+ * True when the query defines the alias itself — `type T = typeof CONST` and the
+ * derivation wrappers around it, such as `keyof typeof CONST`,
+ * `(typeof CONST)[number]` or `Readonly<typeof CONST>` (Issues #1117, #1175).
+ * A query sitting in a member, index signature, function-type parameter,
+ * conditional branch, mapped-type constraint or type-parameter default inside the
+ * alias body is a use site and stays reportable, matching what the same shape
+ * does outside an alias.
+ */
+function isCanonicalAliasDerivation(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            return parent.typeAnnotation === child;
+        }
+        if (!isAliasDerivationWrapper(parent, child)) {
+            return false;
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
 /** Collects module-level consts and type aliases for quick lookup */
 function collectTopLevelContext(program) {
     const topLevelConstInitByName = new Map();
@@ -292,9 +348,12 @@ exports.preferTypeAliasOverTypeofConstant = (0, createRule_1.createRule)({
                 if (!collected)
                     return;
                 const ancestors = ASTHelpers_1.ASTHelpers.getAncestors(context, node);
-                // Skip if inside a type alias declaration (Issue #1117, #1175)
-                // This allows 'type T = typeof CONST' as the canonical way to define the alias.
-                if (ancestors.some((a) => a.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration)) {
+                // Skip the alias definition itself (Issue #1117, #1175), which is the
+                // canonical way to name the constant's type. The exemption covers the
+                // declared type of the alias and its derivation wrappers only; a query
+                // buried in an alias member is a use site and reports like the same
+                // shape written on an interface or a parameter (Issue #1680).
+                if (isCanonicalAliasDerivation(node)) {
                     return;
                 }
                 // Skip `keyof typeof X` as it's a canonical way to derive a union of keys from a constant object.

package/lib/rules/require-https-error.js

@@ -26,8 +26,12 @@ module.exports = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            useHttpsError: 'Throwing "{{constructorName}}" in Cloud Functions returns a generic 500 and drops the structured status code clients rely on. Throw the proprietary HttpsError instead so responses include the correct status, sanitized message, and logging context.',
-            useProprietaryHttpsError: '{{reference}} comes from {{source}} and bypasses our proprietary HttpsError wrapper, so responses skip standardized status codes, logging, and client-safe payloads. Import and throw HttpsError from @our-company/errors to keep errors consistent.',
+            // The remedy names the module SHAPE, never a package name: the proprietary
+            // wrapper lives inside the consuming repository (a shared
+            // util/errors/HttpsError), so prescribing an npm specifier sends the
+            // reader to install something that does not exist (issue #1685).
+            useHttpsError: 'Throwing "{{constructorName}}" in Cloud Functions returns a generic 500 and drops the structured status code clients rely on. Throw the proprietary HttpsError instead so responses include the correct status, sanitized message, and logging context. Import it from the proprietary HttpsError module this codebase owns, such as a shared util/errors/HttpsError, rather than from firebase-admin.',
+            useProprietaryHttpsError: '{{reference}} comes from {{source}} and bypasses our proprietary HttpsError wrapper, so responses skip standardized status codes, logging, and client-safe payloads. Import HttpsError from the proprietary HttpsError module this codebase owns, such as a shared util/errors/HttpsError, and throw that to keep errors consistent.',
         },
     },
     defaultOptions: [],

package/lib/rules/use-custom-link.js

@@ -2,6 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCustomLink = void 0;
 const createRule_1 = require("../utils/createRule");
+const LINK_MODULE_PATH = 'src/components/Link';
+/**
+ * MUI's documented Next.js integration names the component that adapts
+ * `next/link` for the wrapper `NextLinkComposed`, and `src/components/Link`
+ * renders it. Keying on the basename alone — rather than a full path — matches
+ * wherever the integration component is colocated.
+ */
+const INTEGRATION_COMPONENT = 'NextLinkComposed';
+const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
+/**
+ * The two modules that implement the wrapper are the ones that must keep
+ * importing `next/link`: `src/components/Link` is the module the fixer points
+ * every other import at, and it renders `NextLinkComposed`. Rewriting either
+ * one manufactures a cycle — `Link` importing itself, or
+ * `Link → NextLinkComposed → Link` — so the wrapper evaluates circularly and
+ * every consumer of it breaks.
+ *
+ * The linted path is matched by suffix because it reaches the rule in whatever
+ * form the caller used — absolute (`/repo/src/components/Link.tsx`) or
+ * project-relative (`src/components/Link.tsx`). The suffix has to land on a
+ * path-segment boundary, otherwise `notsrc/components/Link.tsx` — an unrelated
+ * module — would be exempted too, and the integration component is matched by
+ * basename equality so that `MyNextLinkComposed.tsx` stays reportable.
+ */
+const isWrapperImplementation = (filename) => {
+    const normalized = filename.replace(/\\/g, '/').replace(SOURCE_EXTENSION, '');
+    const basename = normalized.slice(normalized.lastIndexOf('/') + 1);
+    if (basename === INTEGRATION_COMPONENT) {
+        return true;
+    }
+    if (!normalized.endsWith(LINK_MODULE_PATH)) {
+        return false;
+    }
+    const suffixStart = normalized.length - LINK_MODULE_PATH.length;
+    return suffixStart === 0 || normalized[suffixStart - 1] === '/';
+};
 exports.useCustomLink = (0, createRule_1.createRule)({
     name: 'use-custom-link',
     meta: {
@@ -18,6 +54,14 @@ exports.useCustomLink = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // A processor hands the rule a virtual filename for an extracted code block;
+        // the physical path is the one that identifies the module on disk.
+        const filename = context.getPhysicalFilename
+            ? context.getPhysicalFilename()
+            : context.getFilename();
+        if (isWrapperImplementation(filename)) {
+            return {};
+        }
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'next/link') {
@@ -41,7 +85,7 @@ exports.useCustomLink = (0, createRule_1.createRule)({
                                     defaultAsSpecifier?.local?.name ||
                                     'Link';
                                 // Create the new import statement
-                                const newImport = `import ${localName} from 'src/components/Link';`;
+                                const newImport = `import ${localName} from '${LINK_MODULE_PATH}';`;
                                 return fixer.replaceText(node, newImport);
                             },
                         });

package/lib/rules/use-custom-memo.js

@@ -4,6 +4,28 @@ exports.useCustomMemo = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const MEMO_MODULE = `'src/util/memo'`;
+/** `MEMO_MODULE` carries the quotes the fixer emits; a path never does. */
+const MEMO_MODULE_PATH = MEMO_MODULE.slice(1, -1);
+const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
+/**
+ * The module the fixer points every `memo` import at is the one module that must
+ * keep importing `memo` from `react`: rewriting it makes it import itself, and a
+ * self-import evaluates circularly, so the wrapper exports `undefined` and every
+ * consumer of it breaks.
+ *
+ * The linted path is matched by suffix because it reaches the rule in whatever
+ * form the caller used — absolute (`/repo/src/util/memo.ts`) or project-relative
+ * (`src/util/memo.ts`). The suffix has to land on a path-segment boundary,
+ * otherwise `notsrc/util/memo.ts` — an unrelated module — would be exempted too.
+ */
+const isMemoModule = (filename) => {
+    const normalized = filename.replace(/\\/g, '/').replace(SOURCE_EXTENSION, '');
+    if (!normalized.endsWith(MEMO_MODULE_PATH)) {
+        return false;
+    }
+    const suffixStart = normalized.length - MEMO_MODULE_PATH.length;
+    return suffixStart === 0 || normalized[suffixStart - 1] === '/';
+};
 const isComment = (token) => token.type === utils_1.AST_TOKEN_TYPES.Line || token.type === utils_1.AST_TOKEN_TYPES.Block;
 const isMemoSpecifier = (specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
     specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -162,6 +184,14 @@ exports.useCustomMemo = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // A processor hands the rule a virtual filename for an extracted code block;
+        // the physical path is the one that identifies the module on disk.
+        const filename = context.getPhysicalFilename
+            ? context.getPhysicalFilename()
+            : context.getFilename();
+        if (isMemoModule(filename)) {
+            return {};
+        }
         return {
             ImportDeclaration(node) {
                 if (node.source.value !== 'react') {

package/lib/rules/use-custom-router.js

@@ -3,6 +3,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCustomRouter = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ROUTER_MODULE_PATH = 'src/hooks/routing/useRouter';
+const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
+/**
+ * The module the fixer points every `useRouter` import at is the one module that
+ * must keep importing `useRouter` from `next/router`: rewriting it makes it
+ * import itself, and a self-import evaluates circularly, so the wrapper exports
+ * `undefined` and every consumer of it breaks.
+ *
+ * The linted path is matched by suffix because it reaches the rule in whatever
+ * form the caller used — absolute (`/repo/src/hooks/routing/useRouter.ts`) or
+ * project-relative (`src/hooks/routing/useRouter.ts`). The suffix has to land on
+ * a path-segment boundary, otherwise `notsrc/hooks/routing/useRouter.ts` — an
+ * unrelated module — would be exempted too.
+ */
+const isRouterModule = (filename) => {
+    const normalized = filename.replace(/\\/g, '/').replace(SOURCE_EXTENSION, '');
+    if (!normalized.endsWith(ROUTER_MODULE_PATH)) {
+        return false;
+    }
+    const suffixStart = normalized.length - ROUTER_MODULE_PATH.length;
+    return suffixStart === 0 || normalized[suffixStart - 1] === '/';
+};
 exports.useCustomRouter = (0, createRule_1.createRule)({
     name: 'use-custom-router',
     meta: {
@@ -19,6 +41,14 @@ exports.useCustomRouter = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        // A processor hands the rule a virtual filename for an extracted code block;
+        // the physical path is the one that identifies the module on disk.
+        const filename = context.getPhysicalFilename
+            ? context.getPhysicalFilename()
+            : context.getFilename();
+        if (isRouterModule(filename)) {
+            return {};
+        }
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'next/router') {
@@ -45,7 +75,7 @@ exports.useCustomRouter = (0, createRule_1.createRule)({
                                         .map((s) => s.local.name !== s.imported.name
                                         ? `useRouter as ${s.local.name}`
                                         : 'useRouter')
-                                        .join(', ')} } from 'src/hooks/routing/useRouter';`);
+                                        .join(', ')} } from '${ROUTER_MODULE_PATH}';`);
                                 }
                                 else {
                                     // Create a new import for useRouter and keep other imports
@@ -53,7 +83,7 @@ exports.useCustomRouter = (0, createRule_1.createRule)({
                                         .map((s) => s.local.name !== s.imported.name
                                         ? `useRouter as ${s.local.name}`
                                         : 'useRouter')
-                                        .join(', ')} } from 'src/hooks/routing/useRouter';\n`;
+                                        .join(', ')} } from '${ROUTER_MODULE_PATH}';\n`;
                                     const otherImports = `import { ${otherSpecifiers
                                         .map((s) => s.local.name)
                                         .join(', ')} } from 'next/router';`;

package/lib/utils/harvestRuleTesterCases.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Collects every `RuleTester` case the suite declares WITHOUT executing any of
+ * them, by shadowing `run` on the shared tester instances and then loading each
+ * suite for its declarations alone.
+ *
+ * A guard that wants to exercise fixtures rather than documented snippets has no
+ * other way in. `src/tests/*.test.ts` call `RuleTester.run` at module scope, so
+ * importing one normally re-executes it — measured at 2350 tests, 2 minutes and
+ * 48 cross-file side-effect failures, which is why
+ * `recommended-config-fix-closure.test.ts` reads docs fenced blocks instead.
+ * Shadowing `run` before the load turns each of those calls into a declaration
+ * capture, so the cases are collected at the cost of loading the module and
+ * nothing more.
+ *
+ * The fixtures are worth reaching precisely because they are not the docs: a
+ * rule's `valid` list is written to sit on its carve-out boundaries, which is
+ * where a sibling fixer destroys an exemption. Every finding of that class
+ * (#1595-#1599, #1603, #1677-#1682) came from this corpus; the docs corpus
+ * caught none of them.
+ */
+/** A single `ruleTester.run(name, rule, tests)` call, captured but not run. */
+export type HarvestedSuite = {
+    /** The display name the suite passed to `run`. */
+    name: string;
+    /** Which shared tester export declared it, which fixes the parser. */
+    tester: string;
+    /** Basename of the declaring file, so a finding is reproducible by hand. */
+    file: string;
+    /**
+     * The rule object itself. Callers resolve a rule NAME from this by identity
+     * against the plugin's own map rather than from `name`: 100 of the suites
+     * pass a display name that is not a rule name (`requireMemo`,
+     * `prefer-next-dynamic (JSX scenarios)`, `no-hungarian-phone-number-test`),
+     * and name-keyed matching silently drops every one of them.
+     */
+    rule: unknown;
+    valid: readonly unknown[];
+    invalid: readonly unknown[];
+};
+export type HarvestResult = {
+    suites: HarvestedSuite[];
+    /** Files that threw while loading, `basename: message`. */
+    failures: string[];
+    /** Non-vacuity accounting: a silent drop here would fake a clean sweep. */
+    filesLoaded: number;
+    filesSkipped: number;
+};
+export declare function harvestRuleTesterCases(): HarvestResult;