@blumintinc/eslint-plugin-blumint 1.20.151 → 1.20.153

package/lib/index.js

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

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -69,6 +69,111 @@ function memberNameOf(key) {
     }
     return undefined;
 }
+const EQUALITY_OPERATORS = new Set([
+    '===',
+    '!==',
+    '==',
+    '!=',
+]);
+/**
+ * The text of a literal string, written either way round: `'string'` and
+ * `` `string` `` assert the same thing about the operand beside them.
+ */
+function stringLiteralValueOf(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+        return node.value;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked;
+    }
+    return undefined;
+}
+/**
+ * The operand an equality comparison holds opposite `operand`, so operand
+ * order carries no meaning: `typeof x === 'string'` and
+ * `'string' === typeof x` are the same assertion.
+ */
+function comparedAgainst(comparison, operand) {
+    if (!EQUALITY_OPERATORS.has(comparison.operator))
+        return undefined;
+    if (comparison.left === operand)
+        return comparison.right;
+    if (comparison.right === operand)
+        return comparison.left;
+    return undefined;
+}
+/**
+ * The outermost node standing for the same value, so a contradiction written
+ * around `verdict!` or `verdict as string` is a contradiction about
+ * `verdict`.
+ */
+function passthroughValueOf(node) {
+    let current = node;
+    while (current.parent) {
+        const { parent } = current;
+        const wraps = (parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+            parent.type === utils_1.AST_NODE_TYPES.ChainExpression) &&
+            parent.expression ===
+                current;
+        if (!wraps)
+            break;
+        current = parent;
+    }
+    return current;
+}
+/** `Error`, `TypeError` and any `…Error` class take a string message. */
+function isErrorConstructor(callee) {
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name.endsWith('Error');
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const member = memberNameOf(callee.property);
+        return !!member && member.name.endsWith('Error');
+    }
+    return false;
+}
+/**
+ * Whether this reference uses the value in a way a boolean could not be
+ * used, which disproves a booleanness read off a name.
+ */
+function referenceContradictsBoolean(reference) {
+    const value = passthroughValueOf(reference);
+    const { parent } = value;
+    if (!parent)
+        return false;
+    // `typeof verdict === 'string'`. A tag of `'boolean'` AFFIRMS the boolean
+    // reading whichever equality operator carries it — `!== 'boolean'` is how
+    // a boolean guard is spelled — so only some other tag contradicts.
+    if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === 'typeof' &&
+        parent.argument === value) {
+        const comparison = parent.parent;
+        if (comparison?.type !== utils_1.AST_NODE_TYPES.BinaryExpression)
+            return false;
+        const other = comparedAgainst(comparison, parent);
+        const tag = other ? stringLiteralValueOf(other) : undefined;
+        return tag !== undefined && tag !== 'boolean';
+    }
+    // `verdict === 'occupied'` — a value compared with a string is not a
+    // boolean, since no boolean is ever equal to one.
+    if (parent.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+        const other = comparedAgainst(parent, value);
+        return !!other && stringLiteralValueOf(other) !== undefined;
+    }
+    // `throw new Error(verdict)` — the message parameter is a string, so the
+    // binding carries the failure reason rather than a verdict flag.
+    if (parent.type === utils_1.AST_NODE_TYPES.NewExpression &&
+        parent.arguments[0] === value &&
+        isErrorConstructor(parent.callee)) {
+        return true;
+    }
+    return false;
+}
 exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
     name: 'enforce-boolean-naming-prefixes',
     meta: {
@@ -914,6 +1019,66 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
             }
             return calleeReturnEvaluation(calleeName) !== 'nonBoolean';
         }
+        /**
+         * Whether the only evidence that a binding holds a boolean is a NAME.
+         *
+         * `calleeReturnEvaluation` answers "does this callee demonstrably return a
+         * non-boolean?"; its 'indeterminate' verdict is the case where the callee's
+         * body is out of reach (an import, a parameter, a value read off a builder
+         * chain) and the callee's `is`/`has`/`can` prefix is all that is left. A
+         * boolean-sounding property (`state.isValid`) is the same kind of evidence.
+         *
+         * Everything else — an explicit `: boolean` annotation, a boolean literal, a
+         * comparison or negation, a `Boolean()` coercion, a resolvable declaration
+         * whose return classifies as boolean — is evidence about the VALUE, which no
+         * use site is allowed to outrank.
+         */
+        function booleanEvidenceIsNameOnly(declarator) {
+            if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                hasBooleanTypeAnnotation(declarator.id) ||
+                !declarator.init) {
+                return false;
+            }
+            const restsOnName = (expression) => {
+                const value = unwrapChainExpression(expression);
+                // A property name is the whole of the evidence in
+                // `isLikelyBooleanByMemberExpression`, the only path that reads one.
+                if (value.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    return true;
+                }
+                if (value.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    value.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return (!isGlobalBooleanCall(value) &&
+                        calleeReturnEvaluation(value.callee.name) === 'indeterminate');
+                }
+                // `isFoo(x) || fallback` reaches booleanness through its left operand.
+                if (value.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    value.operator === '||') {
+                    return restsOnName(value.left);
+                }
+                return false;
+            };
+            return restsOnName(declarator.init);
+        }
+        /**
+         * Whether any use of the binding contradicts booleanness.
+         *
+         * Validator families built on `ValidatorPipeline` return `true | string` —
+         * `true` for a pass, the failure message for a fail — while
+         * `enforce-is-prefix-validators` requires the validator itself to be
+         * `is`-prefixed. Inferring the result's booleanness from that mandated
+         * prefix makes the two rules unsatisfiable together, so a use site that
+         * reads the value as a string settles it against the name.
+         *
+         * References come from the scope manager, never from matching the name as
+         * text: a contradiction must belong to THIS binding, not to a shadowing
+         * inner one, a sibling scope's binding, or an unrelated same-named value.
+         */
+        function useSiteContradictsBoolean(declarator) {
+            return context
+                .getDeclaredVariables(declarator)
+                .some((variable) => variable.references.some((reference) => referenceContradictsBoolean(reference.identifier)));
+        }
         /**
          * Check if a variable is used in a while loop condition and is likely a DOM element or tree node
          * This helps identify variables like 'parent', 'element', 'node', etc. that are used
@@ -1233,6 +1398,14 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     utils_1.AST_NODE_TYPES.TSBooleanKeyword) {
                 isBooleanVar = true;
             }
+            // A booleanness read off a name loses to a use site that treats the value
+            // as something else, which is what keeps this rule satisfiable alongside
+            // `enforce-is-prefix-validators` for `true | string` validator verdicts.
+            if (isBooleanVar &&
+                booleanEvidenceIsNameOnly(node) &&
+                useSiteContradictsBoolean(node)) {
+                return;
+            }
             if (isBooleanVar && !hasApprovedPrefix(variableName)) {
                 context.report({
                     node: node.id,

package/lib/rules/enforce-object-literal-as-const.js

@@ -207,25 +207,41 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
             return undefined;
         }
         /**
-         * `as const` turns an array literal into a readonly *tuple*, which TS4104
-         * refuses to assign to a mutable array or tuple. Where the annotation says
-         * the value must be mutable, appending `as const` breaks the build, and no
-         * edit at the literal can satisfy the rule — honouring it would mean
-         * rewriting the signature, a call the author has to make. So the rule stays
-         * silent rather than reporting something the developer cannot act on
-         * (#1526).
+         * `as const` turns an array literal into a fixed-length readonly *tuple*,
+         * strictly narrower than the mutable array the literal otherwise gets. Two
+         * separate breakages follow from that narrowing, and neither is visible at
+         * the literal:
+         *
+         * - Where the enclosing signature declares a mutable array or tuple, TS4104
+         *   refuses the assignment, so appending `as const` breaks the build. No
+         *   edit at the literal satisfies the rule — honouring it means rewriting
+         *   the signature, a call the author has to make (#1526).
+         * - Where the signature is inferred, the frozen arity becomes part of the
+         *   return type and every caller inherits it: `.length` narrows to a literal
+         *   number (TS2367 against any other length), `.includes` narrows its
+         *   parameter to the element union — `never` for `[]` — (TS2345), and the
+         *   value stops satisfying a mutable `T[]` parameter. The break lands in a
+         *   different function than the one edited, and the callers are beyond what
+         *   the rule can see (#2015).
+         *
+         * So an array literal is left alone unless the enclosing signature states a
+         * type that accepts a readonly tuple. An annotation the rule cannot resolve
+         * still counts as accepting, per `acceptsReadonlyArray`: the annotation, not
+         * the literal, is what callers read, so the arity never escapes.
          *
          * Object literals are unaffected: `readonly` property modifiers do not
          * enter assignability, so `{ a: 1 } as const` still satisfies a mutable
-         * `{ a: number }`.
+         * `{ a: number }`, and freezing one fixes no arity.
          */
-        function conflictsWithDeclaredType(literal, ancestors) {
+        function freezingArrayIsUnsafe(literal, ancestors) {
             if (!isArrayLiteral(literal)) {
                 return false;
             }
             const enclosingFunction = enclosingFunctionOf(ancestors);
-            if (!enclosingFunction) {
-                return false;
+            // With no declared return type in view, the inferred tuple is what the
+            // callers get.
+            if (!enclosingFunction || !declaredReturnTypeOf(enclosingFunction)) {
+                return true;
             }
             const returnedValueType = returnedValueTypeOf(enclosingFunction);
             return !!returnedValueType && !acceptsReadonlyArray(returnedValueType);
@@ -285,10 +301,10 @@ exports.enforceObjectLiteralAsConst = (0, createRule_1.createRule)({
                 if (isInsideReactHook(ancestors) && isArrayLiteral(literal)) {
                     return;
                 }
-                // Skip arrays the enclosing signature declares mutable: `as const`
-                // cannot compile there and the developer cannot act on the report
-                // (#1526)
-                if (conflictsWithDeclaredType(literal, ancestors)) {
+                // Skip arrays whose enclosing signature does not accept the readonly
+                // tuple `as const` produces — declared mutable (#1526) or inferred, in
+                // which case the frozen arity reaches every caller (#2015)
+                if (freezingArrayIsUnsafe(literal, ancestors)) {
                     return;
                 }
                 // Report the issue and provide a fix

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

@@ -123,20 +123,19 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
         ]);
         const sourceCode = context.getSourceCode();
         /**
-         * Reports are buffered until the whole file has been walked so the fixer can
-         * put every substituted constant into a single import instead of racing
-         * per-violation insertions that overlap and get dropped.
+         * Reports are buffered until the whole file has been walked so each fix is
+         * planned against the file's complete import picture: what a substituted
+         * constant resolves to, and whether the fix has to bring an import with it,
+         * are questions about the whole file rather than about the text above the
+         * violation.
          */
         const pendingReports = [];
         /**
-         * The queryKeys import rides on one violation's fix, which makes that
-         * violation the file's import carrier. ESLint collects fixes before it
-         * applies inline disable directives, so a suppressed carrier takes the
-         * import down with it while the surviving substitutions still land —
-         * leaving the file referencing constants nothing imports (#1410).
-         * Resolving suppression here keeps a suppressed violation out of the plan
-         * entirely: it neither claims the carrier slot nor contributes a specifier
-         * to the import, which would otherwise be imported and never used.
+         * A violation the author has waived with an inline disable directive is
+         * left out of the fix plan, so no constant is resolved for it and no import
+         * is written for it (#1410). This is the decision ESLint reaches anyway
+         * when it discards a suppressed message together with its fix, taken one
+         * step earlier where the rule can see it.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         /**
@@ -264,10 +263,13 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                 : queryKeysSpecifier;
         }
         /**
-         * Make the substituted constants resolve: extend the file's queryKeys import
+         * Make a substituted constant resolve: extend the file's queryKeys import
          * when there is one to extend, otherwise add a fresh import statement.
+         *
+         * The caller asks for this only where the constant binds to nothing, so the
+         * emitted specifier is never a duplicate of one the file already has.
          */
-        function buildImportFix(fixer, constants) {
+        function buildImportFix(fixer, constant) {
             const importDeclarations = importDeclarationsOf();
             const queryKeysDeclarations = queryKeysDeclarationsOf();
             const reusable = queryKeysDeclarations.find((declaration) => declaration.importKind !== 'type' &&
@@ -275,7 +277,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             if (reusable) {
                 const namedSpecifiers = reusable.specifiers.filter(isValueImportSpecifier);
                 const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-                return fixer.insertTextAfter(lastSpecifier, constants.map((constant) => `, ${constant}`).join(''));
+                return fixer.insertTextAfter(lastSpecifier, `, ${constant}`);
             }
             // A namespace or type-only queryKeys import cannot take named value
             // specifiers, but its path is proof of how this file reaches the module.
@@ -283,7 +285,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             if (source === null) {
                 return null;
             }
-            const importText = `import { ${constants.join(', ')} } from '${source}';\n`;
+            const importText = `import { ${constant} } from '${source}';\n`;
             const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
             if (importDeclarations.length) {
                 // The statement joins an import block, and the anchor is that block's
@@ -310,7 +312,6 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
         }
         function flushReports() {
             const resolutions = new Map();
-            const missingConstants = [];
             const canImport = importSourceOf() !== null;
             // The location handed to `context.report` below is what ESLint matches a
             // directive against, so suppression is resolved from exactly that node.
@@ -329,20 +330,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                     continue;
                 }
                 resolutions.set(report, { name, state });
-                if (state === 'missing' && !missingConstants.includes(name)) {
-                    missingConstants.push(name);
-                }
             }
-            // The first applied substitution carries the import for every other one:
-            // its fix range then starts at the top of the file and ends before the
-            // remaining literals, so no two fixes of this rule overlap in a pass.
-            // Suppressed reports are skipped so the slot falls to a survivor.
-            const importCarrier = pendingReports.find((report) => {
-                const resolution = resolutions.get(report);
-                return (!suppressed.has(report) &&
-                    resolution !== undefined &&
-                    resolution.state !== 'conflict');
-            });
             // Suppressed violations are still reported: ESLint discards them, and
             // reporting keeps the user's directive "used" so that
             // `--report-unused-disable-directives` does not flag it.
@@ -363,8 +351,20 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                         const fixes = [
                             fixer.replaceText(substitution.keyNode, resolution.name),
                         ];
-                        if (report === importCarrier && missingConstants.length > 0) {
-                            const importFix = buildImportFix(fixer, missingConstants);
+                        // Every fix stands on its own: the one that writes a constant is
+                        // the one that imports it. Concentrating the file's imports into a
+                        // single carrier fix made every other fix depend on that one being
+                        // applied, and ESLint drops a fix whose range overlaps a fix it has
+                        // already taken from another rule — so the carrier lost that race
+                        // while the literal-only fixes still landed, leaving the file
+                        // naming an identifier nothing imports (#2012).
+                        //
+                        // Two such fixes both reach for the import declaration, so within a
+                        // pass they overlap and ESLint applies one of them. That converges:
+                        // the unapplied violation is re-reported on the next pass and its
+                        // constant then binds to, or extends, the import that landed.
+                        if (resolution.state === 'missing') {
+                            const importFix = buildImportFix(fixer, resolution.name);
                             if (!importFix) {
                                 return null;
                             }

package/lib/rules/global-const-style.js

@@ -108,6 +108,139 @@ const isComponentFactoryCall = (node) => {
 // the same terms as `const Row = (props) => {...}` (Issue #1681).
 const isFunctionValue = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
     node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
+// `as const` does more than pin literal types: it makes the value deeply
+// `readonly`. A binding that is written through after its declaration therefore
+// cannot carry the assertion at all — appending it turns compiling code into
+// `TS2339: Property 'push' does not exist on type 'readonly []'` for an array
+// and `TS2540: Cannot assign to 'a' because it is a read-only property` for an
+// object (Issue #2013). These are the built-in methods that mutate their
+// receiver rather than returning a fresh value, so a call to one of them is a
+// write even though no assignment target names the binding.
+const MUTATING_METHOD_NAMES = new Set([
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+    'fill',
+    'copyWithin',
+]);
+/**
+ * Climbs out of the wrappers that denote the same value as `node` — type
+ * wrappers (`(X as any).push()`, `X!.push()`) and the `ChainExpression` an
+ * optional access hangs on the outside of the whole chain (`delete X?.a`). The
+ * role a node plays in its statement is decided by the outermost such wrapper,
+ * so a classifier that reads `node.parent` directly answers for the wrapper
+ * instead of the access.
+ */
+const outermostValueOf = (node) => {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (parent &&
+            ((isValueWrapper(parent) && parent.expression === current) ||
+                (parent.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                    parent.expression === current))) {
+            current = parent;
+            continue;
+        }
+        return current;
+    }
+};
+/**
+ * The outermost property-access path rooted at `identifier`: `X` in `X.a.b`
+ * yields the `X.a.b` member expression. Returns `null` when the identifier is
+ * not the base of any access, which is every reference that merely reads the
+ * binding as a value — `other.push(X)` passes it as an ARGUMENT, so the
+ * mutation happens to `other`, not to `X`.
+ *
+ * The climb stops at the first parent that is not a member access on the
+ * current node, so `X.map(f).push(1)` yields `X.map`: the mutated receiver
+ * there is the array `map` returned, not `X`.
+ */
+const accessPathOf = (identifier) => {
+    let current = outermostValueOf(identifier);
+    let path = null;
+    for (;;) {
+        const parent = current.parent;
+        if (!parent ||
+            parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+            parent.object !== current) {
+            return path;
+        }
+        path = parent;
+        current = outermostValueOf(parent);
+    }
+};
+/** The property name an access reads, for `X.push` and `X['push']` alike. */
+const accessedPropertyName = (path) => {
+    if (!path.computed && path.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return path.property.name;
+    }
+    if (path.computed &&
+        path.property.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof path.property.value === 'string') {
+        return path.property.value;
+    }
+    return null;
+};
+const isMutatingMethodCall = (path) => {
+    const propertyName = accessedPropertyName(path);
+    if (propertyName === null || !MUTATING_METHOD_NAMES.has(propertyName)) {
+        return false;
+    }
+    const callee = outermostValueOf(path);
+    return (callee.parent?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        callee.parent.callee === callee);
+};
+/**
+ * Whether `node` sits in a position that writes to it: the left of an
+ * assignment (plain or compound), the operand of `++`/`--` or `delete`, the
+ * loop variable of `for…in`/`for…of`, or a slot in a destructuring assignment
+ * target (`[X.a] = […]`, `({ p: X.a } = …)`).
+ */
+const isWriteTarget = (node) => {
+    const value = outermostValueOf(node);
+    const parent = value.parent;
+    if (!parent) {
+        return false;
+    }
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.AssignmentExpression:
+            return parent.left === value;
+        case utils_1.AST_NODE_TYPES.UpdateExpression:
+            return parent.argument === value;
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            return parent.operator === 'delete' && parent.argument === value;
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+            return parent.left === value;
+        // Destructuring targets nest, so the answer belongs to the pattern's own
+        // position. The same node types appear in ObjectExpression/ArrayExpression
+        // VALUES, where the recursion reaches a non-assignment parent and stops.
+        case utils_1.AST_NODE_TYPES.ArrayPattern:
+        case utils_1.AST_NODE_TYPES.ObjectPattern:
+        case utils_1.AST_NODE_TYPES.Property:
+        case utils_1.AST_NODE_TYPES.RestElement:
+        case utils_1.AST_NODE_TYPES.AssignmentPattern:
+            return isWriteTarget(parent);
+        default:
+            return false;
+    }
+};
+/**
+ * Whether the binding is written through anywhere in the file. Answered from
+ * the scope manager's reference list rather than a textual search for the
+ * name, so a same-named binding in another scope (`const arr` shadowed inside a
+ * callback) contributes nothing, and a same-named method on an unrelated
+ * receiver (`other.push(1)`) is never even visited.
+ */
+const isBindingMutated = (variable) => variable.references.some((reference) => {
+    const path = accessPathOf(reference.identifier);
+    return path !== null && (isMutatingMethodCall(path) || isWriteTarget(path));
+});
 /**
  * Walks the scope chain upward from `scope` (inclusive) and reports whether
  * `targetName` is bound anywhere between `scope` and `stopScope` (inclusive).
@@ -366,9 +499,22 @@ exports.default = (0, createRule_1.createRule)({
                                 (target.value === null || typeof target.value === 'boolean')) {
                                 return false;
                             }
-                            return (target.type === utils_1.AST_NODE_TYPES.Literal ||
-                                target.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
-                                target.type === utils_1.AST_NODE_TYPES.ObjectExpression);
+                            if (target.type !== utils_1.AST_NODE_TYPES.Literal &&
+                                target.type !== utils_1.AST_NODE_TYPES.ArrayExpression &&
+                                target.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                                return false;
+                            }
+                            // A binding that is mutated later can never take the assertion:
+                            // `as const` types the value `readonly`, so the appended text
+                            // turns working code into TS2339/TS2540 (Issue #2013). The
+                            // report is withheld rather than merely the fix, on the same
+                            // terms as the `null`/boolean carve-out above — a violation no
+                            // legal edit can clear is not a violation. The rename is a
+                            // separate concern and still applies.
+                            const declaredVariable = context
+                                .getDeclaredVariables(declaration)
+                                .find((variable) => variable.name === name);
+                            return !declaredVariable || !isBindingMutated(declaredVariable);
                         };
                         if (shouldHaveAsConst(init)) {
                             context.report({

package/lib/rules/no-explicit-return-type.js

@@ -713,6 +713,104 @@ function declaresVoidResult(returnType) {
     return (typeArguments?.length === 1 &&
         typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
 }
+// TypeScript's built-in decorator signatures. A factory annotated with one of
+// these is the one shape where the annotation is WIDER than what inference
+// produces rather than a restatement of it: `MethodDecorator` accepts three
+// parameters, the returned closure typically declares none, and a decoration
+// site requires the declared arity. Stripping the annotation therefore turns
+// every `@Factory()` use into TS1329 (#2014).
+const DECORATOR_TYPE_NAMES = new Set([
+    'ClassDecorator',
+    'MethodDecorator',
+    'ParameterDecorator',
+    'PropertyDecorator',
+]);
+/**
+ * The identifier a type name resolves to. A qualified name (`ts.MethodDecorator`)
+ * denotes the type its right-most segment names, so that segment is what decides
+ * — a substring test over the printed annotation would equally match
+ * `MyMethodDecoratorConfig`, which is an unrelated user type.
+ */
+function rightmostTypeName(typeName) {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return typeName.name;
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return rightmostTypeName(typeName.right);
+    }
+    return undefined;
+}
+function namesDecoratorType(annotation) {
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const name = rightmostTypeName(annotation.typeName);
+        return name !== undefined && DECORATOR_TYPE_NAMES.has(name);
+    }
+    // A factory usable in more than one position (`ClassDecorator &
+    // MethodDecorator`) still owes every decoration site the declared shape.
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+        annotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        return annotation.types.some(namesDecoratorType);
+    }
+    return false;
+}
+/**
+ * The identifier a CALLED decorator invokes: `Log` for `@Log()` and `@Log()()`.
+ *
+ * Only a called decorator identifies a factory, and only a factory's return type
+ * is what the decoration site consumes. A bare `@Log` names the decorator
+ * itself, whose annotation restates the value it returns exactly as inference
+ * would — so it stays reportable rather than being silenced by proximity to a
+ * decorator.
+ *
+ * An owner-qualified decorator (`@registry.log()`) names a property rather than
+ * a binding, and matching it by property name alone would silence the rule on
+ * every unrelated method of the same name, so it yields nothing.
+ */
+function decoratorFactoryIdentifier(expression) {
+    if (expression.type !== utils_1.AST_NODE_TYPES.CallExpression)
+        return undefined;
+    const callee = expression.callee;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee;
+    }
+    return decoratorFactoryIdentifier(callee);
+}
+/**
+ * The declarations invoked by a decorator in this file.
+ *
+ * This catches the factory whose annotation is a user-defined decorator type
+ * (`type Cached = (t: object, k: string, d: PropertyDescriptor) => void`), which
+ * no name test can recognise. Each identifier is resolved through the scope
+ * manager rather than compared by name, so a same-named binding elsewhere in the
+ * file cannot silence the rule on a function no decorator actually reaches.
+ */
+function decoratorReferencedDeclarations(source, visitorKeys) {
+    const heads = new Set();
+    const stack = [source.ast];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.type === utils_1.AST_NODE_TYPES.Decorator) {
+            const head = decoratorFactoryIdentifier(current.expression);
+            if (head) {
+                heads.add(head);
+            }
+        }
+        pushChildren(current, visitorKeys, stack);
+    }
+    const declarations = new Set();
+    if (heads.size === 0)
+        return declarations;
+    for (const scope of source.scopeManager?.scopes ?? []) {
+        for (const reference of scope.references) {
+            if (!heads.has(reference.identifier))
+                continue;
+            for (const definition of reference.resolved?.defs ?? []) {
+                declarations.add(definition.node);
+            }
+        }
+    }
+    return declarations;
+}
 function containsRange(outer, inner) {
     return inner[0] >= outer[0] && inner[1] <= outer[1];
 }
@@ -967,6 +1065,40 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
         // Edges are resolved lazily, and only for functions a direct
         // self-reference has already failed to explain.
         const participatesInReturnCycle = createReturnCycleResolver(visitorKeys);
+        // Decorators are visited after the functions they name — a class body is
+        // walked long after the top-level factory it decorates with — so the
+        // answer is computed from the whole tree rather than accumulated during
+        // the walk, and memoised because most files hold no decorator at all.
+        let decoratedDeclarations;
+        const declarationsNamedByDecorators = () => {
+            decoratedDeclarations ??= decoratorReferencedDeclarations(sourceCode, visitorKeys);
+            return decoratedDeclarations;
+        };
+        /**
+         * True when the annotation is what makes the function usable in a
+         * decorator position. TypeScript infers the concrete closure the factory
+         * returns — `() => void` for `return () => {};` — which declares fewer
+         * parameters than a decoration site passes, so removing the annotation
+         * turns every `@Factory()` use into TS1329 (#2014).
+         *
+         * The question is answered syntactically. A `RuleTester` fixture carries
+         * no `parserOptions.project`, so a type-based answer would be untestable
+         * and would silently no-op wherever consumers lint without a program.
+         */
+        function isDecoratorFactory(node, returnType) {
+            if (namesDecoratorType(returnType.typeAnnotation))
+                return true;
+            const declarations = declarationsNamedByDecorators();
+            if (declarations.size === 0)
+                return false;
+            if (declarations.has(node))
+                return true;
+            // `const Log = (): Cached => ...` is bound by its declarator, which is
+            // what a decorator's identifier resolves to.
+            const parent = node.parent;
+            return (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                declarations.has(parent));
+        }
         /**
          * True when TypeScript cannot infer the return type because the function
          * is referenced from within its own return expression (TS7023). Removing
@@ -1100,6 +1232,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isDecoratorFactory(node, returnType) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {
@@ -1117,6 +1250,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isDecoratorFactory(node, returnType) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {
@@ -1131,6 +1265,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isDecoratorFactory(node, returnType) ||
                     isReturnTypeRequiredByRecursion(node)) {
                     return;
                 }
@@ -1156,6 +1291,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node.value) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isDecoratorFactory(node, returnType) ||
                     (mergedOptions.allowAbstractMethodSignatures &&
                         isInterfaceOrAbstractMethodSignature(node)) ||
                     isReturnTypeRequiredByRecursion(node)) {

package/lib/rules/prefer-clone-deep.js

@@ -25,6 +25,41 @@ function isCloneDeepModule(source) {
         source.startsWith('@/') ||
         source.endsWith('util/cloneDeep'));
 }
+function isConstAssertion(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+        node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.typeAnnotation.typeName.name === 'const');
+}
+/**
+ * A `const` assertion is legal only on a literal, so leaving one wrapped around
+ * the emitted `cloneDeep(...)` call yields TS1355 and turns a compiling file
+ * into a broken one (#2011). The fix is declined there rather than absorbing
+ * the assertion, which is the conservative reading of a `const` the author
+ * asked for on a value this rule replaces.
+ *
+ * The whole assertion chain is walked because each of its links still applies
+ * to the emitted call: `as Foo as const`, `satisfies Foo as const` and
+ * `! as const` are TS1355 just the same. The walk stops at the first parent
+ * that is not an assertion, which keeps `as const` on an ENCLOSING literal
+ * fixable — that assertion still has a literal to apply to.
+ *
+ * Only a `const` assertion is disqualifying: `as Foo` and `satisfies Foo` are
+ * legal on a call expression and keep their fix.
+ */
+function isConstAsserted(node) {
+    let current = node.parent;
+    while (current &&
+        (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+            current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+            current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+        if (isConstAssertion(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 exports.preferCloneDeep = (0, createRule_1.createRule)({
     name: 'prefer-clone-deep',
     meta: {
@@ -444,6 +479,9 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                                     return null;
                                 }
                                 for (const target of targets) {
+                                    if (isConstAsserted(target)) {
+                                        return null;
+                                    }
                                     const call = buildCloneDeepCall(target);
                                     if (call === null) {
                                         return null;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,64 @@
 [
+  {
+    "version": "1.20.153",
+    "date": "2026-08-14T20:21:23.691Z",
+    "rules": [
+      {
+        "name": "enforce-boolean-naming-prefixes",
+        "changeType": "fix",
+        "issues": [
+          2016
+        ],
+        "summary": "decline when the use site contradicts the callee's name (closes #2016)"
+      },
+      {
+        "name": "enforce-object-literal-as-const",
+        "changeType": "fix",
+        "issues": [
+          2015
+        ],
+        "summary": "keep an unannotated returned array unfrozen (closes #2015)"
+      },
+      {
+        "name": "global-const-style",
+        "changeType": "fix",
+        "issues": [
+          2013
+        ],
+        "summary": "decline the as const when the binding is mutated later (closes #2013)"
+      },
+      {
+        "name": "no-explicit-return-type",
+        "changeType": "fix",
+        "issues": [
+          2014
+        ],
+        "summary": "keep a decorator factory's annotation (closes #2014)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.152",
+    "date": "2026-08-14T10:28:08.765Z",
+    "rules": [
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          2012
+        ],
+        "summary": "carry each key's import on its own fix (closes #2012)"
+      },
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          2011
+        ],
+        "summary": "decline the fix under a const assertion (closes #2011)"
+      }
+    ]
+  },
   {
     "version": "1.20.151",
     "date": "2026-08-14T02:27:13.012Z",