@blumintinc/eslint-plugin-blumint 1.20.107 → 1.20.109

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.107',
+        version: '1.20.109',
     },
     parseOptions: {
         ecmaVersion: 2020,

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,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantUseCallbackWrapper = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 function isHookLikeName(name) {
     return name.startsWith('use');
 }
@@ -100,7 +102,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 +114,59 @@ 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;
+        };
         // 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 +199,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, ...)
@@ -173,7 +223,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 +235,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                 context.report({
                                     node,
                                     messageId: 'redundantWrapper',
-                                    data: { callbackName: sourceCode.getText(unwrappedArg) },
+                                    data: {
+                                        wrapper,
+                                        callbackName: sourceCode.getText(unwrappedArg),
+                                    },
                                 });
                             }
                         }
@@ -214,7 +270,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 +282,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             context.report({
                                                 node,
                                                 messageId: 'redundantWrapper',
-                                                data: { callbackName: sourceCode.getText(callee) },
+                                                data: {
+                                                    wrapper,
+                                                    callbackName: sourceCode.getText(callee),
+                                                },
                                             });
                                         }
                                     }
@@ -272,7 +334,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 +346,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/parallelize-loop-awaits.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parallelizeLoopAwaits = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 // Anchored at the end of the path so multi-part suffixes such as
 // `EventRegistry.integration.test.ts` are recognized while production modules
 // that merely contain the word (`testHelpers.ts`, `latest.ts`, `contest/Thing.ts`)
@@ -291,61 +292,7 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             return false;
         }
         /**
-         * Collects all variables declared INSIDE the loop body, including inside
-         * callbacks written there. These are iteration-local variables: nothing
-         * they hold outlives the iteration that created them.
-         *
-         * The walk crosses nested function boundaries because the write scan that
-         * consults this set crosses them too. A name both declared and assigned
-         * inside a callback (`async () => { let tmp; tmp = 1; }`) publishes nothing
-         * to the enclosing scope, so if the set stopped at the boundary the write
-         * would read as a cross-iteration dependency and silence the loop. (#1724)
-         */
-        function collectLoopLocalVars(body) {
-            const localVars = new Set();
-            function visit(node, isRoot) {
-                // A callback's parameters bind afresh on every invocation, so a write
-                // through one (`async (page) => { page.total = 1 }`) reaches whatever
-                // the caller handed that call rather than state the iterations share.
-                if (!isRoot &&
-                    (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
-                        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                        node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
-                    for (const param of node.params) {
-                        collectBindingNames(param, localVars);
-                    }
-                }
-                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
-                    for (const declarator of node.declarations) {
-                        collectBindingNames(declarator.id, localVars);
-                    }
-                }
-                for (const key in node) {
-                    if (key === 'parent' ||
-                        key === 'range' ||
-                        key === 'loc' ||
-                        key === 'type')
-                        continue;
-                    const child = node[key];
-                    if (child && typeof child === 'object') {
-                        if (Array.isArray(child)) {
-                            for (const item of child) {
-                                if (item && typeof item === 'object' && 'type' in item) {
-                                    visit(item, false);
-                                }
-                            }
-                        }
-                        else if ('type' in child) {
-                            visit(child, false);
-                        }
-                    }
-                }
-            }
-            visit(body, true);
-            return localVars;
-        }
-        /**
-         * Collects the BINDINGS an assignment target writes through, returning
+         * Collects the IDENTIFIERS an assignment target writes through, returning
          * false when the target's root is not a plain binding at all.
          *
          * A member write reaches the object its ROOT names: `box.value = 1` writes
@@ -358,62 +305,93 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
          * A root the analysis cannot name — `this.count += 1` reaches instance
          * state every iteration shares — returns false, and the caller reads that
          * as an outer write. The plugin prefers a missed report to a spurious one.
+         *
+         * The identifier NODE is carried rather than its name, because locality is
+         * a question about scope: two bindings can share a spelling, and only the
+         * node knows which one a given write reaches. (#1725)
          */
-        function collectAssignmentTargetNames(target, names) {
+        function collectAssignmentTargetIdentifiers(target, identifiers) {
             switch (target.type) {
                 case utils_1.AST_NODE_TYPES.Identifier:
-                    names.add(target.name);
+                    identifiers.push(target);
                     return true;
                 case utils_1.AST_NODE_TYPES.MemberExpression:
-                    return collectAssignmentTargetNames(target.object, names);
+                    return collectAssignmentTargetIdentifiers(target.object, identifiers);
                 case utils_1.AST_NODE_TYPES.ChainExpression:
                 case utils_1.AST_NODE_TYPES.TSNonNullExpression:
                 case utils_1.AST_NODE_TYPES.TSAsExpression:
-                    return collectAssignmentTargetNames(target.expression, names);
+                    return collectAssignmentTargetIdentifiers(target.expression, identifiers);
                 case utils_1.AST_NODE_TYPES.ObjectPattern: {
                     let resolved = true;
                     for (const property of target.properties) {
                         const inner = property.type === utils_1.AST_NODE_TYPES.RestElement
                             ? property.argument
                             : property.value;
-                        if (!collectAssignmentTargetNames(inner, names))
+                        if (!collectAssignmentTargetIdentifiers(inner, identifiers)) {
                             resolved = false;
+                        }
                     }
                     return resolved;
                 }
                 case utils_1.AST_NODE_TYPES.ArrayPattern: {
                     let resolved = true;
                     for (const element of target.elements) {
-                        if (element && !collectAssignmentTargetNames(element, names)) {
+                        if (element &&
+                            !collectAssignmentTargetIdentifiers(element, identifiers)) {
                             resolved = false;
                         }
                     }
                     return resolved;
                 }
                 case utils_1.AST_NODE_TYPES.RestElement:
-                    return collectAssignmentTargetNames(target.argument, names);
+                    return collectAssignmentTargetIdentifiers(target.argument, identifiers);
                 case utils_1.AST_NODE_TYPES.AssignmentPattern:
-                    return collectAssignmentTargetNames(target.left, names);
+                    return collectAssignmentTargetIdentifiers(target.left, identifiers);
                 default:
                     return false;
             }
         }
+        /**
+         * Reports whether an identifier resolves to a binding DECLARED inside the
+         * given root node.
+         *
+         * Such a binding is iteration-local: nothing it holds outlives the
+         * iteration that created it, so writing it couples no two iterations.
+         * `async () => { let tmp; tmp = 1; }` publishes nothing to the enclosing
+         * scope, and a callback's parameters bind afresh on every invocation.
+         *
+         * The question is settled by SCOPE rather than by spelling. A flat set of
+         * declared NAMES cannot tell an outer binding from a nested one that merely
+         * reuses the identifier, so a genuine cross-iteration write to `cursor`
+         * would read as local the moment any callback in the loop happened to name
+         * a parameter `cursor`. (#1725)
+         *
+         * An UNRESOLVED name — an implicit global — counts as external, which keeps
+         * the barrier in place for the case the analysis cannot see.
+         */
+        function isDeclaredWithin(identifier, root) {
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
+            if (!variable || variable.defs.length === 0) {
+                return false;
+            }
+            return variable.defs.every((definition) => definition.name.range[0] >= root.range[0] &&
+                definition.name.range[1] <= root.range[1]);
+        }
         /**
          * Detects cross-iteration state patterns that require sequential
          * execution:
          *
-         * 1. Accumulator: a variable declared OUTSIDE the loop body (i.e., not
-         *    in localVars) is ASSIGNED inside the loop body, whether directly or
-         *    from inside a callback the body hands to the awaited call. Examples:
-         *    `total += value`, `cursor = page.nextCursor`, `previousResult =
-         *    result`. This catches running totals, pagination cursors, and chained
-         *    results.
+         * 1. Accumulator: a variable declared OUTSIDE the loop body is ASSIGNED
+         *    inside it, whether directly or from inside a callback the body hands
+         *    to the awaited call. Examples: `total += value`, `cursor =
+         *    page.nextCursor`, `previousResult = result`. This catches running
+         *    totals, pagination cursors, and chained results.
          *
          * 2. Direct cross-await dependency: a variable declared by an await
          *    inside the loop is then read as an argument to another await in the
          *    same loop body. Example: `const a = await f(); const b = await g(a);`.
          */
-        function hasSequentialDependency(body, loopLocalVars) {
+        function hasSequentialDependency(body) {
             // Pattern 1: outer variable is written inside the loop body.
             // Collect every assignment target — the left-hand side of an assignment
             // or compound assignment, and the operand of an increment in a callback.
@@ -421,13 +399,20 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             /**
              * Reports whether an assignment target reaches a binding the iterations
              * share rather than one the iteration creates.
+             *
+             * The body is the locality root, so a binding introduced by the loop's
+             * own HEAD reads as shared. That is the conservative reading and the
+             * correct one for a C-style counter: `for (let i = 0; i < n; i += 1)`
+             * carries `i` forward between iterations, so a body write to it really
+             * does couple them.
              */
             function writesOuterBinding(target) {
-                const names = new Set();
-                if (!collectAssignmentTargetNames(target, names))
+                const identifiers = [];
+                if (!collectAssignmentTargetIdentifiers(target, identifiers)) {
                     return true;
-                for (const name of names) {
-                    if (!loopLocalVars.has(name))
+                }
+                for (const identifier of identifiers) {
+                    if (!isDeclaredWithin(identifier, body))
                         return true;
                 }
                 return false;
@@ -829,8 +814,7 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
                 return null;
             // Exclusion: accumulator / pagination patterns — sequential dependency
             // detected between iterations
-            const loopLocalVars = collectLoopLocalVars(body);
-            if (hasSequentialDependency(body, loopLocalVars))
+            if (hasSequentialDependency(body))
                 return null;
             // Exclusion: the specific await being reported is a rate-limiting call
             const callNames = getCallNames(awaitExpr);

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/package.json

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

package/release-manifest.json

@@ -1,4 +1,48 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "parallelize-loop-awaits",
+        "changeType": "fix",
+        "issues": [
+          1725
+        ],
+        "summary": "resolve write locality by scope, not by name (closes #1725)"
+      }
+    ]
+  },
   {
     "version": "1.20.107",
     "date": "2026-08-05T05:11:58.347Z",