@blumintinc/eslint-plugin-blumint 1.20.104 → 1.20.106

package/lib/index.js

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

package/lib/rules/consistent-callback-naming.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"callbackPropPrefix" | "callbackFunctionPrefix", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"callbackPropPrefix" | "callbackFunctionPrefix", [], TSESLint.RuleListener>;
 export = _default;

package/lib/rules/consistent-callback-naming.js

@@ -39,6 +39,183 @@ const ts = __importStar(require("typescript"));
 function hasHandlePrefix(name) {
     return /^handle[A-Z]/.test(name);
 }
+function stripHandlePrefix(name) {
+    return name.slice(6).charAt(0).toLowerCase() + name.slice(7);
+}
+// Stripping the prefix can land the rename squarely on a keyword:
+// `handleDelete` -> `delete`, `handleNew` -> `new`, `handleReturn` -> `return`,
+// `handleTrue` -> `true`. None of those is a legal binding name, so a fix that
+// emits one turns a working file into a parse error — `const delete = fn` and
+// `const { delete } = api` are both SyntaxErrors (Bug #1719). The set covers the
+// ES reserved words, the strict-mode/module reserved words (the linted codebase
+// is entirely ES modules, where `await` and `implements` et al. are reserved
+// too) and the three keyword literals. The guard is applied at every emission
+// site, including member names where a keyword happens to be legal
+// (`class C { delete() {} }`): the rule cannot see whether that member is later
+// destructured into a binding, and a fixer that is safe only sometimes is not
+// safe.
+const RESERVED_WORDS = new Set([
+    'arguments',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+function isEmittableName(name) {
+    return name.length > 0 && !RESERVED_WORDS.has(name);
+}
+function isExportedDeclaration(node) {
+    let current = node;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+// An object literal that is exported or returned is a value other modules read
+// by member name (`api.handleOpenThread`, `const { handleOpenThread } = useX()`).
+// Renaming a member of it edits one end of a contract whose readers live in
+// files a single-file fixer cannot even see, so the violation is reported
+// without a fix — the same reasoning that withholds the JSX prop rename.
+function isApiSurfaceValue(node) {
+    let child = node;
+    let current = node.parent;
+    while (current) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.ExportNamedDeclaration:
+            case utils_1.AST_NODE_TYPES.ExportDefaultDeclaration:
+            case utils_1.AST_NODE_TYPES.ReturnStatement:
+                return true;
+            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                // A concise body is a return with no `return` keyword.
+                return current.body === child;
+            case utils_1.AST_NODE_TYPES.BlockStatement:
+            case utils_1.AST_NODE_TYPES.ClassBody:
+            case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+            case utils_1.AST_NODE_TYPES.Program:
+                return false;
+            default:
+                child = current;
+                current = current.parent;
+        }
+    }
+    return false;
+}
+/** The member names already declared alongside `node`, keyed by identifier. */
+function siblingMemberNames(node) {
+    const names = new Set();
+    const record = (member) => {
+        const key = member.key;
+        if (!member.computed &&
+            key?.type === utils_1.AST_NODE_TYPES.Identifier) {
+            names.add(key.name);
+        }
+    };
+    if (node?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+        node.properties.forEach(record);
+    }
+    else if (node?.type === utils_1.AST_NODE_TYPES.ClassBody) {
+        node.body.forEach(record);
+    }
+    return names;
+}
+/**
+ * Every member name the file reads by name — `obj.handleClick`,
+ * `obj['handleClick']`, `const { handleClick } = obj`.
+ *
+ * Renaming an object literal's key has to move every one of those reads with
+ * it, and a fixer scoped to the literal moves none of them: `const o = { click:
+ * fn }; o.handleClick()` type-checks as a missing property and throws at
+ * runtime. The presence of any reader therefore withholds the rewrite. The walk
+ * is over the whole program because a reader may appear anywhere, including
+ * before the literal.
+ */
+function collectMemberReads(program, visitorKeys) {
+    const names = new Set();
+    const stack = [program];
+    const push = (value) => {
+        if (Array.isArray(value)) {
+            value.forEach(push);
+        }
+        else if (value && typeof value === 'object' && 'type' in value) {
+            stack.push(value);
+        }
+    };
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            if (!node.computed && node.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                names.add(node.property.name);
+            }
+            else if (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.property.value === 'string') {
+                names.add(node.property.value);
+            }
+        }
+        // Read directly off the pattern rather than through `parent`, which is not
+        // guaranteed to be assigned on nodes the traversal has not reached.
+        if (node.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+            for (const property of node.properties) {
+                if (property.type === utils_1.AST_NODE_TYPES.Property &&
+                    !property.computed &&
+                    property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    names.add(property.key.name);
+                }
+            }
+        }
+        for (const key of visitorKeys[node.type] ?? []) {
+            push(node[key]);
+        }
+    }
+    return names;
+}
 module.exports = (0, createRule_1.createRule)({
     name: 'consistent-callback-naming',
     meta: {
@@ -200,6 +377,101 @@ module.exports = (0, createRule_1.createRule)({
             // that includes a void-returning signature keeps the handler semantics.
             return signatures.every((signature) => !returnsVoidLike(checker.getReturnTypeOfSignature(signature)));
         }
+        // Built once per file, and only when an object literal member is actually a
+        // rename candidate.
+        let memberReads;
+        function isReadByName(name) {
+            const sourceCode = context.getSourceCode();
+            memberReads ??= collectMemberReads(sourceCode.ast, sourceCode.visitorKeys);
+            return memberReads.has(name);
+        }
+        /**
+         * The variable a pattern identifier binds. `getDeclaredVariables` is
+         * authoritative — it is asked of the declaring ancestor (the
+         * `VariableDeclaration`, the function owning a destructured parameter, the
+         * `CatchClause`) rather than reconstructed by crawling scopes by name,
+         * which cannot tell two same-named bindings apart.
+         */
+        function findPatternVariable(id) {
+            let current = id.parent;
+            while (current) {
+                const match = context
+                    .getDeclaredVariables(current)
+                    .find((variable) => variable.identifiers.includes(id));
+                if (match) {
+                    return match;
+                }
+                current = current.parent;
+            }
+            return undefined;
+        }
+        // Renaming a binding that leaves the module — `export const { a: handleX }`,
+        // or `export { handleX }` — breaks importers the fixer cannot edit.
+        function isExportedBinding(variable) {
+            const namedByExportSpecifier = (id) => id.parent?.type === utils_1.AST_NODE_TYPES.ExportSpecifier;
+            return (variable.references.some((ref) => namedByExportSpecifier(ref.identifier)) ||
+                variable.identifiers.some(namedByExportSpecifier) ||
+                variable.defs.some((def) => isExportedDeclaration(def.node)));
+        }
+        // A rename that collides with a name already visible where the binding (or
+        // any of its references) lives silently re-points those references at the
+        // other declaration.
+        function isNameTaken(variable, newName) {
+            let scope = variable.scope;
+            while (scope) {
+                if (scope.set.has(newName)) {
+                    return true;
+                }
+                scope = scope.upper;
+            }
+            return variable.scope.childScopes.some((child) => child.set.has(newName));
+        }
+        /**
+         * A `Property` inside an `ObjectPattern`. Its key names a property of the
+         * object being destructured — someone else's API (`const { handleDelete: fn }
+         * = useMessage('handleDelete')` reads Stream Chat's own member) — so
+         * rewriting the key changes WHICH property is read, strands every reader of
+         * the old name, and can emit a keyword that is not a legal binding
+         * (Bug #1719). The key is therefore never reported and never rewritten. The
+         * only name the file owns here is the local binding, so that is what the
+         * report targets when it too carries the prefix.
+         */
+        function reportDestructuredBinding(node) {
+            // A shorthand binding is a single token that is simultaneously the
+            // foreign property name and the local name: there is no name the file
+            // chose independently, and no in-place edit can change one without the
+            // other. Left alone entirely rather than reported with no remedy.
+            if (node.shorthand || node.value.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const binding = node.value;
+            if (!hasHandlePrefix(binding.name)) {
+                return;
+            }
+            const newName = stripHandlePrefix(binding.name);
+            const variable = findPatternVariable(binding);
+            const canFix = isEmittableName(newName) &&
+                !!variable &&
+                !isExportedBinding(variable) &&
+                !isNameTaken(variable, newName);
+            context.report({
+                node: binding,
+                messageId: 'callbackFunctionPrefix',
+                data: { functionName: binding.name },
+                fix(fixer) {
+                    if (!canFix || !variable) {
+                        return null;
+                    }
+                    // Every occurrence in one edit: a rename that reaches the declaration
+                    // but not its readers is worse than no rename at all.
+                    const targets = new Set([binding]);
+                    for (const ref of variable.references) {
+                        targets.add(ref.identifier);
+                    }
+                    return [...targets].map((id) => fixer.replaceText(id, newName));
+                },
+            });
+        }
         return {
             // Check JSX attributes for callback props
             JSXAttribute(node) {
@@ -341,8 +613,12 @@ module.exports = (0, createRule_1.createRule)({
                         data: { functionName },
                         fix(fixer) {
                             // Remove 'handle' prefix and convert first character to lowercase
-                            const newName = functionName.slice(6).charAt(0).toLowerCase() +
-                                functionName.slice(7);
+                            const newName = stripHandlePrefix(functionName);
+                            // `const handleDelete = fn` would become `const delete = fn`,
+                            // which does not parse (Bug #1719).
+                            if (!isEmittableName(newName)) {
+                                return null;
+                            }
                             // Fix the declaration and all references
                             const fixes = [];
                             fixes.push(fixer.replaceText(node.id, newName));
@@ -358,30 +634,50 @@ module.exports = (0, createRule_1.createRule)({
             },
             // Check class methods and object methods
             'MethodDefinition, Property'(node) {
-                if (node.key.type === 'Identifier' &&
-                    node.key.name &&
-                    hasHandlePrefix(node.key.name)) {
-                    const name = node.key.name;
-                    // Skip autofixing for class parameters and getters
-                    if (node.type === 'MethodDefinition' && node.kind === 'get') {
-                        context.report({
-                            node: node.key,
-                            messageId: 'callbackFunctionPrefix',
-                            data: { functionName: name },
-                        });
-                        return;
-                    }
+                const key = node.key;
+                if (key.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !key.name ||
+                    !hasHandlePrefix(key.name)) {
+                    return;
+                }
+                const name = key.name;
+                // Skip autofixing for class parameters and getters
+                if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    node.kind === 'get') {
                     context.report({
-                        node: node.key,
+                        node: key,
                         messageId: 'callbackFunctionPrefix',
                         data: { functionName: name },
-                        fix(fixer) {
-                            // Remove 'handle' prefix and convert first character to lowercase
-                            const newName = name.slice(6).charAt(0).toLowerCase() + name.slice(7);
-                            return fixer.replaceText(node.key, newName);
-                        },
                     });
+                    return;
+                }
+                const isProperty = node.type === utils_1.AST_NODE_TYPES.Property;
+                if (isProperty && node.parent?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    reportDestructuredBinding(node);
+                    return;
                 }
+                const newName = stripHandlePrefix(name);
+                // A shorthand property's key and value are the same token, so replacing
+                // the key also replaces the value: `{ handleClick }` becomes
+                // `{ click }`, which both renames the member and re-points it at a
+                // binding that need not exist (Bug #1719).
+                const canFix = isEmittableName(newName) &&
+                    // A sibling already holding the target name turns the rename into a
+                    // duplicate member: `{ click: a, handleClick: b }` would collapse to
+                    // two `click` keys, silently discarding the first.
+                    !siblingMemberNames(node.parent).has(newName) &&
+                    !(isProperty && node.shorthand) &&
+                    !(isProperty &&
+                        node.parent &&
+                        (isApiSurfaceValue(node.parent) || isReadByName(name)));
+                context.report({
+                    node: key,
+                    messageId: 'callbackFunctionPrefix',
+                    data: { functionName: name },
+                    fix(fixer) {
+                        return canFix ? fixer.replaceText(key, newName) : null;
+                    },
+                });
             },
             // Check constructor parameters
             TSParameterProperty(node) {

package/lib/rules/enforce-dynamic-firebase-imports.d.ts

@@ -1,5 +1,5 @@
-import { TSESTree } from '@typescript-eslint/utils';
-declare const enforceFirebaseImports: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noDynamicImport", never[], {
+import { TSESLint, TSESTree } from '@typescript-eslint/utils';
+declare const enforceFirebaseImports: TSESLint.RuleModule<"noDynamicImport", never[], {} | {
     ImportDeclaration(node: TSESTree.ImportDeclaration): void;
 }>;
 export default enforceFirebaseImports;

package/lib/rules/enforce-dynamic-firebase-imports.js

@@ -1,6 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression;
+/**
+ * Walks outward from a reference to the innermost `async` function whose block
+ * body contains it.
+ *
+ * A reference sitting in a *synchronous* callback nested inside an async
+ * function still resolves once the declaration heads the async body, because
+ * the callback cannot run before the first statement of the body it is created
+ * in — so the walk continues past non-async functions rather than giving up.
+ *
+ * The containment check is against the body rather than the function: a
+ * reference in a parameter default or a signature type annotation is evaluated
+ * before the body runs, so a declaration at the top of the body would come too
+ * late for it.
+ */
+const enclosingAsyncBodyOf = (identifier) => {
+    let current = identifier.parent;
+    while (current) {
+        if (isFunctionNode(current) &&
+            current.async &&
+            current.body.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+            identifier.range[0] >= current.body.range[0] &&
+            identifier.range[1] <= current.body.range[1]) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+};
+const THIRD_PARTY_DIRECTORY = /(^|\/)node_modules(\/|$)/;
+// Anchored at the end of the path so multi-part suffixes such as
+// `useStartMatch.integration.test.ts` are recognized while production modules
+// that merely contain the word (`latest.tsx`, `contest.ts`, `testHelpers.ts`)
+// keep their enforcement.
+const TEST_FILE_SUFFIX = /\.(test|spec)\.[cm]?[jt]sx?$/;
+// Jest convention directories hold test-only modules regardless of file name.
+const TEST_FILE_DIRECTORY = /(^|\/)(__tests__|__mocks__)\//;
+/**
+ * The rule's rationale is bundle weight: a static import pulls Firebase into the
+ * initial client chunk. A suite, a Jest manual mock and a declaration file are
+ * never part of that chunk, so there is nothing to inflate and the rule has
+ * nothing to enforce there.
+ *
+ * The exemption is load-bearing rather than cosmetic because the rule is
+ * fixable: a suite's static binding is exactly what `jest.mock()` hoisting
+ * intercepts, and rewriting it emits a module-scope `await import(...)` that a
+ * CommonJS test transform cannot even parse (issue #1715).
+ */
+const isNeverBundled = (filename) => filename.endsWith('.d.ts') ||
+    TEST_FILE_SUFFIX.test(filename) ||
+    TEST_FILE_DIRECTORY.test(filename);
 const enforceFirebaseImports = (0, createRule_1.createRule)({
     name: 'enforce-dynamic-firebase-imports',
     meta: {
@@ -13,18 +67,26 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
         hasSuggestions: true,
         schema: [],
         messages: {
-            noDynamicImport: 'Static import from firebaseCloud path "{{importPath}}" eagerly bundles Firebase code into the initial client chunk, which inflates startup time and prevents lazy loading. Replace it with an awaited dynamic import so the code only loads when invoked (e.g., `const module = await import(\'{{importPath}}\')` or destructure the exports you need).',
+            noDynamicImport: 'Static import from firebaseCloud path "{{importPath}}" eagerly bundles Firebase code into the initial client chunk, which inflates startup time and prevents lazy loading. Load it at the call site instead, inside an async function body (e.g., `const { export } = await import(\'{{importPath}}\')`). Keep it out of module scope: a top-level `await import(...)` defers nothing and does not parse once the module is compiled to CommonJS.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
+        // Normalize Windows backslash separators so the forward-slash directory
+        // checks match on every platform. Without this, `getFilename()` returns
+        // `C:\repo\src\hooks\__tests__\Foo.ts` on Windows and the exemption
+        // silently fails there.
+        const filename = (context.getFilename?.() ?? '').replace(/\\/g, '/');
+        // `<input>`/`<text>` are the synthetic names RuleTester uses when a case
+        // declares no filename. They match none of the exemptions below, so a
+        // snippet keeps its enforcement — unlike a path-gated rule, this one has no
+        // include list to fall outside of.
+        if (THIRD_PARTY_DIRECTORY.test(filename) || isNeverBundled(filename)) {
+            return {};
+        }
         return {
             ImportDeclaration(node) {
-                // Skip third-party files
-                const filename = context.getFilename?.();
-                if (filename && /(^|[\\/])node_modules([\\/]|$)/.test(filename)) {
-                    return;
-                }
                 // Skip type-only import declarations
                 if (node.importKind === 'type') {
                     return;
@@ -51,75 +113,152 @@ const enforceFirebaseImports = (0, createRule_1.createRule)({
                     ? spec.imported.name
                     : `${spec.imported.name} as ${spec.local.name}`)
                     .join(', ');
-                const buildReplacement = (options = {}) => {
-                    const statements = [];
-                    if (typeOnlySpecifiers.length > 0) {
-                        statements.push(`import type { ${buildTypeNames()} } from '${importPath}';`);
-                    }
+                const destructureEntry = (spec) => spec.imported.name === spec.local.name
+                    ? spec.local.name
+                    : `${spec.imported.name}: ${spec.local.name}`;
+                const buildValueStatements = () => {
                     if (namespaceSpecifier) {
                         const nsLocal = namespaceSpecifier.local.name;
-                        statements.push(`const ${nsLocal} = await import('${importPath}');`);
+                        const statements = [
+                            `const ${nsLocal} = await import('${importPath}');`,
+                        ];
                         if (defaultSpecifier) {
-                            const defLocal = defaultSpecifier.local.name;
-                            statements.push(`const ${defLocal} = ${nsLocal}.default;`);
+                            statements.push(`const ${defaultSpecifier.local.name} = ${nsLocal}.default;`);
                         }
-                        const destructureFromNamespace = [];
                         if (namedSpecifiers.length > 0) {
-                            const destructureParts = namedSpecifiers.map((spec) => {
-                                const imported = spec.imported.name;
-                                const local = spec.local.name;
-                                return imported === local ? imported : `${imported}: ${local}`;
-                            });
-                            destructureFromNamespace.push(...destructureParts);
+                            statements.push(`const { ${namedSpecifiers
+                                .map(destructureEntry)
+                                .join(', ')} } = ${nsLocal};`);
                         }
-                        if (destructureFromNamespace.length > 0) {
-                            statements.push(`const { ${destructureFromNamespace.join(', ')} } = ${nsLocal};`);
-                        }
-                        return statements.join(' ');
+                        return statements;
                     }
-                    const destructureParts = [];
-                    if (defaultSpecifier) {
-                        const defLocal = defaultSpecifier.local.name;
-                        destructureParts.push(`default: ${defLocal}`);
+                    const destructureParts = [
+                        ...(defaultSpecifier
+                            ? [`default: ${defaultSpecifier.local.name}`]
+                            : []),
+                        ...namedSpecifiers.map(destructureEntry),
+                    ];
+                    // A side-effect import binds nothing, so there is no declaration to
+                    // relocate — the awaited call would have to stay at module scope.
+                    return destructureParts.length > 0
+                        ? [
+                            `const { ${destructureParts.join(', ')} } = await import('${importPath}');`,
+                        ]
+                        : [];
+                };
+                /**
+                 * An `ImportDeclaration` only ever sits at module scope, so rewriting
+                 * it in place can only ever produce a module-scope `await import(...)`
+                 * — which defers nothing (the module still awaits it during
+                 * evaluation) and does not even parse once the file is compiled to
+                 * CommonJS, where top-level await does not exist (issue #1716).
+                 *
+                 * The rewrite is therefore only expressible when every value reference
+                 * lives in one async function body: the declaration can then head that
+                 * body, exactly the shape the codebase writes by hand. Anything else
+                 * is a per-call-site refactor the fixer declines rather than corrupts.
+                 */
+                const findRelocationTarget = () => {
+                    const valueLocalNames = new Set([
+                        defaultSpecifier?.local.name,
+                        namespaceSpecifier?.local.name,
+                        ...namedSpecifiers.map((spec) => spec.local.name),
+                    ].filter((name) => name !== undefined));
+                    const references = context
+                        .getDeclaredVariables(node)
+                        .filter((variable) => valueLocalNames.has(variable.name))
+                        .flatMap((variable) => variable.references);
+                    // Nothing reads the binding, so there is no call site to defer to.
+                    if (references.length === 0) {
+                        return undefined;
                     }
-                    if (namedSpecifiers.length > 0) {
-                        for (const spec of namedSpecifiers) {
-                            const imported = spec.imported.name;
-                            const local = spec.local.name;
-                            destructureParts.push(imported === local ? imported : `${imported}: ${local}`);
+                    let target;
+                    for (const reference of references) {
+                        const enclosing = enclosingAsyncBodyOf(reference.identifier);
+                        if (!enclosing || (target && target !== enclosing)) {
+                            return undefined;
                         }
+                        target = enclosing;
                     }
-                    if (destructureParts.length > 0) {
-                        statements.push(`const { ${destructureParts.join(', ')} } = await import('${importPath}');`);
-                        return statements.join(' ');
+                    return target;
+                };
+                const indentationAt = (line) => /^[ \t]*/.exec(sourceCode.lines[line - 1] ?? '')?.[0] ?? '';
+                /**
+                 * Consumes the import's own trailing whitespace, and its line break
+                 * when the import owns the line, so the removal strands neither a blank
+                 * line nor the indentation of whatever shared the line with it.
+                 * Anything that is not whitespace — a trailing comment, a statement —
+                 * is left untouched.
+                 */
+                const removalEnd = () => {
+                    const text = sourceCode.getText();
+                    let cursor = node.range[1];
+                    while (cursor < text.length &&
+                        (text[cursor] === ' ' || text[cursor] === '\t')) {
+                        cursor += 1;
+                    }
+                    if (text[cursor] === '\n') {
+                        return cursor + 1;
                     }
-                    if (node.specifiers.length === 0) {
-                        return options.allowSideEffectFix !== false
-                            ? `await import('${importPath}');`
-                            : null;
+                    if (text[cursor] === '\r' && text[cursor + 1] === '\n') {
+                        return cursor + 2;
+                    }
+                    return cursor;
+                };
+                const buildFix = (fixer) => {
+                    const target = findRelocationTarget();
+                    const statements = buildValueStatements();
+                    if (!target || statements.length === 0) {
+                        return null;
                     }
-                    return null;
+                    const body = target.body;
+                    // A directive stops being a directive the moment a declaration
+                    // precedes it, so `'use server'` on a server action would silently
+                    // become a discarded string expression. The declaration goes after
+                    // the whole prologue instead.
+                    const prologueLength = body.body.findIndex((statement) => statement.type !== utils_1.AST_NODE_TYPES.ExpressionStatement ||
+                        statement.expression.type !== utils_1.AST_NODE_TYPES.Literal ||
+                        typeof statement.expression.value !== 'string');
+                    const directives = body.body.slice(0, prologueLength === -1 ? body.body.length : prologueLength);
+                    const lastDirective = directives[directives.length - 1];
+                    const following = body.body[directives.length];
+                    const anchorLine = lastDirective
+                        ? lastDirective.loc.end.line
+                        : body.loc.start.line;
+                    const neighbour = following ?? lastDirective;
+                    // A body written on one line keeps its shape; a multi-line body gets
+                    // the declaration on its own line at the body's own indentation.
+                    const insertion = following && following.loc.start.line === anchorLine
+                        ? ` ${statements.join(' ')}`
+                        : statements
+                            .map((statement) => {
+                            const indent = neighbour
+                                ? indentationAt(neighbour.loc.start.line)
+                                : `${indentationAt(target.loc.start.line)}  `;
+                            return `\n${indent}${statement}`;
+                        })
+                            .join('');
+                    return [
+                        // Type-only specifiers are erased at compile time, so they stay
+                        // where they are instead of riding along into the function body.
+                        typeOnlySpecifiers.length > 0
+                            ? fixer.replaceText(node, `import type { ${buildTypeNames()} } from '${importPath}';`)
+                            : fixer.removeRange([node.range[0], removalEnd()]),
+                        lastDirective
+                            ? fixer.insertTextAfter(lastDirective, insertion)
+                            : fixer.insertTextAfterRange([body.range[0], body.range[0] + 1], insertion),
+                    ];
                 };
                 context.report({
                     node,
                     messageId: 'noDynamicImport',
                     data: { importPath },
-                    fix(fixer) {
-                        const replacement = buildReplacement();
-                        return replacement ? fixer.replaceText(node, replacement) : null;
-                    },
+                    fix: buildFix,
                     suggest: [
                         {
                             messageId: 'noDynamicImport',
                             data: { importPath },
-                            fix(fixer) {
-                                const replacement = buildReplacement({
-                                    allowSideEffectFix: true,
-                                });
-                                return replacement
-                                    ? fixer.replaceText(node, replacement)
-                                    : null;
-                            },
+                            fix: buildFix,
                         },
                     ],
                 });

package/lib/rules/enforce-empty-object-check.js

@@ -215,6 +215,20 @@ function isObjectLikeType(type, checker) {
     if (type.getCallSignatures().length > 0) {
         return 'non-object';
     }
+    /**
+     * A construct-signature-only type — a class reference, a `…Constructor<P>`
+     * interface, the `ComponentClass` half of `ComponentType` — carries behaviour,
+     * not data. Its own properties are statics, so `Object.keys()` is `[]` for a
+     * plain class or component even when a valid value was supplied, and the
+     * emptiness check this rule prescribes would invert the guard rather than
+     * harden it. Unions reach this branch through the recursive call above, which
+     * matters because a union counts as an object when ANY member does: without
+     * this, the constructor half alone classified a whole `ComponentType` union as
+     * a data object.
+     */
+    if (type.getConstructSignatures().length > 0) {
+        return 'non-object';
+    }
     if (hasRequiredProperties(type, checker)) {
         return 'non-object';
     }

package/lib/rules/memoize-root-level-hocs.d.ts

@@ -1,7 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         additionalHocNames?: string[];
     }
 ];
-export declare const memoizeRootLevelHocs: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"wrapHocInUseMemo", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const memoizeRootLevelHocs: TSESLint.RuleModule<"wrapHocInUseMemo", Options, TSESLint.RuleListener>;
 export {};

package/lib/rules/memoize-root-level-hocs.js

@@ -121,26 +121,150 @@ const getCallableIdentifierName = (callee) => {
     }
     return null;
 };
-const isHocIdentifier = (name, additionalHocs) => {
-    if (additionalHocs.has(name)) {
-        return true;
-    }
+const hasHocNameShape = (name) => {
     if (!name.startsWith('with')) {
         return false;
     }
     const suffix = name.charAt(4);
     return Boolean(suffix) && /^[A-Z]$/.test(suffix);
 };
-const findHocName = (node, additionalHocs) => {
+/**
+ * Strips wrappers that carry no runtime meaning so a component argument stays
+ * recognizable behind `as`, `!`, `satisfies` and optional-chaining nodes.
+ */
+const unwrapExpression = (node) => {
+    let current = node;
+    for (;;) {
+        if (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.type === utils_1.AST_NODE_TYPES.TSInstantiationExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+};
+const findHocNameMatch = (node, additionalHocs) => {
     const identifier = getCallableIdentifierName(node.callee);
-    if (identifier && isHocIdentifier(identifier, additionalHocs)) {
-        return identifier;
+    if (identifier) {
+        if (additionalHocs.has(identifier)) {
+            return { name: identifier, configured: true };
+        }
+        if (hasHocNameShape(identifier)) {
+            return { name: identifier, configured: false };
+        }
     }
-    if (node.callee.type === utils_1.AST_NODE_TYPES.CallExpression) {
-        return findHocName(node.callee, additionalHocs);
+    const callee = unwrapExpression(node.callee);
+    if (callee.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        return findHocNameMatch(callee, additionalHocs);
     }
     return null;
 };
+/**
+ * Collects the arguments of every call in a curried chain, so the component
+ * passed to `withStyles(styles)(Component)` still counts as evidence for the
+ * outer call even though it names the HOC through its callee.
+ */
+const collectCallChainArguments = (node) => {
+    const args = [];
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        args.push(...current.arguments);
+        current = unwrapExpression(current.callee);
+    }
+    return args;
+};
+/**
+ * A `with[A-Z]…` name alone says nothing: string utilities such as
+ * `withOpacity(color, 0.3)` share the shape. Reporting requires positive
+ * structural evidence that the call operates on a component.
+ */
+const isComponentEvidence = (node, ctx) => {
+    const target = unwrapExpression(node);
+    if (ctx.visiting.has(target)) {
+        return false;
+    }
+    ctx.visiting.add(target);
+    try {
+        switch (target.type) {
+            case utils_1.AST_NODE_TYPES.Identifier:
+                return (isComponentName(target.name) || resolvesToComponentValue(target, ctx));
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                return (!target.computed &&
+                    target.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    isComponentName(target.property.name));
+            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+            case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                return containsJsx(getBodyNodeForJsxCheck(target));
+            case utils_1.AST_NODE_TYPES.ClassExpression:
+            case utils_1.AST_NODE_TYPES.ClassDeclaration:
+                return true;
+            case utils_1.AST_NODE_TYPES.CallExpression:
+                return getHocName(target, ctx) !== null;
+            case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                return (isComponentEvidence(target.consequent, ctx) ||
+                    isComponentEvidence(target.alternate, ctx));
+            case utils_1.AST_NODE_TYPES.LogicalExpression:
+                return (isComponentEvidence(target.left, ctx) ||
+                    isComponentEvidence(target.right, ctx));
+            case utils_1.AST_NODE_TYPES.SpreadElement:
+                return isComponentEvidence(target.argument, ctx);
+            default:
+                return false;
+        }
+    }
+    finally {
+        ctx.visiting.delete(target);
+    }
+};
+/**
+ * Resolves a lowercase argument through scope analysis rather than assuming it
+ * might be a component. Component bindings are conventionally capitalized, so a
+ * lowercase name only counts when its declaration proves it holds a component —
+ * which keeps `withPortal(build)` reported while leaving `withOpacity(color,
+ * 0.3)` alone. A binding the scope cannot resolve (an import, a parameter, a
+ * global) proves nothing and is therefore not evidence.
+ */
+const resolvesToComponentValue = (identifier, ctx) => {
+    const variable = ctx.resolveVariable(identifier);
+    if (!variable) {
+        return false;
+    }
+    return variable.defs.some((def) => {
+        const defNode = def.node;
+        if (defNode.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+            return (defNode.id === def.name &&
+                Boolean(defNode.init) &&
+                isComponentEvidence(defNode.init, ctx));
+        }
+        // A parameter definition shares its node with the enclosing function, so the
+        // function's own JSX must not be credited to the parameter.
+        if (defNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            return (defNode.id === def.name && containsJsx(getBodyNodeForJsxCheck(defNode)));
+        }
+        if (defNode.type === utils_1.AST_NODE_TYPES.ClassDeclaration) {
+            return defNode.id === def.name;
+        }
+        return false;
+    });
+};
+const getHocName = (node, ctx) => {
+    const match = findHocNameMatch(node, ctx.additionalHocs);
+    if (!match) {
+        return null;
+    }
+    // An explicitly configured name is a deliberate opt-in, so it is trusted
+    // without any structural confirmation.
+    if (match.configured) {
+        return match.name;
+    }
+    const hasEvidence = collectCallChainArguments(node).some((argument) => isComponentEvidence(argument, ctx));
+    return hasEvidence ? match.name : null;
+};
 /**
  * Detects chained HOC calls where an inner call is immediately invoked by
  * another call (for example, withHoc(Component)()). We only treat calls as
@@ -183,6 +307,38 @@ exports.memoizeRootLevelHocs = (0, createRule_1.createRule)({
     defaultOptions,
     create(context, [options]) {
         const additionalHocs = new Set(options?.additionalHocNames ?? []);
+        const sourceCode = context.getSourceCode();
+        /**
+         * Walks outward to the nearest scope owning the identifier, then up the
+         * scope chain. Acquiring scopes from the node keeps resolution independent
+         * of where the traversal currently sits.
+         */
+        const resolveVariable = (identifier) => {
+            const { scopeManager } = sourceCode;
+            if (!scopeManager) {
+                return null;
+            }
+            let scope = null;
+            let current = identifier;
+            while (current && !scope) {
+                scope = scopeManager.acquire(current, true);
+                current = current.parent;
+            }
+            scope = scope ?? scopeManager.globalScope;
+            while (scope) {
+                const variable = scope.variables.find((candidate) => candidate.name === identifier.name);
+                if (variable) {
+                    return variable;
+                }
+                scope = scope.upper;
+            }
+            return null;
+        };
+        const hocContext = {
+            additionalHocs,
+            resolveVariable,
+            visiting: new Set(),
+        };
         const reportUnmemoizedHoc = (node, hocName, contextInfo) => {
             context.report({
                 node,
@@ -194,9 +350,9 @@ exports.memoizeRootLevelHocs = (0, createRule_1.createRule)({
             });
         };
         const checkHocCall = (callExpr, contextInfo) => {
-            const hocName = findHocName(callExpr, additionalHocs);
+            const hocName = getHocName(callExpr, hocContext);
             const parentCall = getParentCallExpression(callExpr);
-            const parentHocName = parentCall && findHocName(parentCall, additionalHocs);
+            const parentHocName = parentCall && getHocName(parentCall, hocContext);
             if (hocName && !isPartOfHocChain(hocName, parentHocName)) {
                 reportUnmemoizedHoc(callExpr, hocName, contextInfo);
             }

package/lib/rules/no-entire-object-hook-deps.js

@@ -122,6 +122,53 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         return false;
     }
 }
+/**
+ * Whether a member access reads a method — a function declared as a member of
+ * a class or interface, which lives on the prototype.
+ *
+ * why: such a reference is one shared value across every instance of the type
+ * (`new Set().has === new Set().has`, `f1.call === f2.call`). Narrowing a
+ * dependency from `set` to `set.has` therefore pins a constant: the hook never
+ * invalidates again and serves a stale value forever, so the whole object has
+ * to stay the dependency. This is the checker-driven generalisation of the
+ * `ARRAY_METHODS`/`STRING_METHODS` name lists, which recognise the identical
+ * hazard for two built-ins only; `Map`, `Set`, `Promise`, `Date`, `Intl.*` and
+ * every user-defined class come for free.
+ *
+ * The discriminator is how the member is *declared*, not merely "the type is
+ * callable". A function-valued data property (`{ getName?: () => string }`, or
+ * a class field holding an arrow function) is per-instance state: it genuinely
+ * changes when the object carrying it is rebuilt, so narrowing to it is correct
+ * and stays allowed.
+ *
+ * The question is asked of the symbol's flags rather than its declarations'
+ * `SyntaxKind`, because a rule must survive a version skew between the
+ * TypeScript this package resolves and the one the consumer's parser built the
+ * program with. `SyntaxKind` is renumbered whenever a kind is inserted —
+ * `MethodSignature` is 170 under 5.0 and 174 under 5.9 — so a `ts.isMethodX`
+ * guard imported here silently answers `false` for every node of a consumer on
+ * a different minor, making the carve-out a no-op in exactly the place it
+ * matters. `SymbolFlags` is an append-only bit set (`Method` has been 8192
+ * throughout), so the flag test holds across versions.
+ */
+function isMethodMember(checker, esTreeNode, nodeMap) {
+    try {
+        const tsNode = nodeMap.get(esTreeNode);
+        if (!tsNode)
+            return false;
+        // why: an unresolved member (an `any` receiver, a missing type) yields no
+        // symbol, so the check stays inert rather than guessing — matching the
+        // conservative stance `isArrayOrPrimitive` takes on Any/Unknown.
+        const symbol = checker.getSymbolAtLocation(tsNode);
+        if (!symbol)
+            return false;
+        return (symbol.flags & typescript_1.SymbolFlags.Method) !== 0;
+    }
+    catch (error) {
+        // A type-checker failure must not change what the rule reports.
+        return false;
+    }
+}
 function renderPathSegments(baseName, segments) {
     let path = baseName;
     for (const segment of segments) {
@@ -196,7 +243,7 @@ function callsCorrespondingSetter(hookBody, dependencyName) {
     }
     return visit(hookBody);
 }
-function getObjectUsagesInHook(hookBody, objectName) {
+function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
     const usages = new Map(); // Track usage and its position
     // why: derived dependency paths (first-optional intermediate, array base)
     // must be re-rendered from structured links — string surgery on the
@@ -310,10 +357,17 @@ function getObjectUsagesInHook(hookBody, objectName) {
                 if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
                     return null;
                 }
-                // Check for array/string methods - these indicate usage of the entire array/string
-                if (memberExpr.property.name &&
+                // Check for a member that cannot serve as a narrowed dependency: a
+                // built-in array/string method by name, or — when type information is
+                // available — any method of a class or interface. Both denote usage of
+                // the entire receiver, because the member itself is a prototype-shared
+                // reference rather than per-instance state.
+                const isBuiltInWholeObjectMethod = !!memberExpr.property.name &&
                     (ARRAY_METHODS.has(memberExpr.property.name) ||
-                        STRING_METHODS.has(memberExpr.property.name))) {
+                        STRING_METHODS.has(memberExpr.property.name));
+                if (isBuiltInWholeObjectMethod ||
+                    (typeInfo !== undefined &&
+                        isMethodMember(typeInfo.checker, memberExpr, typeInfo.nodeMap))) {
                     const methodTarget = unwrapExpression(memberExpr.object);
                     if (methodTarget.type === utils_1.AST_NODE_TYPES.MemberExpression) {
                         // Method call on a property (e.g., userData.items.map(...) or
@@ -661,6 +715,22 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
             // In a real environment, we would want to enforce this
             // throw new Error('You have to enable the `project` setting in parser options to use this rule');
         }
+        // why: building the checker is the expensive half of a typed lint, so the
+        // handles are resolved once per file and shared by every type-driven check
+        // rather than re-fetched per dependency.
+        let typeInfo;
+        function getTypeInfo() {
+            if (!hasFullTypeChecking || !parserServices) {
+                return undefined;
+            }
+            if (!typeInfo) {
+                typeInfo = {
+                    checker: parserServices.program.getTypeChecker(),
+                    nodeMap: parserServices.esTreeNodeToTSNodeMap,
+                };
+            }
+            return typeInfo;
+        }
         const sourceCode = context.getSourceCode();
         // why: scanning every comment once per file rather than once per hook call
         // keeps the check off the hot path of files with many hooks.
@@ -736,16 +806,15 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                     if (unwrappedElement.type === utils_1.AST_NODE_TYPES.Identifier) {
                         const objectName = unwrappedElement.name;
                         // Skip type checking if we don't have TypeScript services
-                        if (hasFullTypeChecking && parserServices) {
-                            const checker = parserServices.program.getTypeChecker();
-                            const nodeMap = parserServices.esTreeNodeToTSNodeMap;
+                        const dependencyTypeInfo = getTypeInfo();
+                        if (dependencyTypeInfo) {
                             // Skip if the dependency is an array or primitive type
-                            if (isArrayOrPrimitive(checker, unwrappedElement, nodeMap)) {
+                            if (isArrayOrPrimitive(dependencyTypeInfo.checker, unwrappedElement, dependencyTypeInfo.nodeMap)) {
                                 return;
                             }
                         }
                         // For testing without TypeScript services, we'll assume all identifiers are objects
-                        const result = getObjectUsagesInHook(callbackBody, objectName);
+                        const result = getObjectUsagesInHook(callbackBody, objectName, dependencyTypeInfo);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
                             // why: deleting an entry from an array the author maintains by

package/lib/rules/prefer-nullish-coalescing-boolean-props.d.ts

@@ -1 +1,2 @@
-export declare const preferNullishCoalescingBooleanProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"preferNullishCoalescing", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const preferNullishCoalescingBooleanProps: TSESLint.RuleModule<"preferNullishCoalescing", [], TSESLint.RuleListener>;

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -489,6 +489,48 @@ function couldBeNullish(node, checker, parserServices) {
     // For other expressions, conservatively assume they could be nullish
     return true;
 }
+/**
+ * ECMAScript forbids `??` from sharing an expression with an unparenthesized
+ * `&&`/`||`. Source-level parentheses are not part of an ESTree node's range,
+ * so rewriting a whole LogicalExpression drops the parens around its operands —
+ * exactly the ones the operator swap makes mandatory. Re-adding them around any
+ * logical operand is unconditionally safe: the sub-expression was already
+ * evaluated as a unit, so redundant parens cannot change semantics.
+ */
+function parenthesizeLogical(text, operand) {
+    return operand.type === utils_1.AST_NODE_TYPES.LogicalExpression ? `(${text})` : text;
+}
+/**
+ * Detects parentheses that wrap the node itself. They live outside the node's
+ * range, so a `replaceText` of the node preserves them and the rewrite needs no
+ * parens of its own.
+ */
+function isParenthesized(node, sourceCode) {
+    const before = sourceCode.getTokenBefore(node);
+    const after = sourceCode.getTokenAfter(node);
+    return (!!before &&
+        !!after &&
+        before.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+        before.value === '(' &&
+        after.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
+        after.value === ')');
+}
+/**
+ * A partially converted chain (`a ?? b || c`) is a syntax error just like an
+ * unparenthesized operand. Only one fix per overlapping range survives a pass,
+ * so converting one link of a `||` chain always leaves the sibling links
+ * untouched; parenthesizing the rewritten link keeps the emitted program
+ * parseable while later passes convert the remaining links.
+ */
+function needsSelfParens(node, sourceCode) {
+    const { parent } = node;
+    if (!parent ||
+        parent.type !== utils_1.AST_NODE_TYPES.LogicalExpression ||
+        parent.operator === '??') {
+        return false;
+    }
+    return !isParenthesized(node, sourceCode);
+}
 exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
     name: 'prefer-nullish-coalescing-boolean-props',
     meta: {
@@ -540,7 +582,10 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                 right: rightText,
                             },
                             fix(fixer) {
-                                return fixer.replaceText(node, `${leftText} ?? ${rightText}`);
+                                const replacement = `${parenthesizeLogical(leftText, node.left)} ?? ${parenthesizeLogical(rightText, node.right)}`;
+                                return fixer.replaceText(node, needsSelfParens(node, sourceCode)
+                                    ? `(${replacement})`
+                                    : replacement);
                             },
                         });
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,65 @@
 [
+  {
+    "version": "1.20.106",
+    "date": "2026-08-05T01:12:16.076Z",
+    "rules": [
+      {
+        "name": "consistent-callback-naming",
+        "changeType": "fix",
+        "issues": [
+          1719
+        ],
+        "summary": "stop renaming destructuring keys and reserved words (closes #1719)"
+      },
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1721
+        ],
+        "summary": "keep the whole object when the member is a method (closes #1721)"
+      },
+      {
+        "name": "prefer-nullish-coalescing-boolean-props",
+        "changeType": "fix",
+        "issues": [
+          1720
+        ],
+        "summary": "keep the parens ?? requires (closes #1720)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.105",
+    "date": "2026-08-04T22:42:11.381Z",
+    "rules": [
+      {
+        "name": "enforce-dynamic-firebase-imports",
+        "changeType": "fix",
+        "issues": [
+          1715,
+          1716
+        ],
+        "summary": "relocate the dynamic import to its call site (closes #1716); exempt never-bundled files (closes #1715)"
+      },
+      {
+        "name": "enforce-empty-object-check",
+        "changeType": "fix",
+        "issues": [
+          1718
+        ],
+        "summary": "exempt constructable types, not just callable ones (closes #1718)"
+      },
+      {
+        "name": "memoize-root-level-hocs",
+        "changeType": "fix",
+        "issues": [
+          1717
+        ],
+        "summary": "require component evidence, not just a with[A-Z] name (closes #1717)"
+      }
+    ]
+  },
   {
     "version": "1.20.104",
     "date": "2026-08-04T20:46:47.102Z",