@blumintinc/eslint-plugin-blumint 1.20.104 → 1.20.105

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.105',
     },
     parseOptions: {
         ecmaVersion: 2020,

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

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

package/release-manifest.json

@@ -1,4 +1,35 @@
 [
+  {
+    "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",