@blumintinc/eslint-plugin-blumint 1.20.108 → 1.20.110

package/README.md

@@ -104,7 +104,7 @@ full closed loop is documented in agora's `.claude/skills/eslint-autonomy/SKILL.
 | [enforce-exported-function-types](docs/rules/enforce-exported-function-types.md)                             | Enforce exporting types for function props and return values                                                                                                                                                                                                                                                                                                                                     | ✅  |    | 🔧 |    |    |
 | [enforce-f-extension-for-entry-points](docs/rules/enforce-f-extension-for-entry-points.md)                   | Enforce .f.ts extension for entry points                                                                                                                                                                                                                                                                                                                                                         | ✅  |    |    |    |    |
 | [enforce-fieldpath-syntax-in-docsetter](docs/rules/enforce-fieldpath-syntax-in-docsetter.md)                 | Enforce the use of Firestore FieldPath syntax when passing documentData into DocSetter. Instead of using nested object syntax, developers should use dot notation for deeply nested fields.                                                                                                                                                                                                      | ✅  |    | 🔧 |    |    |
-| [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)                         | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                | ✅  |    |    |    | 💭 |
+| [enforce-firestore-doc-ref-generic](docs/rules/enforce-firestore-doc-ref-generic.md)                         | Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup                                                                                                                                                                                                                                                                                                | ✅  |    |    |    |    |
 | [enforce-firestore-facade](docs/rules/enforce-firestore-facade.md)                                           | Enforce usage of Firestore facades instead of direct Firestore methods                                                                                                                                                                                                                                                                                                                           | ✅  |    |    |    |    |
 | [enforce-firestore-path-utils](docs/rules/enforce-firestore-path-utils.md)                                   | Enforce usage of utility functions for Firestore paths to ensure type safety, maintainability, and consistent path construction. This prevents errors from manual string concatenation and makes path changes easier to manage.                                                                                                                                                                  | ✅  |    |    |    |    |
 | [enforce-firestore-rules-get-access](docs/rules/enforce-firestore-rules-get-access.md)                       | Ensure Firestore security rules use .get() with a default value instead of direct field access comparisons (e.g., resource.data.fieldX.fieldY != null).                                                                                                                                                                                                                                          | ✅  |    | 🔧 |    |    |

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.108',
+        version: '1.20.110',
     },
     parseOptions: {
         ecmaVersion: 2020,
@@ -339,6 +339,11 @@ module.exports = {
                 '@blumintinc/blumint/prefer-destructuring-no-class': 'error',
                 '@blumintinc/blumint/enforce-render-hits-memoization': 'error',
                 '@blumintinc/blumint/enforce-transform-memoization': 'error',
+                // Off because it demands the opposite spelling from the enabled
+                // prefer-fragment-shorthand, and because the consumer's codebase
+                // still violates it while its sync reverts on any report. The measured
+                // impact and the criterion that graduates it to 'error' are recorded in
+                // docs/rules/prefer-fragment-component.md.
                 '@blumintinc/blumint/prefer-fragment-component': 'off',
                 '@blumintinc/blumint/react-usememo-should-be-component': 'error',
                 '@blumintinc/blumint/no-unnecessary-verb-suffix': 'error',

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -21,7 +21,12 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
         docs: {
             description: 'Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup',
             recommended: 'error',
-            requiresTypeChecking: true,
+            // Every check here is syntactic: generics are read off the AST and named
+            // generics are resolved against declarations in the same file. Declaring
+            // type information would be a false promise twice over — it tells
+            // consumers they need `parserOptions.project`, and it exempts this rule
+            // from guards that skip rules a program-less `Linter` cannot exercise.
+            requiresTypeChecking: false,
         },
         schema: [],
         messages: {

package/lib/rules/enforce-memoize-async.js

@@ -83,6 +83,29 @@ function isInsideMockFactory(node) {
     }
     return false;
 }
+/**
+ * The class a method belongs to, reached through its `ClassBody`.
+ */
+function enclosingClass(node) {
+    const body = node.parent;
+    return body?.type === utils_1.AST_NODE_TYPES.ClassBody ? body.parent : undefined;
+}
+/**
+ * Whether the method's own class is written as an expression — `const C = class
+ * {}`, a class in argument position, a class assigned to a property — rather
+ * than as a declaration.
+ *
+ * Under `experimentalDecorators`, TypeScript accepts a member decorator only
+ * inside a class DECLARATION: the same `@Memoize()` that compiles inside `class
+ * C {}`, `export class C {}` or `export default class {}` is `TS1206:
+ * Decorators are not valid here.` inside a class expression. An emitted
+ * decorator there breaks the consumer's build, so the report stands without a
+ * fix and the author restructures deliberately — hoisting the class to a
+ * declaration makes the decorator legal.
+ */
+function isInsideClassExpression(node) {
+    return enclosingClass(node)?.type === utils_1.AST_NODE_TYPES.ClassExpression;
+}
 /**
  * Whether a declared return type annotation promises no value: `void` or
  * `Promise<void>`.
@@ -351,6 +374,14 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                         if (isInsideMockFactory(node)) {
                             return null;
                         }
+                        // A decorator is legal only on a member of a class declaration, so
+                        // decorating a class expression's method emits code the consumer's
+                        // compiler rejects outright (TS1206). Declining ahead of the import
+                        // carrier claim below leaves the import to a violation that does
+                        // fix.
+                        if (isInsideClassExpression(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         const sourceCode = context.sourceCode;
                         // Determine which identifier to use for the decorator

package/lib/rules/firestore-transaction-reads-before-writes.js

@@ -6,6 +6,85 @@ const createRule_1 = require("../utils/createRule");
 // Define the operations that are considered reads and writes
 const READ_OPERATIONS = new Set(['get']);
 const WRITE_OPERATIONS = new Set(['set', 'update', 'delete']);
+/**
+ * Helpers that validate a property key and hand back that very key, so a call
+ * to one names exactly the method its argument names. `enforce-assert-safe-object-key`
+ * is `error` in the same recommended config and its fixer wraps computed keys in
+ * `assertSafe(...)`, which means this shape is machine-generated from ordinary
+ * `transaction[methodName]` code rather than hand-written.
+ */
+const KEY_ASSERTION_HELPERS = new Set(['assertSafe']);
+/**
+ * Strips wrappers that erase at compile time or resolve to the key itself.
+ * `k as string`, `k satisfies string`, `<string>k` and `k!` emit nothing, and
+ * `await k` yields the same key, so none of them changes which method the
+ * lookup selects.
+ *
+ * The peel repeats because the wrappers nest: `(k as any)!`.
+ */
+function unwrapErasedKey(node) {
+    let current = node;
+    for (;;) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.TSAsExpression:
+            case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                break;
+            case utils_1.AST_NODE_TYPES.AwaitExpression:
+                current = current.argument;
+                break;
+            default:
+                return current;
+        }
+    }
+}
+/** True for `assertSafe(k)` and for a namespaced `utils.assertSafe(k)`. */
+function isKeyAssertionCall(node) {
+    const { callee } = node;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return KEY_ASSERTION_HELPERS.has(callee.name);
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        KEY_ASSERTION_HELPERS.has(callee.property.name));
+}
+/**
+ * Resolves the method a computed access selects: `transaction[<key>]()`.
+ *
+ * A key assertion returns its argument untouched, so reading through one is
+ * information-free — `transaction[assertSafe(k)]` must land on exactly the
+ * verdict `transaction[k]` lands on, definite name and all. Every other call
+ * may return something other than what it was handed, so its argument proves
+ * nothing about the method and the key counts as unresolved. That keeps the
+ * safety net on for any wrapper (`transaction[String(k)]`) while never minting
+ * a definite read/write verdict out of a call whose result is unknown.
+ */
+function resolveComputedKey(property) {
+    let current = unwrapErasedKey(property);
+    for (;;) {
+        if (current.type === utils_1.AST_NODE_TYPES.Literal &&
+            typeof current.value === 'string') {
+            return { kind: 'name', name: current.value };
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return { kind: 'unresolved' };
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const [argument] = current.arguments;
+            if (!isKeyAssertionCall(current) ||
+                current.arguments.length !== 1 ||
+                argument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                return { kind: 'unresolved' };
+            }
+            current = unwrapErasedKey(argument);
+            continue;
+        }
+        return { kind: 'opaque' };
+    }
+}
 exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
     name: 'firestore-transaction-reads-before-writes',
     meta: {
@@ -119,18 +198,19 @@ exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
                 // Normal property access: transaction.get()
                 methodName = property.name;
             }
-            else if (callee.computed &&
-                property.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof property.value === 'string') {
-                // Computed property access with string literal: transaction['get']
-                methodName = property.value;
-            }
-            else if (callee.computed &&
-                property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                // Computed property access with variable: transaction[methodName]
-                // This is tricky to analyze statically. For now, we'll be conservative
-                // and assume it could be any method. We'll handle this in the caller.
-                return { isRead: true, isWrite: true, methodName: null }; // Could be either - let caller decide
+            else if (callee.computed) {
+                // Computed property access: transaction['get'], transaction[methodName],
+                // transaction[assertSafe(methodName)]. A key that survives resolution
+                // as a definite string names the method; one that cannot be resolved
+                // could be any method, so it is answered conservatively and the caller
+                // decides.
+                const resolved = resolveComputedKey(property);
+                if (resolved.kind === 'unresolved') {
+                    return { isRead: true, isWrite: true, methodName: null };
+                }
+                if (resolved.kind === 'name') {
+                    methodName = resolved.name;
+                }
             }
             if (!methodName) {
                 return { isRead: false, isWrite: false, methodName: null };
@@ -154,7 +234,14 @@ exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
                 if (callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return `${objectName}[${callee.property.name}]`;
                 }
-                return `${objectName}[computed]`;
+                // A wrapped key such as assertSafe(methodName) is quoted verbatim so
+                // the message names text that exists in the file and can be searched
+                // for, rather than the resolved key the reader never wrote.
+                const keyText = context
+                    .getSourceCode()
+                    .getText(callee.property)
+                    .replace(/\s+/g, ' ');
+                return `${objectName}[${keyText}]`;
             }
             if (callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return `${objectName}.${callee.property.name}`;

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -3,6 +3,77 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantUseCallbackWrapper = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+const MEMO_HOOK = 'useMemo';
+/**
+ * Type-level wrappers carry no runtime value, so a callback that leaves a
+ * memoizing call through a cast is the same callback. Reading through them keeps
+ * the proof from depending on whether the author spelled an annotation.
+ */
+const TYPE_ONLY_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+    utils_1.AST_NODE_TYPES.TSTypeAssertion,
+    utils_1.AST_NODE_TYPES.TSInstantiationExpression,
+]);
+function unwrapValueExpression(node) {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+        TYPE_ONLY_WRAPPERS.has(current.type)) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * The bare name a callee resolves to, collapsing the namespaced spelling so
+ * `React.useCallback` and `useCallback` answer alike.
+ */
+function calleeNameOf(callee) {
+    const unwrapped = unwrapValueExpression(callee);
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return unwrapped.name;
+    }
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !unwrapped.computed &&
+        unwrapped.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return unwrapped.property.name;
+    }
+    return null;
+}
+function isFunctionLiteral(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+}
+/**
+ * Whether a `useMemo` factory demonstrably yields a function.
+ *
+ * `useMemo` memoizes any value, so its result is a memoized *callback* only when
+ * the factory produces one. Only a factory that hands back a function literal
+ * proves that in-source; a factory returning a call result, a conditional or a
+ * value assembled across several statements might yield anything, and this rule
+ * prefers a false negative to guessing.
+ */
+function producesFunction(factory) {
+    if (!factory || !isFunctionLiteral(factory)) {
+        return false;
+    }
+    const fn = factory;
+    if (fn.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return isFunctionLiteral(unwrapValueExpression(fn.body));
+    }
+    const statements = fn.body.body;
+    if (statements.length !== 1) {
+        return false;
+    }
+    const [only] = statements;
+    if (only.type !== utils_1.AST_NODE_TYPES.ReturnStatement || !only.argument) {
+        return false;
+    }
+    return isFunctionLiteral(unwrapValueExpression(only.argument));
+}
 function isHookLikeName(name) {
     return name.startsWith('use');
 }
@@ -100,7 +171,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            redundantWrapper: 'useCallback is wrapping memoized callback "{{callbackName}}", adding a redundant dependency array without improving stability. Pass the hook/context callback directly so React keeps the original stable reference and avoids wrapper allocations and dependency drift.',
+            // The wrapper is named rather than hardcoded: the rule reports
+            // `useLatestCallback` too, which has no dependency array, so a message
+            // asserting one would describe code the reader cannot find.
+            redundantWrapper: '{{wrapper}} is wrapping memoized callback "{{callbackName}}", adding a redundant memoization layer without improving stability. Pass the hook/context callback directly so React keeps the original stable reference and avoids wrapper allocations and dependency drift.',
         },
     },
     defaultOptions: [{}],
@@ -109,10 +183,116 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
         const knownHooks = new Set(option.memoizedHookNames ?? []);
         const assumeAllUseAreMemoized = option.assumeAllUseAreMemoized === true;
         const sourceCode = context.sourceCode;
+        // Every callee that memoizes the callback handed to it. `useLatestCallback`
+        // belongs here because `use-latest-callback` — 'error' in the same
+        // recommended config, and fixable — rewrites every `useCallback(fn, deps)`
+        // into `useLatestCallback(fn)`. The wrapper it produces is the very
+        // construct this rule objects to, still allocating a fresh arrow around an
+        // already stable callback, so without this entry one `eslint --fix` renames
+        // the violation out of view while leaving it byte-for-byte intact — and the
+        // config mandating that spelling means it is also written by hand (#1726).
+        const wrapperNames = new Set(['useCallback', LATEST_CALLBACK_HOOK]);
+        /**
+         * The wrapper's name if this callee is one, else null. Reading the name
+         * rather than a boolean lets the report say which wrapper it found, since
+         * the local binding need not be spelled `useLatestCallback` at all.
+         */
+        const wrapperNameOf = (callee) => {
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return wrapperNames.has(callee.name) ? callee.name : null;
+            }
+            // Namespaced spelling, e.g. React.useCallback
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return wrapperNames.has(callee.property.name)
+                    ? callee.property.name
+                    : null;
+            }
+            return null;
+        };
+        /**
+         * Whether the binding this identifier resolves to holds a callback whose
+         * memoization is visible in this very file.
+         *
+         * `memoizedHookNames` exists for callbacks whose stability only the consumer
+         * knows about. A `const` initialized from `useCallback`, `useLatestCallback`
+         * or a `useMemo` that yields a function needs no such knowledge: the
+         * memoizing call sits in the same source, so wrapping its result is provably
+         * redundant and the rule reports it under the default options — without
+         * which the rule can report nothing at all in a config that does not set
+         * `memoizedHookNames`.
+         *
+         * The binding is resolved through scope analysis rather than matched by
+         * name, because a name set cannot tell the memoized `inner` of one component
+         * from the `inner` prop of the next, and would report the prop — the wrapper
+         * that is the only thing making it stable.
+         */
+        const isLocallyMemoizedCallback = (identifier, wrapperCall) => {
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
+            if (!variable || variable.defs.length !== 1) {
+                return false;
+            }
+            const declarator = variable.defs[0].node;
+            if (declarator.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !declarator.init) {
+                return false;
+            }
+            // A rebindable declaration breaks the proof: the value read at the wrapper
+            // need not be the one the memoizing call produced.
+            const declaration = declarator.parent;
+            if (declaration?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                declaration.kind !== 'const') {
+                return false;
+            }
+            // A wrapper sitting inside the initializer it reads is self-referential,
+            // and collapsing it would emit `const x = x`.
+            if (wrapperCall.range[0] >= declarator.range[0] &&
+                wrapperCall.range[1] <= declarator.range[1]) {
+                return false;
+            }
+            const init = unwrapValueExpression(declarator.init);
+            if (init.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            const initName = calleeNameOf(init.callee);
+            if (!initName) {
+                return false;
+            }
+            // Every wrapper this rule reports is itself a memoizing call, so the same
+            // set answers both questions: what makes a callback stable, and what
+            // redundantly re-wraps one that already is.
+            if (wrapperNames.has(initName)) {
+                return true;
+            }
+            return initName === MEMO_HOOK && producesFunction(init.arguments[0]);
+        };
         // Track identifiers coming from hook-like calls
         const hookReturnObjects = new Set(); // variables assigned to a hook call result (object or function)
         const hookReturnProps = new Set(); // properties destructured from a hook call result
         return {
+            ImportDeclaration(node) {
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name with `freeImportName`, falling back to `useLatestCallback2` when
+                // `useLatestCallback` is already taken in the file, so the alias is
+                // authored by the sibling fixer rather than being hypothetical.
+                if (node.source.value !== LATEST_CALLBACK_MODULE ||
+                    (node.importKind && node.importKind !== 'value')) {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                        (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.importKind !== 'type' &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                        wrapperNames.add(specifier.local.name);
+                    }
+                }
+            },
             VariableDeclarator(node) {
                 if (!node.init)
                     return;
@@ -145,17 +325,13 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                 }
             },
             CallExpression(node) {
-                // Detect useCallback wrappers (including React.useCallback)
+                // Detect memoization wrappers (including React.useCallback and the
+                // useLatestCallback spelling the config's own fixer produces)
                 const calleeNode = unwrapChainExpression(node.callee);
                 if (!calleeNode)
                     return;
-                const isUseCallback = (calleeNode.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    calleeNode.name === 'useCallback') ||
-                    (calleeNode.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        !calleeNode.computed &&
-                        calleeNode.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        calleeNode.property.name === 'useCallback');
-                if (isUseCallback && node.arguments.length >= 1) {
+                const wrapper = wrapperNameOf(calleeNode);
+                if (wrapper && node.arguments.length >= 1) {
                     const arg = node.arguments[0];
                     const unwrappedArg = unwrapChainExpression(arg);
                     // Case 1: useCallback(memoizedFn, ...) or useCallback(ctx.memoized, ...)
@@ -164,7 +340,8 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                             unwrappedArg.type === utils_1.AST_NODE_TYPES.MemberExpression)) {
                         if ((unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier &&
                             (hookReturnProps.has(unwrappedArg.name) ||
-                                hookReturnObjects.has(unwrappedArg.name))) ||
+                                hookReturnObjects.has(unwrappedArg.name) ||
+                                isLocallyMemoizedCallback(unwrappedArg, node))) ||
                             (unwrappedArg.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                                 unwrappedArg.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                                 hookReturnObjects.has(unwrappedArg.object.name))) {
@@ -173,7 +350,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                 context.report({
                                     node,
                                     messageId: 'redundantWrapper',
-                                    data: { callbackName: sourceCode.getText(unwrappedArg) },
+                                    data: {
+                                        wrapper,
+                                        callbackName: sourceCode.getText(unwrappedArg),
+                                    },
                                     fix: (fixer) => fixer.replaceText(node, replaceText),
                                 });
                             }
@@ -182,7 +362,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                 context.report({
                                     node,
                                     messageId: 'redundantWrapper',
-                                    data: { callbackName: sourceCode.getText(unwrappedArg) },
+                                    data: {
+                                        wrapper,
+                                        callbackName: sourceCode.getText(unwrappedArg),
+                                    },
                                 });
                             }
                         }
@@ -203,7 +386,8 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                     isIdentifierOrMemberOn(callee, hookReturnObjects)) ||
                                     (callee &&
                                         callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                        hookReturnProps.has(callee.name))) {
+                                        (hookReturnProps.has(callee.name) ||
+                                            isLocallyMemoizedCallback(callee, node)))) {
                                     if (bodyExpr.arguments.length > 0) {
                                         // Passing any arguments: treat as non-redundant (avoid false positives)
                                         return;
@@ -214,7 +398,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             context.report({
                                                 node,
                                                 messageId: 'redundantWrapper',
-                                                data: { callbackName: sourceCode.getText(callee) },
+                                                data: {
+                                                    wrapper,
+                                                    callbackName: sourceCode.getText(callee),
+                                                },
                                                 fix: (fixer) => fixer.replaceText(node, replaceText),
                                             });
                                         }
@@ -223,7 +410,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             context.report({
                                                 node,
                                                 messageId: 'redundantWrapper',
-                                                data: { callbackName: sourceCode.getText(callee) },
+                                                data: {
+                                                    wrapper,
+                                                    callbackName: sourceCode.getText(callee),
+                                                },
                                             });
                                         }
                                     }
@@ -254,7 +444,8 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                         const callee = unwrapChainExpression(expr.callee);
                                         const isHookProp = callee &&
                                             callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                            hookReturnProps.has(callee.name);
+                                            (hookReturnProps.has(callee.name) ||
+                                                isLocallyMemoizedCallback(callee, node));
                                         const isHookObjMember = callee &&
                                             callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                                             callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -272,7 +463,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                                     context.report({
                                                         node,
                                                         messageId: 'redundantWrapper',
-                                                        data: { callbackName: sourceCode.getText(callee) },
+                                                        data: {
+                                                            wrapper,
+                                                            callbackName: sourceCode.getText(callee),
+                                                        },
                                                         fix: (fixer) => fixer.replaceText(node, replaceText),
                                                     });
                                                 }
@@ -281,7 +475,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                                     context.report({
                                                         node,
                                                         messageId: 'redundantWrapper',
-                                                        data: { callbackName: sourceCode.getText(callee) },
+                                                        data: {
+                                                            wrapper,
+                                                            callbackName: sourceCode.getText(callee),
+                                                        },
                                                     });
                                                 }
                                             }

package/lib/rules/prefer-fragment-component.js

@@ -111,7 +111,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
         type: 'suggestion',
         docs: {
             description: 'Require the Fragment named import instead of shorthand fragments or React.Fragment to keep fragments explicit and prop-friendly',
-            recommended: 'error',
+            // `RuleMetaDataDocs` admits `false | 'error' | 'strict' | 'warn'` and has
+            // no `'off'` member, so `false` is this field's spelling of the `'off'`
+            // the recommended config ships. See the docs page for why it ships off
+            // and what graduates it to 'error'.
+            recommended: false,
         },
         fixable: 'code',
         schema: [],

package/lib/rules/require-server-timestamp-for-firestore-dates.js

@@ -91,20 +91,60 @@ function typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeName
     const names = collectTypeReferenceNames(typeAnnotation);
     return names.some((n) => firestoreTypeNames.has(n));
 }
+/**
+ * True for the assertion wrappers that leave the underlying expression intact:
+ * `x as T` and `x satisfies T`.
+ */
+function isCastExpression(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        node.type ===
+            utils_1.AST_NODE_TYPES
+                .TSSatisfiesExpression);
+}
 /**
  * Returns the inner expression, unwrapping TSAsExpression / TSSatisfiesExpression
  * chains, so we can inspect what lies under a cast.
  */
 function unwrapCast(node) {
     let current = node;
-    while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-        current.type ===
-            utils_1.AST_NODE_TYPES
-                .TSSatisfiesExpression) {
+    while (isCastExpression(current)) {
         current = current.expression;
     }
     return current;
 }
+/**
+ * True when some `as` cast in the wrapper chain targets a Firestore type. Those
+ * casts are the TSAsExpression visitor's own entry point, so the annotation- and
+ * return-type-driven visitors must stand down on them or the same `new Date()`
+ * is reported twice.
+ */
+function castChainTargetsFirestoreType(node, firestoreTypeNames) {
+    let current = node;
+    while (isCastExpression(current)) {
+        const cast = current;
+        if (cast.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+            typeAnnotationReferencesFirestoreType(cast.typeAnnotation, firestoreTypeNames)) {
+            return true;
+        }
+        current = cast.expression;
+    }
+    return false;
+}
+/**
+ * Resolves an expression in a Firestore-typed position to the object literal it
+ * ultimately denotes, seeing through `as const` and other assertion wrappers.
+ * A wrapper is a syntactic no-op — `{ createdAt: new Date() } as const` still
+ * stamps the document with the client clock — so it must not hide the object.
+ * Returns null when the chain is already owned by the TSAsExpression visitor.
+ */
+function resolveObjectLiteral(node, firestoreTypeNames) {
+    if (!node)
+        return null;
+    if (castChainTargetsFirestoreType(node, firestoreTypeNames))
+        return null;
+    const inner = unwrapCast(node);
+    return inner.type === utils_1.AST_NODE_TYPES.ObjectExpression ? inner : null;
+}
 /**
  * Checks whether an expression is `new Date(...)` (possibly wrapped in casts).
  */
@@ -343,19 +383,22 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
             VariableDeclarator(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                // Pattern: const x: FirestoreType = { ... }
+                // Pattern: const x: FirestoreType = { ... }, including when the literal
+                // is wrapped in `as const` or another assertion.
                 const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
-                if (typeAnnotation &&
-                    typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeNames) &&
-                    node.init &&
-                    node.init.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    // Exempt local render seeds handed to React state, never written to
-                    // Firestore — being typed as a Firestore doc is not a write.
-                    if (context.getDeclaredVariables(node).some(isLocalRenderSeedVariable)) {
-                        return;
-                    }
-                    reportNewDatesInObject(node.init, context);
+                if (!typeAnnotation ||
+                    !typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeNames)) {
+                    return;
                 }
+                const object = resolveObjectLiteral(node.init, firestoreTypeNames);
+                if (!object)
+                    return;
+                // Exempt local render seeds handed to React state, never written to
+                // Firestore — being typed as a Firestore doc is not a write.
+                if (context.getDeclaredVariables(node).some(isLocalRenderSeedVariable)) {
+                    return;
+                }
+                reportNewDatesInObject(object, context);
             },
             // Pattern: { ... } as FirestoreType  or  { ... } satisfies FirestoreType
             TSAsExpression(node) {
@@ -384,21 +427,24 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
             ArrowFunctionExpression(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                if (node.body.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement)
                     return;
                 const returnType = node.returnType?.typeAnnotation;
-                if (returnType &&
-                    typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
-                    reportNewDatesInObject(node.body, context);
+                if (!returnType ||
+                    !typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
+                    return;
+                }
+                const object = resolveObjectLiteral(node.body, firestoreTypeNames);
+                if (object) {
+                    reportNewDatesInObject(object, context);
                 }
             },
             // Return statements in functions with explicit Firestore return type annotation
             ReturnStatement(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                if (!node.argument)
-                    return;
-                if (node.argument.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                const object = resolveObjectLiteral(node.argument, firestoreTypeNames);
+                if (!object)
                     return;
                 // Walk up to find the enclosing function and check its return type
                 let ancestor = node.parent;
@@ -409,7 +455,7 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
                         const returnType = ancestor.returnType?.typeAnnotation;
                         if (returnType &&
                             typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
-                            reportNewDatesInObject(node.argument, context);
+                            reportNewDatesInObject(object, context);
                         }
                         break;
                     }

package/lib/utils/fixtureCorpus.d.ts

@@ -0,0 +1,147 @@
+import { Linter } from 'eslint';
+import { HarvestResult } from './harvestRuleTesterCases';
+/**
+ * The one harvest a module registry gets.
+ *
+ * A second `harvestRuleTesterCases()` call in the same registry returns ZERO
+ * suites: the suite files are already in the require cache, so requiring them
+ * again re-executes nothing and their `run` calls never fire, while
+ * `filesLoaded` still counts every file. A guard that harvests twice therefore
+ * runs its second corpus over nothing and reports a clean sweep. Every consumer
+ * — including one that wants both the raw suites and the adapted corpus below —
+ * goes through this.
+ */
+export declare function harvestOnce(): HarvestResult;
+/**
+ * Which array a snippet came out of. A fixer must converge, type-check and
+ * resolve its references identically whichever it is, so the bucket is carried
+ * for reporting rather than for filtering — except that an `output` is by
+ * construction an ALREADY-FIXED state, which makes it the cheapest available
+ * probe of "does the fixer fire again on its own result".
+ */
+export type FixtureBucket = 'valid' | 'invalid' | 'output';
+export type FixtureCase = {
+    code: string;
+    /** Only when the case declares one; a guard supplies its own default. */
+    filename?: string;
+    options?: readonly unknown[];
+    parserOptions?: Record<string, unknown>;
+    /** Which shared tester declared it, which fixes the parser. */
+    tester: string;
+    /** Declaring suite file, so a finding is reproducible by hand. */
+    origin: string;
+    bucket: FixtureBucket;
+};
+export type FixtureCorpus = {
+    byRule: Map<string, FixtureCase[]>;
+    /** Suites whose rule object is not in the plugin's map, `file::name`. */
+    suitesDropped: string[];
+    /** Suites skipped for declaring under a non-TypeScript tester. */
+    suitesNonTs: string[];
+    suitesUsed: number;
+    totalCases: number;
+    /** Non-vacuity accounting: a silent drop here would fake a clean sweep. */
+    filesLoaded: number;
+    failures: string[];
+};
+/**
+ * `ruleTesterJson` and `ruleTesterMarkdown` parse a different language, so their
+ * fixtures cannot be linted by the TypeScript parser these guards configure.
+ */
+export declare const TS_TESTERS: Set<string>;
+/**
+ * Rules that ask the checker a question. Under a bare `Linter` they have no
+ * program, so they report nothing and would manufacture a false clean rather
+ * than a finding — a guard therefore has to be able to say so out loud when one
+ * of them contributes no probe, instead of filing it under "no trigger".
+ *
+ * Read from the rule sources rather than `String(rule.create)`, since
+ * `createRule` wraps `create` and stringifying it matches nothing.
+ */
+export declare const typeAwareRuleNames: Set<string>;
+/**
+ * Rule name resolved by OBJECT IDENTITY, never by the display name `run`
+ * received: ~100 of the ~310 suites pass a name that is not a rule name
+ * (`requireMemo`, `prefer-next-dynamic (JSX scenarios)`), and name-keyed
+ * matching silently drops every case they declare. Identity holds because the
+ * suites and `../index` resolve to the same module instance under jest.
+ */
+export declare const ruleNameByIdentity: Map<unknown, string>;
+/**
+ * The filename a case is probed under when it declares none.
+ *
+ * `RuleTester` passes `undefined` in that situation, which ESLint renders as
+ * `<input>` — a name with no extension, under which every path-gated rule is
+ * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
+ * departure that keeps those rules reachable, and it matches the extension the
+ * fixture's own tester implies.
+ */
+export declare const defaultFilenameFor: (testCase: FixtureCase) => string;
+/**
+ * Second-chance filenames, used ONLY for a rule that produced no probe at all
+ * under the authentic one.
+ *
+ * Probing every case under every one of these is what the text-harvest guards
+ * did, and it is 3.5x the work for zero extra rules covered (measured: 8,433
+ * fix pairs over 81 rules with the fan-out, 2,652 over the same 81 without).
+ * Spending that budget on the pairs a cap would otherwise drop is worth more
+ * than re-probing the same snippet under a path its author never wrote — but a
+ * rule that would otherwise be UNPROBED is the one case where the fan-out buys
+ * something, so it is kept for exactly that.
+ */
+export declare const FALLBACK_FILENAMES: string[];
+/**
+ * The parser options a case is probed under: the harness's own, overridden by
+ * whatever the fixture declared, with `jsx` merged rather than replaced so a
+ * case that declares an unrelated `ecmaFeatures` does not silently turn JSX
+ * parsing off for itself.
+ */
+export declare const parserOptionsFor: (testCase: FixtureCase) => {
+    ecmaFeatures: {
+        jsx: boolean;
+    };
+    ecmaVersion: number;
+    sourceType: string;
+};
+/**
+ * Rules that offer suggestions. `--fix` never applies one, so a guard driving
+ * `verifyAndFix` (or reading a fixture's `output`) probes the fix channel
+ * exclusively and every transform these rules emit stays unexamined (#1733).
+ */
+export declare const suggestionRuleNames: string[];
+export type SuggestionEdit = {
+    /** Stable identity within one lint of one source, `<report>:<suggestion>`. */
+    slot: string;
+    /** Which rule offered it, so a multi-rule lint still names the culprit. */
+    ruleId: string;
+    messageId: string;
+    desc: string;
+    /** The source with THIS suggestion applied, and nothing else. */
+    output: string;
+};
+/**
+ * Every state a user can reach by accepting ONE suggestion from `messages`.
+ *
+ * Three semantics are load-bearing, and each is a way the probe would otherwise
+ * judge a suggestion against a state nobody can produce:
+ *   - ALONE. Each edit lands on the untouched source. Accepting two suggestions
+ *     from one report is not reachable — the first rewrite invalidates the
+ *     second's ranges — and neither is feeding the result back through a fix
+ *     loop, which is what `verifyAndFix` would do.
+ *   - ONE STEP. The output is a single accepted suggestion, not a fixed point.
+ *     A suggestion is an offer, so the contract is progress, not closure.
+ *   - A `fix()` returning `null` is a DECLINE, not a defect. ESLint drops those
+ *     silently before the message is built, so they never arrive here; an edit
+ *     that changes nothing is discarded for the same reason.
+ */
+export declare function suggestionEditsOf(code: string, messages: readonly Linter.LintMessage[], 
+/** Restricts to one rule; omitted, every reporting rule contributes. */
+ruleId?: string): SuggestionEdit[];
+/** A case's options must reach the FIX pass, or the finding is a fabrication. */
+export declare const severityWithOptions: (testCase: FixtureCase) => "error" | unknown[];
+/**
+ * Harvested once per process. Loading ~270 suites is the dominant cost of every
+ * consumer, and a second call would pay it again for a corpus that cannot have
+ * changed.
+ */
+export declare function harvestFixtureCorpus(): FixtureCorpus;

package/lib/utils/fixtureCorpus.js

@@ -0,0 +1,311 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.harvestFixtureCorpus = exports.severityWithOptions = exports.suggestionEditsOf = exports.suggestionRuleNames = exports.parserOptionsFor = exports.FALLBACK_FILENAMES = exports.defaultFilenameFor = exports.ruleNameByIdentity = exports.typeAwareRuleNames = exports.TS_TESTERS = exports.harvestOnce = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const harvestRuleTesterCases_1 = require("./harvestRuleTesterCases");
+/**
+ * The fixture corpus every fixer guard probes, keyed by RULE NAME.
+ *
+ * The guards used to build this by text-parsing `src/tests/<rule>.test.ts` and
+ * keeping the static string literals, which loses two things at once. A case
+ * assembled by interpolation is invisible — `no-usememo-for-pass-by-value`
+ * prepends a shared `typedPrelude` to all 64 of its cases and yielded exactly
+ * ONE snippet — and a snippet that does survive arrives stripped of the
+ * `filename` and `options` it was written for, so it is probed under a
+ * configuration its author never wrote (#1732).
+ *
+ * `harvestRuleTesterCases` loads each suite with `run` shadowed, so the real
+ * case objects are captured: interpolated code, options, filename and
+ * parserOptions together. This module is the adapter between that raw capture
+ * and what a `Linter`-based guard needs.
+ */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const plugin = require('../index');
+/* eslint-enable @typescript-eslint/no-var-requires */
+const RULES_DIR = path_1.default.join(__dirname, '..', 'rules');
+let rawHarvest = null;
+/**
+ * The one harvest a module registry gets.
+ *
+ * A second `harvestRuleTesterCases()` call in the same registry returns ZERO
+ * suites: the suite files are already in the require cache, so requiring them
+ * again re-executes nothing and their `run` calls never fire, while
+ * `filesLoaded` still counts every file. A guard that harvests twice therefore
+ * runs its second corpus over nothing and reports a clean sweep. Every consumer
+ * — including one that wants both the raw suites and the adapted corpus below —
+ * goes through this.
+ */
+function harvestOnce() {
+    if (!rawHarvest)
+        rawHarvest = (0, harvestRuleTesterCases_1.harvestRuleTesterCases)();
+    return rawHarvest;
+}
+exports.harvestOnce = harvestOnce;
+/**
+ * `ruleTesterJson` and `ruleTesterMarkdown` parse a different language, so their
+ * fixtures cannot be linted by the TypeScript parser these guards configure.
+ */
+exports.TS_TESTERS = new Set(['ruleTesterTs', 'ruleTesterJsx']);
+/**
+ * Parser options that build a TypeScript PROGRAM. A guard driving a bare
+ * `Linter` has none, and honouring these would make it spend seconds per case
+ * constructing one from the repo's own tsconfig — or throw, since a fixture's
+ * relative `project` is resolved against whatever cwd the runner happens to
+ * have. Stripped rather than dropped: the snippet still exercises every
+ * syntactic path of the rule.
+ */
+const PROGRAM_OPTIONS = new Set([
+    'project',
+    'projectService',
+    'programs',
+    'tsconfigRootDir',
+    'EXPERIMENTAL_useProjectService',
+]);
+const withoutProgramOptions = (raw) => {
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (PROGRAM_OPTIONS.has(key))
+            continue;
+        out[key] = value;
+    }
+    return Object.keys(out).length ? out : undefined;
+};
+/**
+ * Rules that ask the checker a question. Under a bare `Linter` they have no
+ * program, so they report nothing and would manufacture a false clean rather
+ * than a finding — a guard therefore has to be able to say so out loud when one
+ * of them contributes no probe, instead of filing it under "no trigger".
+ *
+ * Read from the rule sources rather than `String(rule.create)`, since
+ * `createRule` wraps `create` and stringifying it matches nothing.
+ */
+exports.typeAwareRuleNames = new Set(fs_1.default
+    .readdirSync(RULES_DIR)
+    .filter((file) => file.endsWith('.ts'))
+    .filter((file) => /getParserServices|getTypeChecker/.test(fs_1.default.readFileSync(path_1.default.join(RULES_DIR, file), 'utf8')))
+    .map((file) => path_1.default.basename(file, '.ts')));
+/**
+ * Rule name resolved by OBJECT IDENTITY, never by the display name `run`
+ * received: ~100 of the ~310 suites pass a name that is not a rule name
+ * (`requireMemo`, `prefer-next-dynamic (JSX scenarios)`), and name-keyed
+ * matching silently drops every case they declare. Identity holds because the
+ * suites and `../index` resolve to the same module instance under jest.
+ */
+exports.ruleNameByIdentity = new Map(Object.entries(plugin.rules).map(([name, rule]) => [rule, name]));
+/**
+ * The filename a case is probed under when it declares none.
+ *
+ * `RuleTester` passes `undefined` in that situation, which ESLint renders as
+ * `<input>` — a name with no extension, under which every path-gated rule is
+ * silent and contributes nothing. A bare `file.ts`/`react.tsx` is the smallest
+ * departure that keeps those rules reachable, and it matches the extension the
+ * fixture's own tester implies.
+ */
+const defaultFilenameFor = (testCase) => testCase.filename ??
+    (testCase.tester === 'ruleTesterJsx' ? 'react.tsx' : 'file.ts');
+exports.defaultFilenameFor = defaultFilenameFor;
+/**
+ * Second-chance filenames, used ONLY for a rule that produced no probe at all
+ * under the authentic one.
+ *
+ * Probing every case under every one of these is what the text-harvest guards
+ * did, and it is 3.5x the work for zero extra rules covered (measured: 8,433
+ * fix pairs over 81 rules with the fan-out, 2,652 over the same 81 without).
+ * Spending that budget on the pairs a cap would otherwise drop is worth more
+ * than re-probing the same snippet under a path its author never wrote — but a
+ * rule that would otherwise be UNPROBED is the one case where the fan-out buys
+ * something, so it is kept for exactly that.
+ */
+exports.FALLBACK_FILENAMES = [
+    '/repo/src/components/Widget.tsx',
+    '/repo/src/util/helper.ts',
+    '/repo/src/util/helper.test.ts',
+    '/repo/src/__tests__/helper.test.ts',
+    '/repo/functions/src/util/helper.test.ts',
+    '/repo/functions/src/callable/handler.ts',
+    '/repo/src/pages/index.tsx',
+];
+/**
+ * The parser options a case is probed under: the harness's own, overridden by
+ * whatever the fixture declared, with `jsx` merged rather than replaced so a
+ * case that declares an unrelated `ecmaFeatures` does not silently turn JSX
+ * parsing off for itself.
+ */
+const parserOptionsFor = (testCase) => {
+    const declared = testCase.parserOptions || {};
+    const features = (declared.ecmaFeatures || {});
+    return {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+        ...declared,
+        ecmaFeatures: { jsx: true, ...features },
+    };
+};
+exports.parserOptionsFor = parserOptionsFor;
+/**
+ * Rules that offer suggestions. `--fix` never applies one, so a guard driving
+ * `verifyAndFix` (or reading a fixture's `output`) probes the fix channel
+ * exclusively and every transform these rules emit stays unexamined (#1733).
+ */
+exports.suggestionRuleNames = Object.entries(plugin.rules)
+    .filter(([, rule]) => rule?.meta?.hasSuggestions)
+    .map(([name]) => name)
+    .sort();
+const applyEdit = (text, fix) => text.slice(0, fix.range[0]) + fix.text + text.slice(fix.range[1]);
+/**
+ * Every state a user can reach by accepting ONE suggestion from `messages`.
+ *
+ * Three semantics are load-bearing, and each is a way the probe would otherwise
+ * judge a suggestion against a state nobody can produce:
+ *   - ALONE. Each edit lands on the untouched source. Accepting two suggestions
+ *     from one report is not reachable — the first rewrite invalidates the
+ *     second's ranges — and neither is feeding the result back through a fix
+ *     loop, which is what `verifyAndFix` would do.
+ *   - ONE STEP. The output is a single accepted suggestion, not a fixed point.
+ *     A suggestion is an offer, so the contract is progress, not closure.
+ *   - A `fix()` returning `null` is a DECLINE, not a defect. ESLint drops those
+ *     silently before the message is built, so they never arrive here; an edit
+ *     that changes nothing is discarded for the same reason.
+ */
+function suggestionEditsOf(code, messages, 
+/** Restricts to one rule; omitted, every reporting rule contributes. */
+ruleId) {
+    const edits = [];
+    messages.forEach((message, messageIndex) => {
+        if (ruleId && message.ruleId !== ruleId)
+            return;
+        (message.suggestions || []).forEach((suggestion, suggestionIndex) => {
+            if (!suggestion.fix)
+                return;
+            const output = applyEdit(code, suggestion.fix);
+            if (output === code)
+                return;
+            edits.push({
+                slot: `${messageIndex}:${suggestionIndex}`,
+                ruleId: message.ruleId || '',
+                messageId: message.messageId || message.message,
+                desc: suggestion.desc,
+                output,
+            });
+        });
+    });
+    return edits;
+}
+exports.suggestionEditsOf = suggestionEditsOf;
+/** A case's options must reach the FIX pass, or the finding is a fabrication. */
+const severityWithOptions = (testCase) => testCase.options && testCase.options.length
+    ? ['error', ...testCase.options]
+    : 'error';
+exports.severityWithOptions = severityWithOptions;
+/** Already-fixed states a case declares: its `output`, and each suggestion's. */
+const outputsOf = (testCase) => {
+    const outputs = [];
+    if (typeof testCase.output === 'string')
+        outputs.push(testCase.output);
+    if (!Array.isArray(testCase.errors))
+        return outputs;
+    for (const error of testCase.errors) {
+        const suggestions = error?.suggestions;
+        if (!Array.isArray(suggestions))
+            continue;
+        for (const suggestion of suggestions) {
+            const output = suggestion?.output;
+            if (typeof output === 'string')
+                outputs.push(output);
+        }
+    }
+    return outputs;
+};
+let cached = null;
+/**
+ * Harvested once per process. Loading ~270 suites is the dominant cost of every
+ * consumer, and a second call would pay it again for a corpus that cannot have
+ * changed.
+ */
+function harvestFixtureCorpus() {
+    if (cached)
+        return cached;
+    const harvested = harvestOnce();
+    const byRule = new Map();
+    const suitesDropped = [];
+    const suitesNonTs = [];
+    let suitesUsed = 0;
+    let totalCases = 0;
+    for (const suite of harvested.suites) {
+        const name = exports.ruleNameByIdentity.get(suite.rule);
+        if (!name) {
+            suitesDropped.push(`${suite.file}::${suite.name}`);
+            continue;
+        }
+        if (!exports.TS_TESTERS.has(suite.tester)) {
+            suitesNonTs.push(`${suite.file}::${suite.name}`);
+            continue;
+        }
+        suitesUsed++;
+        const cases = byRule.get(name) || [];
+        /**
+         * Deduped on the whole configuration, not on the code: the same snippet
+         * probed under different options is a different probe, and several suites
+         * declare exactly that pair to pin an option's effect.
+         */
+        const keyOf = (testCase) => JSON.stringify([
+            testCase.code,
+            testCase.options,
+            testCase.filename,
+            testCase.parserOptions,
+        ]);
+        const seen = new Set(cases.map(keyOf));
+        const push = (code, raw, bucket, parserOptions) => {
+            const testCase = {
+                code,
+                filename: typeof raw.filename === 'string' ? raw.filename : undefined,
+                options: Array.isArray(raw.options)
+                    ? raw.options
+                    : undefined,
+                parserOptions,
+                tester: suite.tester,
+                origin: suite.file,
+                bucket,
+            };
+            const key = keyOf(testCase);
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            cases.push(testCase);
+            totalCases++;
+        };
+        const collect = (raw, bucket) => {
+            const declared = (typeof raw === 'string' ? { code: raw } : raw);
+            if (!declared || typeof declared.code !== 'string')
+                return;
+            const parserOptions = withoutProgramOptions(declared.parserOptions);
+            push(declared.code, declared, bucket, parserOptions);
+            for (const output of outputsOf(declared)) {
+                push(output, declared, 'output', parserOptions);
+            }
+        };
+        for (const raw of suite.valid)
+            collect(raw, 'valid');
+        for (const raw of suite.invalid)
+            collect(raw, 'invalid');
+        byRule.set(name, cases);
+    }
+    cached = {
+        byRule,
+        suitesDropped,
+        suitesNonTs,
+        suitesUsed,
+        totalCases,
+        filesLoaded: harvested.filesLoaded,
+        failures: harvested.failures,
+    };
+    return cached;
+}
+exports.harvestFixtureCorpus = harvestFixtureCorpus;
+//# sourceMappingURL=fixtureCorpus.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.108",
+  "version": "1.20.110",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

@@ -1,4 +1,72 @@
 [
+  {
+    "version": "1.20.110",
+    "date": "2026-08-05T11:59:59.800Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-doc-ref-generic",
+        "changeType": "fix",
+        "issues": [
+          1730
+        ],
+        "summary": "drop the unearned requiresTypeChecking declaration (closes #1730)"
+      },
+      {
+        "name": "enforce-memoize-async",
+        "changeType": "fix",
+        "issues": [
+          1735
+        ],
+        "summary": "decline to decorate a method of a class expression (closes #1735)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1729
+        ],
+        "summary": "report provably memoized wrappers under default options (closes #1729)"
+      },
+      {
+        "name": "prefer-fragment-component",
+        "changeType": "fix",
+        "issues": [
+          1736
+        ],
+        "summary": "declare the disabled severity it actually ships (closes #1736)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.109",
+    "date": "2026-08-05T07:42:30.150Z",
+    "rules": [
+      {
+        "name": "firestore-transaction-reads-before-writes",
+        "changeType": "fix",
+        "issues": [
+          1728
+        ],
+        "summary": "resolve a call-wrapped computed key (closes #1728)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1726
+        ],
+        "summary": "see the useLatestCallback spelling (closes #1726)"
+      },
+      {
+        "name": "require-server-timestamp-for-firestore-dates",
+        "changeType": "fix",
+        "issues": [
+          1727
+        ],
+        "summary": "look through cast wrappers (closes #1727)"
+      }
+    ]
+  },
   {
     "version": "1.20.108",
     "date": "2026-08-05T05:55:32.346Z",