@blumintinc/eslint-plugin-blumint 1.20.122 → 1.20.124

package/lib/index.js

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

package/lib/rules/enforce-console-error.js

@@ -41,6 +41,45 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                 node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                 node.callee.property.name === method);
         }
+        /**
+         * A type assertion carries no runtime behaviour, so `'error' as const`,
+         * `'error' satisfies Severity`, `<const>'error'` and `'error'!` all evaluate
+         * to exactly the string their inner expression evaluates to. Reading through
+         * the wrapper keeps a severity that is pinned at compile time out of the
+         * `dynamic` bucket, whose report demands both console methods and asserts
+         * the severity may render either dialog. The wrappers nest, so unwrap until
+         * a non-assertion node is reached.
+         */
+        function unwrapTypeAssertions(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+                current = current.expression;
+            }
+            return current;
+        }
+        /**
+         * Reads a severity that is fixed at compile time, or null when the value can
+         * only be known at runtime. A template with no substitutions denotes a
+         * single constant string exactly as a quoted literal does; only an
+         * INTERPOLATED template is genuinely dynamic.
+         */
+        function getStaticSeverityValue(node) {
+            const value = unwrapTypeAssertions(node);
+            if (value.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof value.value === 'string') {
+                return value.value;
+            }
+            if (value.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                value.expressions.length === 0 &&
+                value.quasis.length === 1 &&
+                typeof value.quasis[0].value.cooked === 'string') {
+                return value.quasis[0].value.cooked;
+            }
+            return null;
+        }
         function getSeverityFromObjectExpression(node) {
             for (const prop of node.properties) {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
@@ -57,11 +96,11 @@ exports.enforceConsoleError = (0, createRule_1.createRule)({
                         isSeverityProperty = true;
                     }
                     if (isSeverityProperty) {
-                        if (prop.value.type === utils_1.AST_NODE_TYPES.Literal &&
-                            typeof prop.value.value === 'string') {
-                            return prop.value.value;
+                        const staticSeverity = getStaticSeverityValue(prop.value);
+                        if (staticSeverity !== null) {
+                            return staticSeverity;
                         }
-                        // If severity is not a literal, treat as dynamic
+                        // A severity only known at runtime forces the stricter dynamic path
                         return 'dynamic';
                     }
                 }

package/lib/rules/enforce-mock-firestore.js

@@ -8,6 +8,77 @@ const FIRESTORE_PATHS = [
     'firebase-admin',
     'firebase-admin/firestore',
 ];
+/**
+ * `x as T`, `<T>x`, `x satisfies T` and `x!` assert a type without contributing
+ * a value of their own, so a check that classifies the *shape* of an expression
+ * must look through all four alike.
+ *
+ * This matters beyond hand-written code: sibling rules' autofixes append
+ * ` as const` to the very objects this rule inspects
+ * (`enforce-object-literal-as-const` rewrites
+ * `jest.mock(path, () => { return ({ db }); })` into
+ * `jest.mock(path, () => { return ({ db } as const); })`). A bare
+ * `node.type === ObjectExpression` test taken on the wrapper therefore goes
+ * silent on code `eslint --fix` had just reported (Issue #1806).
+ */
+const ASSERTION_EXPRESSION_TYPES = 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,
+]);
+const isAssertionExpression = (node) => ASSERTION_EXPRESSION_TYPES.has(node.type);
+/**
+ * Peels every assertion wrapper off an expression, so `{ db } as const`,
+ * `<const>{ db }` and chains such as `{ db } as const satisfies Module` all
+ * classify as the object literal they wrap.
+ */
+const unwrapAssertions = (node) => {
+    let target = node;
+    while (isAssertionExpression(target)) {
+        target = target.expression;
+    }
+    return target;
+};
+/**
+ * A `jest.mock` factory produces the same module shape whether it is written as
+ * a concise arrow, a block-bodied arrow, or a `function` expression. Matching
+ * the factory argument itself would only ever see the concise arrow, letting an
+ * identical mock evade the rule on a body-form choice alone. Resolving to the
+ * produced object keeps every spelling on one matching path.
+ *
+ * Assertions are peeled at both ends — off the factory and off the expression
+ * it produces — so every body form is covered by one unwrap rather than only
+ * the spelling a bug report happened to quote.
+ *
+ * A body with more than a lone `return` is deliberately unresolved: the object
+ * reaching the caller can no longer be read off a single expression.
+ */
+const resolveFactoryReturn = (factory) => {
+    if (!factory) {
+        return undefined;
+    }
+    const callable = unwrapAssertions(factory);
+    if (callable.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        callable.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return undefined;
+    }
+    // A concise arrow body is the produced expression itself. Parentheses around
+    // an object body are not part of the AST, so the node is matched directly.
+    if (callable.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return unwrapAssertions(callable.body);
+    }
+    const statements = callable.body.body;
+    if (statements.length !== 1) {
+        return undefined;
+    }
+    const [statement] = statements;
+    if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement ||
+        !statement.argument) {
+        return undefined;
+    }
+    return unwrapAssertions(statement.argument);
+};
 exports.enforceFirestoreMock = (0, createRule_1.createRule)({
     name: 'enforce-mock-firestore',
     meta: {
@@ -27,37 +98,51 @@ exports.enforceFirestoreMock = (0, createRule_1.createRule)({
         return {
             // Detect jest.mock() calls for firebaseAdmin
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.object.name === 'jest' &&
-                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.property.name === 'mock' &&
-                    node.arguments.length > 0 &&
-                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.arguments[0].value === 'string' &&
-                    FIRESTORE_PATHS.some((path) => node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                        typeof node.arguments[0].value === 'string' &&
-                        node.arguments[0].value?.includes(path))) {
-                    // Check if the mock includes Firestore-related properties
-                    const mockFn = node.arguments[1];
-                    if (mockFn &&
-                        mockFn.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                        const returnStmt = mockFn.body;
-                        if (returnStmt.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                            returnStmt.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
-                                prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                (prop.key.name === 'db' ||
-                                    prop.key.name === 'firestore' ||
-                                    prop.key.name === 'getFirestore'))) {
-                            context.report({
-                                node,
-                                messageId: 'noManualFirestoreMock',
-                            });
-                        }
-                    }
+                // `(jest.mock as any)(...)` and `jest!.mock(...)` call the same
+                // function, so the callee and its object are read through assertions
+                // too. The property name cannot carry one: an assertion there requires
+                // computed access, a spelling this rule does not resolve at all.
+                const callee = unwrapAssertions(node.callee);
+                if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                    return;
+                }
+                const calleeObject = unwrapAssertions(callee.object);
+                if (calleeObject.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    calleeObject.name !== 'jest' ||
+                    callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    callee.property.name !== 'mock' ||
+                    node.arguments.length === 0) {
+                    return;
+                }
+                const modulePath = unwrapAssertions(node.arguments[0]);
+                if (modulePath.type !== utils_1.AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                const mockedPath = modulePath.value;
+                if (typeof mockedPath !== 'string' ||
+                    !FIRESTORE_PATHS.some((path) => mockedPath.includes(path))) {
+                    return;
+                }
+                // Check if the mock includes Firestore-related properties
+                const mockedModule = resolveFactoryReturn(node.arguments[1]);
+                if (mockedModule &&
+                    mockedModule.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    mockedModule.properties.some((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                        prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (prop.key.name === 'db' ||
+                            prop.key.name === 'firestore' ||
+                            prop.key.name === 'getFirestore'))) {
+                    context.report({
+                        node,
+                        messageId: 'noManualFirestoreMock',
+                    });
                 }
             },
-            // Detect imports of mockFirebase
+            // Detect imports of mockFirebase.
+            //
+            // No unwrapping applies here: the grammar admits only a bare string
+            // literal as an import source and only a bare identifier as an imported
+            // name, so neither position can carry an assertion for a fixer to add.
             ImportDeclaration(node) {
                 if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
                     node.source.value === 'firestore-jest-mock' &&

package/lib/rules/enforce-querykey-ts.js

@@ -477,6 +477,36 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * The key's value when it is knowable without running the program, paired
+         * with the node that spells it.
+         *
+         * The substituted `QUERY_KEY_*` name is derived from that value, so what a
+         * fix needs is the value — not the notation carrying it. Gating on the node
+         * type instead left a static template reported exactly like the quoted
+         * string it renders to but with no fix behind the report (#1803). Every
+         * genuinely underivable shape — concatenation, a ternary, a template WITH
+         * expressions — holds no single value and falls out here on its own, so the
+         * conservative carve-out survives without being keyed to notation.
+         *
+         * Read through `cooked` rather than `raw` so an escape names the character
+         * it renders to, and the two spellings of one key derive one constant.
+         */
+        function staticKeyOf(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                return typeof node.value === 'string'
+                    ? { node, text: node.value }
+                    : null;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                node.expressions.length === 0) {
+                const cooked = node.quasis[0]?.value.cooked;
+                // A cooked value is absent only for an invalid escape sequence, which
+                // names no character and so cannot name a constant either.
+                return typeof cooked === 'string' ? { node, text: cooked } : null;
+            }
+            return null;
+        }
         /**
          * Generate auto-fix suggestion for string literals
          */
@@ -549,18 +579,17 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                                 if (!isValidQueryKeyUsage(keyValue)) {
                                     // Check if it contains invalid string literals
                                     if (containsInvalidStringLiteral(keyValue)) {
-                                        // Only simple string literals can be auto-fixed
-                                        const suggestedConstant = keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
-                                            typeof keyValue.value === 'string'
-                                            ? generateAutoFix(keyValue.value)
+                                        // Only a statically known key value can be auto-fixed.
+                                        const staticKey = staticKeyOf(keyValue);
+                                        const suggestedConstant = staticKey
+                                            ? generateAutoFix(staticKey.text)
                                             : null;
                                         pendingReports.push({
                                             node: keyValue,
                                             messageId: 'enforceQueryKeyImport',
-                                            substitution: suggestedConstant &&
-                                                keyValue.type === utils_1.AST_NODE_TYPES.Literal
+                                            substitution: staticKey && suggestedConstant
                                                 ? {
-                                                    keyNode: keyValue,
+                                                    keyNode: staticKey.node,
                                                     constant: suggestedConstant,
                                                     scope: scopeOf(keyValue),
                                                 }

package/lib/rules/ensure-pointer-events-none.js

@@ -9,6 +9,34 @@ const createRule_1 = require("../utils/createRule");
 function hasPseudoElementSelector(selector) {
     return /::?(before|after)\b/i.test(selector);
 }
+/**
+ * Reads the static string a node denotes, so a property name or value carries
+ * the same meaning however it is spelled. A no-substitution template literal is
+ * a notation-only rewrite of a quoted string, and CSS-in-JS code writes both.
+ *
+ * Reading every name and value through one accessor keeps detection and the
+ * `pointerEvents` exemption on the same footing. Widening only the detection
+ * side would make the rule report objects that already set `pointerEvents` in a
+ * spelling it cannot read, and its fixer would append a second key — an object
+ * literal with duplicate keys does not compile.
+ *
+ * An interpolated template stays opaque: its text is not known statically, so
+ * the rule keeps its conservative silence there.
+ */
+function staticStringOf(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+        return String(node.value);
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return node.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+    }
+    return undefined;
+}
 /**
  * Checks if a property name is position with absolute or fixed value
  */
@@ -170,35 +198,18 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             for (const property of node.properties) {
                 if (property.type !== utils_1.AST_NODE_TYPES.Property)
                     continue;
-                let propertyName = '';
-                let propertyValue;
-                // Get property name
-                if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    propertyName = property.key.name;
-                }
-                else if (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof property.key.value === 'string') {
-                    propertyName = property.key.value;
-                }
-                // Get property value if it's a string literal
-                if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
-                    propertyValue = String(property.value.value);
-                }
-                else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    propertyValue = property.value.name;
-                }
+                const propertyName = staticStringOf(property.key) ?? '';
+                const propertyValue = staticStringOf(property.value);
                 // Check if this is position: absolute/fixed
                 if (isAbsoluteOrFixedPosition(propertyName, propertyValue)) {
                     hasAbsolutePosition = true;
                 }
-                // Check if this is pointer-events property
-                if (isPointerEventsProperty(propertyName)) {
-                    if (property.value.type === utils_1.AST_NODE_TYPES.Literal) {
-                        pointerEventsValue = String(property.value.value);
-                    }
-                    else if (property.value.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        pointerEventsValue = property.value.name;
-                    }
+                // Check if this is pointer-events property. A value that cannot be read
+                // statically never clears one already read: the rule's only remedy is to
+                // append a `pointerEvents` key, which would duplicate the existing one.
+                if (isPointerEventsProperty(propertyName) &&
+                    propertyValue !== undefined) {
+                    pointerEventsValue = propertyValue;
                 }
                 // Track inset offsets to detect hit-slop touch-target extensions
                 if (INSET_PROPERTIES.has(propertyName)) {
@@ -350,12 +361,12 @@ exports.ensurePointerEventsNone = (0, createRule_1.createRule)({
             // Process CSS-in-JS libraries that use objects with selectors
             Property(node) {
                 // Check for patterns like { '&::before': { ... } }
-                if (node.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.key.value === 'string' &&
-                    hasPseudoElementSelector(node.key.value) &&
+                const selector = staticStringOf(node.key);
+                if (selector !== undefined &&
+                    hasPseudoElementSelector(selector) &&
                     node.value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                     processStyleObject(node.value);
-                    checkStyleObject(node.value, node.key.value);
+                    checkStyleObject(node.value, selector);
                 }
             },
         };

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -15,14 +15,23 @@ const TYPE_EXPRESSION_WRAPPERS = new Set([
 function isHookLikeName(name) {
     return /^use[A-Z0-9]/.test(name);
 }
+/**
+ * The hook carve-out is a *suppression*, so failing to recognize a callee costs
+ * more than a missed report: `handleSideEffects` would hoist the call, and
+ * reordering hook calls is the one reordering React forbids outright. The
+ * assertion wrappers are therefore peeled off both the callee and the receiver
+ * it hangs from, so `(useTrack as any)()` and `(ref as Ref).useThing()` keep the
+ * suppression their bare spellings get.
+ */
 function isHookCallee(callee) {
-    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return isHookLikeName(callee.name);
+    const target = unwrapAssertions(callee);
+    if (target.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return isHookLikeName(target.name);
     }
-    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-        !callee.computed &&
-        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return isHookLikeName(callee.property.name);
+    if (target.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !target.computed &&
+        target.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return isHookLikeName(target.property.name);
     }
     return false;
 }
@@ -35,6 +44,29 @@ function isTypeNode(node) {
     }
     return node.type.startsWith('TS');
 }
+/**
+ * Peels every type-only wrapper off an expression: `x as T`, `<T>x`,
+ * `x satisfies T`, `x!` and `f<T>` all assert or instantiate a type without
+ * contributing a value, so a classifier asking about the *shape* of an
+ * expression must read straight through them.
+ *
+ * This matters beyond hand-written code. Sibling rules' autofixes put these
+ * wrappers on the very expressions this rule inspects — `global-const-style`
+ * appends ` as const` to module constants, `enforce-object-literal-as-const`
+ * to object literals — so a bare `init.type === Literal` test goes silent on a
+ * declaration `eslint --fix` had just reported (#1807). In the callee-resolving
+ * direction the same blindness is worse than silence: an unresolved callee
+ * contributes none of its captures, and the reordering fix then hoists the call
+ * above a binding it reads.
+ */
+function unwrapAssertions(node) {
+    let target = node;
+    while (TYPE_EXPRESSION_WRAPPERS.has(target.type) &&
+        'expression' in target) {
+        target = target.expression;
+    }
+    return target;
+}
 function unwrapTypeExpression(expression) {
     switch (expression.type) {
         case utils_1.AST_NODE_TYPES.TSAsExpression:
@@ -1006,11 +1038,26 @@ function isSiblingSourceDerivation(statement, sourceNodes, sourceDeclarators) {
         return !sourceDeclarators.has(name);
     });
 }
+/**
+ * A declarator's initializer with every type-only wrapper removed, or null when
+ * there is none.
+ *
+ * The candidate test and the dependency read below must agree on which node the
+ * initializer *is*: accepting `x as const` as a movable candidate while reading
+ * its dependency off the wrapper would make the move miss the very name it
+ * depends on. One accessor keeps both in step.
+ */
+function unwrappedInitOf(declarator) {
+    return declarator.init ? unwrapAssertions(declarator.init) : null;
+}
 /**
  * Restrict late-declaration candidates to simple variables with at most an Identifier or
  * Literal initializer. This ensures they are pure values that do not have side effects or
  * change execution order when moved closer to their usage. More complex initializers are
  * excluded to maintain temporal safety.
+ *
+ * The classification runs on the unwrapped initializer: an assertion is erased
+ * before the code runs, so `1 as const` is exactly the movable literal `1` is.
  */
 function lateDeclarationCandidateOf(statement) {
     const declaration = variableDeclarationOf(statement);
@@ -1021,9 +1068,10 @@ function lateDeclarationCandidateOf(statement) {
     if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
         return null;
     }
-    if (declarator.init &&
-        declarator.init.type !== utils_1.AST_NODE_TYPES.Identifier &&
-        declarator.init.type !== utils_1.AST_NODE_TYPES.Literal) {
+    const init = unwrappedInitOf(declarator);
+    if (init &&
+        init.type !== utils_1.AST_NODE_TYPES.Identifier &&
+        init.type !== utils_1.AST_NODE_TYPES.Literal) {
         return null;
     }
     return declarator;
@@ -1068,8 +1116,9 @@ function handleLateDeclarations(sink, body) {
         }
         const name = declarator.id.name;
         const dependencies = new Set();
-        if (declarator.init && declarator.init.type === utils_1.AST_NODE_TYPES.Identifier) {
-            dependencies.add(declarator.init.name);
+        const init = unwrappedInitOf(declarator);
+        if (init && init.type === utils_1.AST_NODE_TYPES.Identifier) {
+            dependencies.add(init.name);
         }
         const nameSet = new Set([name]);
         const usageIndex = findFirstUsageIndex(body, nameSet, index + 1);
@@ -1117,13 +1166,21 @@ function handleLateDeclarations(sink, body) {
         record(sink, statement, 'moveDeclarationCloser', { name }, index, usageIndex);
     });
 }
+/**
+ * Assertions are peeled at both ends of the optional-chain wrapper, so
+ * `send() as void`, `(send?.())!` and `(send?.() as void)` are all recognized as
+ * the call they perform.
+ */
 function extractCallExpression(expression) {
-    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
-        return expression;
+    const unwrapped = unwrapAssertions(expression);
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        return unwrapped;
     }
-    if (expression.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-        expression.expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
-        return expression.expression;
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        const chained = unwrapAssertions(unwrapped.expression);
+        if (chained.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            return chained;
+        }
     }
     return null;
 }
@@ -1187,40 +1244,49 @@ function resolveValueForIdentifier(body, name, beforeIndex) {
     return null;
 }
 function resolveValueNode(body, node, visited, beforeIndex) {
-    if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
-        if (visited.has(node.name)) {
+    // Every caller feeds its value through here, so unwrapping once at the entry
+    // covers the object, class and function shapes `descend` matches on: an
+    // `as const` on a lookup table must not turn its members opaque.
+    const target = unwrapAssertions(node);
+    if (target.type === utils_1.AST_NODE_TYPES.Identifier) {
+        if (visited.has(target.name)) {
             return null;
         }
-        visited.add(node.name);
-        const resolved = resolveValueForIdentifier(body, node.name, beforeIndex);
+        visited.add(target.name);
+        const resolved = resolveValueForIdentifier(body, target.name, beforeIndex);
         if (!resolved) {
             return null;
         }
         return resolveValueNode(body, resolved, visited, beforeIndex);
     }
-    if (node.type === utils_1.AST_NODE_TYPES.NewExpression &&
-        node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-        const resolvedClass = resolveValueForIdentifier(body, node.callee.name, beforeIndex);
-        if (resolvedClass &&
-            (resolvedClass.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
-                resolvedClass.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
-            return resolvedClass;
+    if (target.type === utils_1.AST_NODE_TYPES.NewExpression) {
+        const constructor = unwrapAssertions(target.callee);
+        if (constructor.type === utils_1.AST_NODE_TYPES.Identifier) {
+            const resolvedClass = resolveValueForIdentifier(body, constructor.name, beforeIndex);
+            if (resolvedClass &&
+                (resolvedClass.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                    resolvedClass.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
+                return resolvedClass;
+            }
         }
     }
-    return node;
+    return target;
 }
 function resolveMemberFunction(body, member, beforeIndex) {
     if (member.computed || member.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
         return null;
     }
     const path = [];
-    let cursor = member;
+    // A receiver may carry an assertion at any link — `(api as Api).run` — and an
+    // unresolved receiver costs the captures of the function it names, which is
+    // what stops the call being hoisted above them.
+    let cursor = unwrapAssertions(member);
     while (cursor &&
         cursor.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         !cursor.computed &&
         cursor.property.type === utils_1.AST_NODE_TYPES.Identifier) {
         path.unshift(cursor.property.name);
-        cursor = cursor.object;
+        cursor = unwrapAssertions(cursor.object);
     }
     if (!cursor || cursor.type !== utils_1.AST_NODE_TYPES.Identifier) {
         return null;
@@ -1276,12 +1342,12 @@ function getMemberCalleeKey(member) {
         return null;
     }
     const parts = [member.property.name];
-    let cursor = member.object;
+    let cursor = unwrapAssertions(member.object);
     while (cursor.type === utils_1.AST_NODE_TYPES.MemberExpression &&
         !cursor.computed &&
         cursor.property.type === utils_1.AST_NODE_TYPES.Identifier) {
         parts.unshift(cursor.property.name);
-        cursor = cursor.object;
+        cursor = unwrapAssertions(cursor.object);
     }
     if (cursor.type !== utils_1.AST_NODE_TYPES.Identifier) {
         return null;
@@ -1357,12 +1423,19 @@ function collectCalleeDependencies(body, callee, dependencies, callIndex, visite
                 continue;
             }
             for (const declarator of statement.declarations) {
-                if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    declarator.id.name === name &&
-                    declarator.init &&
-                    (declarator.init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                        declarator.init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
-                    return collectFunctionBodyDependencies(declarator.init, dependencies, {
+                if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    declarator.id.name !== name) {
+                    continue;
+                }
+                // Missing the function behind an assertion does not merely lose a
+                // report: the scan falls through to "resolved with no dependencies",
+                // and the reordering fix then hoists the call above the bindings the
+                // function body reads.
+                const init = unwrappedInitOf(declarator);
+                if (init &&
+                    (init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                        init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+                    return collectFunctionBodyDependencies(init, dependencies, {
                         body,
                         callIndex,
                         visitedCallees,
@@ -1380,9 +1453,8 @@ function collectCalleeDependencies(body, callee, dependencies, callIndex, visite
             }
             visitedCallees.add(memberKey);
         }
-        const rootName = callee.object.type === utils_1.AST_NODE_TYPES.Identifier
-            ? callee.object.name
-            : null;
+        const receiver = unwrapAssertions(callee.object);
+        const rootName = receiver.type === utils_1.AST_NODE_TYPES.Identifier ? receiver.name : null;
         if (rootName && isIdentifierMutated(body, rootName, callIndex)) {
             return false;
         }
@@ -1481,6 +1553,12 @@ function applyMove(body, fromIndex, toIndex) {
  * an await. An await buried deeper (`const x = (await f()).y`) is deliberately not
  * counted — that rule does not group it either, so protecting it would cost autofixes
  * for no gain.
+ *
+ * The same reasoning keeps assertion wrappers *out* of this one test, against the
+ * grain of the rest of the file: `parallelize-async-operations` matches an await
+ * initializer with the identical bare type check, so `const x = (await f()) as T`
+ * is outside its runs. Peeling the wrapper here would protect a run that rule
+ * never forms, so the narrowness is what keeps the two in step (#1807).
  */
 function isAwaitBearingStatement(statement) {
     if (statement.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {

package/lib/rules/no-complex-cloud-params.js

@@ -4,6 +4,41 @@ exports.noComplexCloudParams = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const PASCAL_CASE_RE = /^[A-Z][a-zA-Z0-9]*$/;
+/**
+ * Resolves a member expression's property to the name it accesses, so that a
+ * computed spelling such as `Object['create']` is recognized as the same
+ * access as `Object.create`. Returns null when the property is only known at
+ * runtime, in which case callers must fall back to their conservative path.
+ */
+function staticPropertyName(property, computed) {
+    if (!computed && property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return property.name;
+    }
+    if (computed &&
+        property.type === utils_1.AST_NODE_TYPES.Literal &&
+        (typeof property.value === 'string' || typeof property.value === 'number')) {
+        return String(property.value);
+    }
+    return null;
+}
+/**
+ * Reads the module path of a dynamic import when the path is fixed in the
+ * source. A no-substitution template literal spells exactly the same path as a
+ * string literal, so both must be tracked; an interpolated template resolves to
+ * a different module per call and is deliberately left untracked to keep this
+ * to a question of notation.
+ */
+function staticModulePath(source) {
+    if (source.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof source.value === 'string') {
+        return source.value;
+    }
+    if (source.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        source.expressions.length === 0) {
+        return source.quasis[0]?.value.cooked ?? null;
+    }
+    return null;
+}
 exports.noComplexCloudParams = (0, createRule_1.createRule)({
     name: 'no-complex-cloud-params',
     meta: {
@@ -49,8 +84,7 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
                 if (node.value &&
                     node.value.type === utils_1.AST_NODE_TYPES.CallExpression &&
                     node.value.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    node.value.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.value.callee.property.name === 'bind') {
+                    staticPropertyName(node.value.callee.property, node.value.callee.computed) === 'bind') {
                     return true;
                 }
                 // Check for generator methods
@@ -184,20 +218,21 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
                 }
                 // Check for method calls that could create complex objects
                 if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const calleeProperty = node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression
+                        ? staticPropertyName(node.callee.property, node.callee.computed)
+                        : null;
                     // Allow JSON.stringify
                     if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                         node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                         node.callee.object.name === 'JSON' &&
-                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.callee.property.name === 'stringify') {
+                        calleeProperty === 'stringify') {
                         return false;
                     }
                     // Allow Object.create(null)
                     if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                         node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                         node.callee.object.name === 'Object' &&
-                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.callee.property.name === 'create') {
+                        calleeProperty === 'create') {
                         // Only allow Object.create(null), check if the prototype object is complex
                         if (node.arguments.length === 1) {
                             if (node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
@@ -210,8 +245,7 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
                     }
                     // Check for function binding
                     if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.callee.property.name === 'bind') {
+                        calleeProperty === 'bind') {
                         return true;
                     }
                     return isComplexValue(node.callee);
@@ -345,9 +379,8 @@ exports.noComplexCloudParams = (0, createRule_1.createRule)({
         return {
             // Track cloud function imports
             ImportExpression(node) {
-                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.source.value === 'string' &&
-                    node.source.value.includes('firebaseCloud')) {
+                const modulePath = staticModulePath(node.source);
+                if (modulePath !== null && modulePath.includes('firebaseCloud')) {
                     // Find the variable declarator that contains this import
                     let parent = node.parent;
                     while (parent && parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {

package/lib/rules/no-conditional-literals-in-jsx.js

@@ -21,6 +21,18 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        /**
+         * A template literal without substitutions renders exactly the text its
+         * quoted spelling renders, so notation must never decide whether a value
+         * counts as JSX text. Substitution-bearing templates are excluded because
+         * their rendered value is not decidable syntactically. Numeric and boolean
+         * literals are excluded to avoid misleading messages for values that are
+         * not text.
+         */
+        const isTextLiteral = (astNode) => (astNode.type === utils_1.TSESTree.AST_NODE_TYPES.Literal &&
+            typeof astNode.value === 'string') ||
+            (astNode.type === utils_1.TSESTree.AST_NODE_TYPES.TemplateLiteral &&
+                astNode.expressions.length === 0);
         return {
             // Imagine evaluating <div>text {conditional && 'string'}</div>
             JSXExpressionContainer(node) {
@@ -62,21 +74,20 @@ exports.noConditionalLiteralsInJsx = (0, createRule_1.createRule)({
                 const logicalExpression = node.expression;
                 const literalNode = logicalExpression.right;
                 const conditionalNode = logicalExpression.left;
-                // Only enforce when the literal is the expression's return value.
-                if (literalNode.type !== utils_1.TSESTree.AST_NODE_TYPES.Literal) {
-                    return;
-                }
-                // Only enforce for string literals to avoid misleading messages for
-                // numeric or boolean literals rendered conditionally.
-                if (typeof literalNode.value !== 'string') {
+                // Only enforce when a text literal is the expression's return value.
+                if (!isTextLiteral(literalNode)) {
                     return;
                 }
                 /**
                  * Ignore logical expressions that do not actually render the literal
                  * conditionally (e.g., literal && condition or literal || condition)
-                 * and expressions with two literals.
+                 * and expressions with two literals. Any literal on the left is
+                 * unconditional, including the numeric and boolean ones that are never
+                 * reported as a rendered value, so this exemption is wider than
+                 * isTextLiteral on purpose.
                  */
-                if (conditionalNode.type === utils_1.TSESTree.AST_NODE_TYPES.Literal) {
+                if (conditionalNode.type === utils_1.TSESTree.AST_NODE_TYPES.Literal ||
+                    isTextLiteral(conditionalNode)) {
                     return;
                 }
                 const sourceCode = context.getSourceCode();

package/lib/rules/no-margin-properties.js

@@ -15,6 +15,37 @@ function normalizePropertyName(name) {
     // Convert camelCase to kebab-case
     return toKebabCase(name).toLowerCase();
 }
+/**
+ * `x as T`, `<T>x`, `x satisfies T` and `x!` assert a type without contributing
+ * a value of their own, so a check that classifies the *shape* of an expression
+ * must look through all four alike.
+ *
+ * This matters beyond hand-written code: sibling rules' autofixes append
+ * ` as const` to the very object literals this rule inspects
+ * (`global-const-style` rewrites `const styles = { margin: 8 }` into
+ * `const STYLES = { margin: 8 } as const`). A bare
+ * `node.type === ObjectExpression` test taken on the wrapper therefore goes
+ * silent on code `eslint --fix` had just reported (Issue #1805).
+ */
+const ASSERTION_EXPRESSION_TYPES = 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,
+]);
+const isAssertionExpression = (node) => ASSERTION_EXPRESSION_TYPES.has(node.type);
+/**
+ * Peels every assertion wrapper off an expression, so `{ m: 1 } as const`,
+ * `<const>{ m: 1 }` and chains such as `{ m: 1 } as const satisfies Styles`
+ * all classify as the object literal they wrap.
+ */
+function unwrapAssertions(node) {
+    let target = node;
+    while (isAssertionExpression(target)) {
+        target = target.expression;
+    }
+    return target;
+}
 // List of margin properties to flag
 const MARGIN_PROPERTIES = new Set([
     'margin',
@@ -63,6 +94,11 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
          */
         function isMuiStylingContext(node) {
             let current = node;
+            // An assertion wrapper (`{ m: 1 } as const`) is transparent to this
+            // climb: it matches none of the terminal predicates below, so the loop
+            // steps over it and keeps ascending. Any terminal branch added here must
+            // preserve that — concluding *at* an assertion would decide the styling
+            // context from the type syntax an author happened to reach for.
             while (current?.parent) {
                 // Check for JSX sx attribute (MUI specific)
                 if (current.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
@@ -77,10 +113,12 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                     return true;
                 }
                 // Check for MUI's css function
-                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    current.parent.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    current.parent.callee.name === 'css') {
-                    return true;
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const callee = unwrapAssertions(current.parent.callee);
+                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        callee.name === 'css') {
+                        return true;
+                    }
                 }
                 // Skip if we're in a TypeScript type definition
                 if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
@@ -97,19 +135,21 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
             if (seenNodes.has(node))
                 return;
             seenNodes.add(node);
+            // A computed key carries its own assertions (`['margin' as const]`), so
+            // the key is classified through them as well.
+            const key = unwrapAssertions(node.key);
             let propertyName = '';
             // Get property name
-            if (node.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                propertyName = node.key.name;
+            if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                propertyName = key.name;
             }
-            else if (node.key.type === utils_1.AST_NODE_TYPES.Literal) {
-                propertyName = String(node.key.value);
+            else if (key.type === utils_1.AST_NODE_TYPES.Literal) {
+                propertyName = String(key.value);
             }
-            else if (node.computed &&
-                node.key.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
+            else if (node.computed && key.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
                 // Handle template literals like [`${prop}Top`]
-                const quasis = node.key.quasis.map((q) => q.value.raw).join('');
-                const expressions = node.key.expressions
+                const quasis = key.quasis.map((q) => q.value.raw).join('');
+                const expressions = key.expressions
                     .map((exp) => {
                     if (exp.type === utils_1.AST_NODE_TYPES.Identifier) {
                         return exp.name;
@@ -132,23 +172,36 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                 }
             }
         }
+        /**
+         * Resolves an identifier to the object literal it is initialized with,
+         * looking through any assertion wrappers on that initializer.
+         */
+        function resolveObjectLiteral(variableName) {
+            const scope = context.getScope();
+            const variable = scope.variables.find((v) => v.name === variableName);
+            if (!variable || variable.defs.length === 0)
+                return undefined;
+            const def = variable.defs[0];
+            if (def.node.type !== utils_1.AST_NODE_TYPES.VariableDeclarator ||
+                !def.node.init) {
+                return undefined;
+            }
+            const init = unwrapAssertions(def.node.init);
+            return init.type === utils_1.AST_NODE_TYPES.ObjectExpression ? init : undefined;
+        }
         // Check object expression for margin properties
         function checkObjectExpression(objExp) {
             objExp.properties.forEach((prop) => {
                 if (prop.type === utils_1.AST_NODE_TYPES.Property) {
                     checkNode(prop);
                 }
-                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement &&
-                    prop.argument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                else if (prop.type === utils_1.AST_NODE_TYPES.SpreadElement) {
                     // Handle spread elements by looking up the variable
-                    const variableName = prop.argument.name;
-                    const scope = context.getScope();
-                    const variable = scope.variables.find((v) => v.name === variableName);
-                    if (variable && variable.defs.length > 0) {
-                        const def = variable.defs[0];
-                        if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                            def.node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                            checkObjectExpression(def.node.init);
+                    const spreadArgument = unwrapAssertions(prop.argument);
+                    if (spreadArgument.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const spreadSource = resolveObjectLiteral(spreadArgument.name);
+                        if (spreadSource) {
+                            checkObjectExpression(spreadSource);
                         }
                     }
                 }
@@ -166,69 +219,69 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                 if (node.name.type !== utils_1.AST_NODE_TYPES.JSXIdentifier ||
                     node.name.name !== 'sx')
                     return;
-                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    node.value.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    checkObjectExpression(node.value.expression);
+                if (node.value?.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer)
+                    return;
+                const expression = unwrapAssertions(node.value.expression);
+                if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    checkObjectExpression(expression);
                 }
-                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    node.value.expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+                else if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
                     // Handle variable reference in sx prop
-                    const variableName = node.value.expression.name;
-                    const scope = context.getScope();
-                    const variable = scope.variables.find((v) => v.name === variableName);
-                    if (variable && variable.defs.length > 0) {
-                        const def = variable.defs[0];
-                        if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                            def.node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                            checkObjectExpression(def.node.init);
-                        }
+                    const referenced = resolveObjectLiteral(expression.name);
+                    if (referenced) {
+                        checkObjectExpression(referenced);
                     }
                 }
-                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    node.value.expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                else if (expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
                     // Handle function-based sx props
-                    if (node.value.expression.body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    const body = unwrapAssertions(expression.body);
+                    if (body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                         // Arrow function with object expression body
-                        checkObjectExpression(node.value.expression.body);
+                        checkObjectExpression(body);
                     }
-                    else if (node.value.expression.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    else if (body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
                         // Arrow function with block body
-                        const returnStatements = node.value.expression.body.body.filter((stmt) => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
+                        const returnStatements = body.body.filter((stmt) => stmt.type === utils_1.AST_NODE_TYPES.ReturnStatement);
                         returnStatements.forEach((returnStmt) => {
-                            if (returnStmt.argument?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                                checkObjectExpression(returnStmt.argument);
+                            if (!returnStmt.argument)
+                                return;
+                            const returned = unwrapAssertions(returnStmt.argument);
+                            if (returned.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                checkObjectExpression(returned);
                             }
                         });
                     }
                 }
-                else if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
-                    node.value.expression.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
+                else if (expression.type === utils_1.AST_NODE_TYPES.ConditionalExpression) {
                     // Handle conditional expressions in sx props
-                    if (node.value.expression.consequent.type ===
-                        utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        checkObjectExpression(node.value.expression.consequent);
+                    const consequent = unwrapAssertions(expression.consequent);
+                    if (consequent.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectExpression(consequent);
                     }
-                    if (node.value.expression.alternate.type ===
-                        utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        checkObjectExpression(node.value.expression.alternate);
+                    const alternate = unwrapAssertions(expression.alternate);
+                    if (alternate.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkObjectExpression(alternate);
                     }
                 }
             },
             // Handle variable declarations that might be used in sx props
             VariableDeclarator(node) {
-                if (node.init?.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
-                    node.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                if (!node.init || node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const init = unwrapAssertions(node.init);
+                if (init.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                     const variableName = node.id.name;
                     const sourceText = context.sourceCode.getText();
                     // Check for margin properties in the object
-                    node.init.properties.forEach((prop) => {
+                    init.properties.forEach((prop) => {
                         if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            const key = unwrapAssertions(prop.key);
                             let propertyName = '';
-                            if (prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                propertyName = prop.key.name;
+                            if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                propertyName = key.name;
                             }
-                            else if (prop.key.type === utils_1.AST_NODE_TYPES.Literal) {
-                                propertyName = String(prop.key.value);
+                            else if (key.type === utils_1.AST_NODE_TYPES.Literal) {
+                                propertyName = String(key.value);
                             }
                             if (propertyName && checkProperty(propertyName)) {
                                 // Check if this variable is used in an sx prop
@@ -268,10 +321,11 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
             },
             // Handle MUI's css function
             CallExpression(node) {
-                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.callee.name === 'css' &&
+                const callee = unwrapAssertions(node.callee);
+                if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.name === 'css' &&
                     node.arguments.length > 0) {
-                    const arg = node.arguments[0];
+                    const arg = unwrapAssertions(node.arguments[0]);
                     if (arg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
                         checkObjectExpression(arg);
                     }

package/lib/rules/prefer-global-router-state-key.js

@@ -305,6 +305,36 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * The key's value when it is knowable without running the program, paired
+         * with the node that spells it.
+         *
+         * The substituted `QUERY_KEY_*` name is derived from that value, so what a
+         * fix needs is the value — not the notation carrying it. Gating on the node
+         * type instead left a static template reported exactly like the quoted
+         * string it renders to but with no fix behind the report (#1804). Every
+         * genuinely underivable shape — concatenation, a ternary, a template WITH
+         * expressions — holds no single value and falls out here on its own, so the
+         * conservative carve-out survives without being keyed to notation.
+         *
+         * Read through `cooked` rather than `raw` so an escape names the character
+         * it renders to, and the two spellings of one key derive one constant.
+         */
+        function staticKeyOf(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                return typeof node.value === 'string'
+                    ? { node, text: node.value }
+                    : null;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+                node.expressions.length === 0) {
+                const cooked = node.quasis[0]?.value.cooked;
+                // A cooked value is absent only for an invalid escape sequence, which
+                // names no character and so cannot name a constant either.
+                return typeof cooked === 'string' ? { node, text: cooked } : null;
+            }
+            return null;
+        }
         /**
          * Generate auto-fix suggestion for string literals
          */
@@ -384,9 +414,10 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
                                                 keyValue: sourceCode.getText(keyValue),
                                             },
                                             fix(fixer) {
-                                                if (keyValue.type === utils_1.AST_NODE_TYPES.Literal &&
-                                                    typeof keyValue.value === 'string') {
-                                                    const suggestedConstant = generateAutoFix(keyValue.value);
+                                                // Only a statically known key value can be auto-fixed.
+                                                const staticKey = staticKeyOf(keyValue);
+                                                if (staticKey) {
+                                                    const suggestedConstant = generateAutoFix(staticKey.text);
                                                     if (suggestedConstant) {
                                                         const fixes = [];
                                                         const namespaceAlias = findImportKey(namespaceImports, isQueryKeysSource);
@@ -440,8 +471,8 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
                                                         if (visibleBinding && !bindingIsQueryKeyImport) {
                                                             return null;
                                                         }
-                                                        // 1) Replace the literal with the constant (qualify if alias exists)
-                                                        fixes.push(fixer.replaceText(keyValue, replacementText));
+                                                        // 1) Replace the key with the constant (qualify if alias exists)
+                                                        fixes.push(fixer.replaceText(staticKey.node, replacementText));
                                                         // 2) Ensure an import exists for the suggested constant
                                                         const hasNamespaceOrDefault = Boolean(importAlias);
                                                         if (!existingNamedImport &&

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,96 @@
 [
+  {
+    "version": "1.20.124",
+    "date": "2026-08-06T15:15:14.462Z",
+    "rules": [
+      {
+        "name": "enforce-console-error",
+        "changeType": "fix",
+        "issues": [
+          1801
+        ],
+        "summary": "treat a no-substitution template and an assertion-wrapped literal as a static severity (closes #1801)"
+      },
+      {
+        "name": "enforce-mock-firestore",
+        "changeType": "fix",
+        "issues": [
+          1806
+        ],
+        "summary": "treat expression assertions as transparent when resolving the jest.mock factory's object (closes #1806)"
+      },
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          1803
+        ],
+        "summary": "gate the autofix on the key's value rather than its notation (closes #1803)"
+      },
+      {
+        "name": "ensure-pointer-events-none",
+        "changeType": "fix",
+        "issues": [
+          1800
+        ],
+        "summary": "read a no-substitution template as the static string it denotes (closes #1800)"
+      },
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          1807
+        ],
+        "summary": "treat expression assertions as transparent in every movability and dependency read (closes #1807)"
+      },
+      {
+        "name": "no-complex-cloud-params",
+        "changeType": "fix",
+        "issues": [
+          1799
+        ],
+        "summary": "track template-literal cloud imports and computed escape-hatch spellings (closes #1799)"
+      },
+      {
+        "name": "no-conditional-literals-in-jsx",
+        "changeType": "fix",
+        "issues": [
+          1802
+        ],
+        "summary": "recognise a no-substitution template on both operands (closes #1802)"
+      },
+      {
+        "name": "no-margin-properties",
+        "changeType": "fix",
+        "issues": [
+          1805
+        ],
+        "summary": "treat expression assertions as transparent when classifying a style object (closes #1805)"
+      },
+      {
+        "name": "prefer-global-router-state-key",
+        "changeType": "fix",
+        "issues": [
+          1804
+        ],
+        "summary": "gate the autofix on the key's value rather than its notation (closes #1804)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.123",
+    "date": "2026-08-06T11:53:46.588Z",
+    "rules": [
+      {
+        "name": "enforce-mock-firestore",
+        "changeType": "fix",
+        "issues": [
+          1798
+        ],
+        "summary": "resolve the jest.mock factory's returned object in every body form (closes #1798)"
+      }
+    ]
+  },
   {
     "version": "1.20.122",
     "date": "2026-08-06T11:06:53.595Z",