@blumintinc/eslint-plugin-blumint 1.20.50 → 1.20.52

package/lib/index.js

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

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

@@ -36,9 +36,11 @@ exports.DEFAULT_IGNORED_LIBRARIES = [
     'use-latest-callback',
     '@blumintinc/typescript-memoize',
     '@blumintinc/use-deep-compare',
+    '@blumintinc/microdiff',
     'microdiff',
     'safe-stable-stringify',
-    'fast-deep-equal', // fast-deep-equal-over-microdiff
+    '@blumintinc/fast-deep-equal',
+    'fast-deep-equal', // fast-deep-equal-over-microdiff, for files already on upstream
 ];
 exports.DEFAULT_INTERNAL_PREFIXES = ['src/', 'functions/'];
 // Pre-built set of Node.js core module names for O(1) lookup.

package/lib/rules/enforce-m3-sentence-case.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceM3SentenceCase = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 /**
  * Default props that carry user-facing label text, per the issue spec.
@@ -452,7 +453,11 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
             ...DEFAULT_IGNORED_WORDS,
             ...(options.ignoredWords ?? []),
         ]);
-        const ignorePatternRegexes = (options.ignorePatterns ?? []).map((p) => new RegExp(p));
+        // Rejecting a malformed `ignorePatterns` entry rather than dropping it keeps
+        // the consumer's exception list honest: a silently discarded pattern would
+        // make text they deliberately excluded start getting reported with no
+        // indication why.
+        const ignorePatternRegexes = (0, compilePatternOption_1.compilePatternOption)('enforce-m3-sentence-case', 'ignorePatterns', options.ignorePatterns ?? []);
         const allowListSet = new Set(options.allowList ?? []);
         const checkJsxText = options.checkJsxText !== false;
         /**

package/lib/rules/enforce-microdiff.js

@@ -5,7 +5,25 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const DIFF_NAME = 'diff';
-const MICRODIFF_MODULE = 'microdiff';
+/**
+ * The package the fix imports from. BluMint's fork is the dependency this
+ * codebase declares, and every call site resolves against it.
+ */
+const MICRODIFF_MODULE = '@blumintinc/microdiff';
+/**
+ * The specifiers that already satisfy this rule. The fix emits the fork, but a
+ * file importing upstream `microdiff` is diffing structurally all the same, so
+ * both are recognised on the way in: an unrecognised one would earn a second
+ * import of the same binding (TS2300).
+ */
+const MICRODIFF_MODULES = new Set([MICRODIFF_MODULE, 'microdiff']);
+/**
+ * The import the fix emits. Both packages export their diff function as the
+ * module *default* — `Difference`, `MicrodiffOptions` and the `default*`
+ * predicates are the only named exports — so a `{ diff }` specifier binds
+ * nothing (TS2305) however the module resolves.
+ */
+const MICRODIFF_IMPORT = `import ${DIFF_NAME} from '${MICRODIFF_MODULE}';`;
 /**
  * The names a competing library's diff export is conventionally bound to. They
  * are candidates for a report, never proof of one: what a call resolves to
@@ -68,7 +86,7 @@ function bindsMicrodiffDiff(specifier) {
  */
 function findMicrodiffImport(program) {
     return program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-        statement.source.value === MICRODIFF_MODULE &&
+        MICRODIFF_MODULES.has(String(statement.source.value)) &&
         statement.importKind !== 'type' &&
         statement.specifiers.some(bindsMicrodiffDiff));
 }
@@ -85,7 +103,7 @@ function collectClaimableSpecifiers(program) {
             return;
         }
         const source = statement.source.value;
-        if (source === MICRODIFF_MODULE) {
+        if (MICRODIFF_MODULES.has(source)) {
             statement.specifiers
                 .filter(bindsMicrodiffDiff)
                 .forEach((specifier) => claimable.add(specifier));
@@ -166,6 +184,28 @@ function toImportedDiffSource(variable, importedSpecifiers) {
     }
     return null;
 }
+/**
+ * Whether a call carries operands `diff(obj, newObj, options?)` accepts.
+ * microdiff needs both sides of the comparison, so a call supplying fewer is
+ * reported but left alone: rewriting it would trade an unresolved name for a
+ * call that does not type-check (TS2554).
+ */
+function hasRewritableArity(call) {
+    return call.arguments.length >= 2;
+}
+/**
+ * Whether a reference sits where the call fix rewrites it — as the callee of a
+ * convertible call. A reference in any other position (passed as a value,
+ * assigned to a variable, re-exported) has no rewrite of its own, so retiring
+ * the import that binds it would leave it unresolved (TS2304).
+ */
+function isRewrittenCallee(identifier) {
+    const parent = identifier.parent;
+    return (!!parent &&
+        parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        parent.callee === identifier &&
+        hasRewritableArity(parent));
+}
 /**
  * Whether a bare `diff` written at `scope` reaches microdiff's function.
  * Resolving through the scope chain catches both failure modes: a module-scope
@@ -221,21 +261,86 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
             return canEmitDiff(ASTHelpers_1.ASTHelpers.getScope(context, node), collectClaimableSpecifiers(sourceCode.ast));
         }
         /**
-         * Whether retiring `declaration` leaves every reference it binds able to
-         * take the name `diff`. The import rewrite lands at module scope while the
-         * references it serves sit in nested scopes: one standing where `diff` is
-         * shadowed keeps the old name, because its own fix declines, so rewriting
-         * the import would strand it without a binding (TS2304).
+         * Whether the call handler rewrites the calls a specifier's references
+         * make. It fires on a specifier the import handler tracked, or on a local
+         * name a competing library conventionally binds; a specifier matching
+         * neither — `applyChange` from `deep-diff`, say — keeps its call sites, so
+         * its references survive only if the import that binds them does.
          */
-        function canRenameReferencesOf(declaration) {
+        function isRewrittenSpecifier(specifier) {
+            return (importedDiffSpecifiers.has(specifier) ||
+                DIFF_FUNCTION_NAMES.has(specifier.local.name));
+        }
+        /**
+         * Whether retiring `declaration` leaves every name it binds accounted for.
+         * The fix removes the whole declaration, so each reference it serves has to
+         * be one the call fixes rewrite to `diff` in the same pass — an import swap
+         * that strands a reference behind is the defect this guards.
+         *
+         * Two things have to hold at every reference. `diff` must reach microdiff
+         * there: the import rewrite lands at module scope while the references it
+         * serves sit in nested scopes, and one standing where `diff` is shadowed
+         * would resolve to the shadow. And the reference has to sit where a rewrite
+         * exists at all, which is the callee position of a convertible call.
+         *
+         * A specifier nothing references is vacuously safe: retiring it removes an
+         * import no code reads.
+         */
+        function canRetireImport(declaration) {
             const claimable = collectClaimableSpecifiers(sourceCode.ast);
             const declarationScope = ASTHelpers_1.ASTHelpers.getScope(context, declaration);
             return declaration.specifiers.every((specifier) => {
                 const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(declarationScope, specifier.local.name);
-                return (!variable ||
-                    variable.references.every((reference) => canEmitDiff(reference.from, claimable)));
+                if (!variable) {
+                    return true;
+                }
+                const rewritten = isRewrittenSpecifier(specifier);
+                return variable.references.every((reference) => canEmitDiff(reference.from, claimable) &&
+                    rewritten &&
+                    isRewrittenCallee(reference.identifier));
             });
         }
+        /**
+         * Whether the import fix retires `declaration` in this same pass.
+         */
+        function willRetireImport(declaration) {
+            return canEmitDiffAt(declaration) && canRetireImport(declaration);
+        }
+        /**
+         * Whether the call at `node`, whose callee `declaration` binds, may be
+         * rewritten to `diff(...)`. Separate from the decision to report: a call
+         * this rule cannot convert is still a use of a competing library, so it is
+         * reported and left for the author.
+         *
+         * The rename needs something to bind the `diff` it writes — an import the
+         * file already has, or the one that replaces `declaration` in this same
+         * pass. Renaming a callee whose import survives strands the rewritten call
+         * exactly as retiring an import whose callee survives strands that one.
+         */
+        function canRewriteCall(node, declaration) {
+            if (!canEmitDiffAt(node) || !hasRewritableArity(node)) {
+                return false;
+            }
+            if (findMicrodiffImport(sourceCode.ast)) {
+                return true;
+            }
+            return !!declaration && willRetireImport(declaration);
+        }
+        /**
+         * The fix element that puts microdiff's import at the top of the file, or
+         * null when the file already has one.
+         *
+         * It is its own element rather than text spliced into the replacement for
+         * the reported node, because the reported node is rarely at module scope: a
+         * comparison inside a function body, or a function behind an `export`,
+         * would otherwise take the import somewhere the grammar forbids it.
+         */
+        function buildMicrodiffImportFix(fixer) {
+            if (findMicrodiffImport(sourceCode.ast)) {
+                return null;
+            }
+            return fixer.insertTextBeforeRange([0, 0], `${MICRODIFF_IMPORT}\n\n`);
+        }
         // Add a specific set to track which import names are used
         const usedImportNames = new Set();
         // Check if a node is an object or array type
@@ -272,7 +377,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
             ImportDeclaration(node) {
                 const importSource = node.source.value;
                 // Check for microdiff import
-                if (importSource === MICRODIFF_MODULE) {
+                if (MICRODIFF_MODULES.has(importSource)) {
                     return;
                 }
                 // Track other diffing libraries
@@ -296,9 +401,10 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         },
                         fix(fixer) {
                             // Decline rather than duplicate or shadow a `diff` this file
-                            // already binds to something else. The report stands so the
-                            // author resolves the name clash deliberately.
-                            if (!canEmitDiffAt(node) || !canRenameReferencesOf(node)) {
+                            // already binds to something else, and rather than retire an
+                            // import whose references no call fix rewrites. The report stands
+                            // either way, so the author resolves it deliberately.
+                            if (!canEmitDiffAt(node) || !canRetireImport(node)) {
                                 return null;
                             }
                             // If we already have a microdiff import, just remove this import
@@ -306,7 +412,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 return fixer.remove(node);
                             }
                             // Otherwise, replace with microdiff import
-                            return fixer.replaceText(node, `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';`);
+                            return fixer.replaceText(node, MICRODIFF_IMPORT);
                         },
                     });
                     // Check if importing a diff function or a known equality library
@@ -346,6 +452,9 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         // Check if this call resolves to a function we specifically
                         // imported from a diff library
                         const importSource = toImportedDiffSource(calleeVariable, importedDiffSpecifiers);
+                        // The declaration the rename depends on: retiring it is what frees
+                        // the name `diff` and imports something under it.
+                        const competingImport = toCompetingDiffImport(calleeVariable);
                         if (importSource) {
                             usedImportNames.add(name);
                             // Skip reporting if it's from fast-deep-equal
@@ -358,7 +467,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
-                                    if (!canEmitDiffAt(node)) {
+                                    if (!canRewriteCall(node, competingImport)) {
                                         return null;
                                     }
                                     return fixer.replaceText(callee, DIFF_NAME);
@@ -370,29 +479,28 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             // The name is only a candidate until the scope chain says what it
                             // binds: a local function, variable, parameter, or an import from
                             // anywhere but a competing diff library keeps its call untouched.
-                            const competingImport = toCompetingDiffImport(calleeVariable);
                             if (!competingImport) {
                                 return;
                             }
                             // Track this import name as used
                             usedImportNames.add(name);
-                            // Check if we have at least 2 arguments that are objects or arrays
-                            if (node.arguments.length >= 2 &&
-                                isObjectOrArrayType(node.arguments[0]) &&
-                                isObjectOrArrayType(node.arguments[1])) {
-                                reportedNodes.add(node);
-                                context.report({
-                                    node,
-                                    messageId: 'enforceMicrodiff',
-                                    fix(fixer) {
-                                        if (!canEmitDiffAt(node)) {
-                                            return null;
-                                        }
-                                        // When handling fast-diff and similar libraries, need to ensure the function name is replaced
-                                        return fixer.replaceText(callee, DIFF_NAME);
-                                    },
-                                });
-                            }
+                            // What the callee resolves to already settles this: the argument
+                            // shapes say nothing a competing library's own import has not.
+                            // Gating the report on them left the call behind while the import
+                            // handler retired the declaration binding it, so `deepDiff(a, b)`
+                            // came out of a fix unresolved.
+                            reportedNodes.add(node);
+                            context.report({
+                                node,
+                                messageId: 'enforceMicrodiff',
+                                fix(fixer) {
+                                    if (!canRewriteCall(node, competingImport)) {
+                                        return null;
+                                    }
+                                    // When handling fast-diff and similar libraries, need to ensure the function name is replaced
+                                    return fixer.replaceText(callee, DIFF_NAME);
+                                },
+                            });
                         }
                     }
                 }
@@ -461,28 +569,13 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                     if (!canEmitDiffAt(node)) {
                                         return null;
                                     }
-                                    // Find the containing function to add the import
-                                    let functionNode = node;
-                                    while (functionNode &&
-                                        functionNode.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                                        functionNode.type !==
-                                            utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                                        functionNode.type !== utils_1.AST_NODE_TYPES.Program) {
-                                        functionNode = functionNode.parent;
-                                    }
-                                    // If we found a program node and microdiff isn't imported,
-                                    // we'll need to add the import manually
-                                    if (functionNode &&
-                                        functionNode.type === utils_1.AST_NODE_TYPES.Program &&
-                                        !findMicrodiffImport(sourceCode.ast)) {
-                                        // Need to add an import
-                                        const importFix = fixer.insertTextBeforeRange([0, 0], `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';\n\n`);
-                                        // Replace JSON.stringify comparison
-                                        const compareFix = fixer.replaceText(node, `${DIFF_NAME}(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
-                                        return [importFix, compareFix];
-                                    }
-                                    // Otherwise just replace the comparison
-                                    return fixer.replaceText(node, `${DIFF_NAME}(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                    const compareFix = fixer.replaceText(node, `${DIFF_NAME}(${sourceCode.getText(leftArg)}, ${sourceCode.getText(rightArg)})${isEqual ? '.length === 0' : '.length > 0'}`);
+                                    // The comparison this rewrites almost always sits inside a
+                                    // function, and the `diff` it emits needs an import whatever
+                                    // encloses it. Deciding on the enclosing node left every
+                                    // nested comparison calling a `diff` nothing bound.
+                                    const importFix = buildMicrodiffImportFix(fixer);
+                                    return importFix ? [importFix, compareFix] : compareFix;
                                 },
                             });
                         }
@@ -518,27 +611,31 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             bodyText.includes('JSON.stringify') &&
                             bodyText.includes('!==')) {
                             reportedNodes.add(node);
-                            const param1 = sourceCode.getText(node.params[0]);
-                            const param2 = sourceCode.getText(node.params[1]);
+                            // The operands are the parameter *names*, not the text of the
+                            // parameters: a typed parameter's text carries its annotation,
+                            // and `diff(oldConfig: Config, ...)` does not parse. A parameter
+                            // that binds no single name — a destructuring or rest pattern —
+                            // has no operand to pass, so the report stands without a fix.
+                            const [firstParam, secondParam] = node.params;
+                            const operands = firstParam.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                secondParam.type === utils_1.AST_NODE_TYPES.Identifier
+                                ? [firstParam.name, secondParam.name]
+                                : null;
                             context.report({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
-                                    if (!canEmitDiffAt(node)) {
+                                    if (!operands || !canEmitDiffAt(node)) {
                                         return null;
                                     }
-                                    // Create a new version of the function with microdiff
-                                    const newFunctionBody = `{
-  return ${DIFF_NAME}(${param1}, ${param2}).length > 0;
-}`;
-                                    if (!findMicrodiffImport(sourceCode.ast)) {
-                                        // Create a new import statement
-                                        return fixer.replaceText(node, `import { ${DIFF_NAME} } from '${MICRODIFF_MODULE}';\n\nfunction ${node.id?.name}(${param1}, ${param2}) ${newFunctionBody}`);
-                                    }
-                                    else {
-                                        // Just replace the function body
-                                        return fixer.replaceText(body, newFunctionBody);
-                                    }
+                                    // Only the body is rewritten, so the signature keeps its type
+                                    // annotations, its modifiers, and any `export` in front of
+                                    // it. Replacing the declaration wholesale used to drop those
+                                    // and, when it prefixed the import, put an `import` inside
+                                    // whatever enclosed the function.
+                                    const bodyFix = fixer.replaceText(body, `{\n  return ${DIFF_NAME}(${operands[0]}, ${operands[1]}).length > 0;\n}`);
+                                    const importFix = buildMicrodiffImportFix(fixer);
+                                    return importFix ? [importFix, bodyFix] : bodyFix;
                                 },
                             });
                             return;

package/lib/rules/enforce-timestamp-now.js

@@ -7,6 +7,27 @@ const FIRESTORE_MODULES = new Set([
     'firebase-admin/firestore',
     'firebase/firestore',
 ]);
+/**
+ * Members whose meaning survives the `new Date()` → `Timestamp.now()` rewrite,
+ * taken from the shipped typings rather than from `Date`'s surface:
+ * `@google-cloud/firestore` (what `firebase-admin/firestore` re-exports)
+ * declares `seconds`, `nanoseconds`, `toDate()`, `toMillis()`, `isEqual()` and
+ * `valueOf()`, and `@firebase/firestore` adds `toString()` and `toJSON()`.
+ *
+ * `valueOf`, `toString` and `toJSON` are excluded on purpose even though
+ * `Timestamp` declares them, because their contracts differ from `Date`'s:
+ * `Timestamp#valueOf()` returns an encoded `string` where `Date#valueOf()`
+ * returns a `number`, and the string forms render `Timestamp(seconds=…,
+ * nanoseconds=…)` instead of a date. Those call sites keep compiling while the
+ * value silently changes, which is harder to catch than a type error.
+ */
+const TIMESTAMP_COMPATIBLE_MEMBERS = new Set([
+    'toDate',
+    'toMillis',
+    'isEqual',
+    'seconds',
+    'nanoseconds',
+]);
 exports.enforceTimestampNow = (0, createRule_1.createRule)({
     name: 'enforce-timestamp-now',
     meta: {
@@ -58,14 +79,27 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
                 importedTimestampAliases.push(localName);
             }
         }
-        /** Local names a static Firestore import binds to `Timestamp`. */
+        /**
+         * Local names a static Firestore import binds to `Timestamp` as a *value*.
+         *
+         * A type-only binding is erased at emit, so referencing it from the
+         * synthesized `Timestamp.now()` turns compiling code into TS1361 (issue
+         * #1530). This is the same shape as #1521: the gate has to prove not just
+         * that a binding exists but that it is the kind of binding the emitted code
+         * requires. Both spellings are type-only and neither implies the other —
+         * `import type { Timestamp }` marks the declaration while leaving its
+         * specifier `value`, and `import { type Timestamp }` marks the specifier
+         * while leaving the declaration `value`.
+         */
         function staticTimestampAliases(node) {
             if (typeof node.source.value !== 'string' ||
-                !FIRESTORE_MODULES.has(node.source.value)) {
+                !FIRESTORE_MODULES.has(node.source.value) ||
+                node.importKind === 'type') {
                 return [];
             }
             return node.specifiers
                 .filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.importKind !== 'type' &&
                 specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
                 specifier.imported.name === 'Timestamp')
                 .map((specifier) => specifier.local.name);
@@ -73,6 +107,12 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
         /**
          * Local names a `const { Timestamp } = await import(...)` declarator binds
          * to `Timestamp`.
+         *
+         * No type-only screen is needed here the way the static path needs one
+         * (#1530): a destructured `await import(...)` is a runtime value binding by
+         * construction. TypeScript spells a type-only dynamic import as the
+         * `import('...').Timestamp` type node, which never appears as a variable
+         * initializer, and `ImportExpression` carries no `importKind` to check.
          */
         function dynamicTimestampAliases(node) {
             if (node.init?.type !== utils_1.AST_NODE_TYPES.AwaitExpression ||
@@ -193,27 +233,61 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
                 node.callee.name === 'Date' &&
                 node.arguments.length === 0);
         }
-        // Check if a Date object is being modified (e.g., futureDate.setDate())
-        function isDateBeingModified(dateVar) {
-            // Look through the scope to find if this variable is modified
-            const scope = context.getScope();
-            const variable = scope.variables.find((v) => v.name === dateVar);
-            if (!variable)
+        /**
+         * Whether a single use of the rewritten binding would still type-check and
+         * mean the same thing once its initializer is a `Timestamp`.
+         *
+         * Only a read of a member that `Timestamp` shares with `Date` qualifies.
+         * Every other shape — a write, an argument, a return, a comparison, an
+         * interpolation, a computed access — hands the value to a position whose
+         * expected type this rule cannot see, so it cannot be shown safe.
+         */
+        function isTimestampCompatibleReference(reference) {
+            // The declaration's own initializer write is the site being rewritten,
+            // not a use of the resulting value.
+            if (reference.init) {
+                return true;
+            }
+            // A later assignment rebinds the variable to a value typed elsewhere,
+            // which the rewritten initializer no longer matches.
+            if (!reference.isReadOnly()) {
                 return false;
-            // Check if any references to this variable are followed by property access and modification
-            return variable.references.some((ref) => {
-                const id = ref.identifier;
-                const parent = id.parent;
-                // Check for patterns like dateVar.setDate(), dateVar.setHours(), etc.
-                return (parent &&
-                    parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                    parent.object === id &&
-                    parent.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (parent.property.name.startsWith('set') ||
-                        parent.property.name === 'toISOString' ||
-                        parent.property.name === 'toLocaleString' ||
-                        parent.property.name === 'toString'));
-            });
+            }
+            const identifier = reference.identifier;
+            const parent = identifier.parent;
+            if (!parent ||
+                parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                parent.object !== identifier ||
+                parent.computed ||
+                parent.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            return TIMESTAMP_COMPATIBLE_MEMBERS.has(parent.property.name);
+        }
+        /**
+         * Whether every use of a `new Date()` binding survives the rewrite to
+         * `Timestamp.now()`.
+         *
+         * `Timestamp` shares almost none of `Date`'s surface, so rewriting the
+         * initializer turns each `getX`/`setX`/`toLocaleX` call on the binding into
+         * TS2339 (issue #1528). A denylist of the `Date` members `Timestamp` lacks
+         * can only ever be incomplete, so the question is inverted: the fix is
+         * offered only when the whole use set is provably part of the `Timestamp`
+         * API. Declining on an unrecognized use trades a missed rewrite for never
+         * breaking the build, which is the trade this repo prefers.
+         */
+        function usesOnlyTimestampCompatibleMembers(declarator) {
+            // An exported binding is read by files this rule never sees, so its use
+            // set cannot be enumerated and the rewrite would break importers instead.
+            if (declarator.parent?.parent?.type ===
+                utils_1.AST_NODE_TYPES.ExportNamedDeclaration) {
+                return false;
+            }
+            const [variable] = context.getDeclaredVariables(declarator);
+            if (!variable) {
+                return false;
+            }
+            return variable.references.every(isTimestampCompatibleReference);
         }
         return {
             Program(node) {
@@ -288,9 +362,9 @@ exports.enforceTimestampNow = (0, createRule_1.createRule)({
                             varName.includes('date') ||
                             varName.includes('created') ||
                             varName.includes('updated')) {
-                            // Check if the Date object is being modified
-                            if (isDateBeingModified(parent.id.name)) {
-                                // If the Date is being modified, don't flag it
+                            // Stay silent when any use of the binding relies on the `Date`
+                            // API, since the rewrite would strip it (issue #1528).
+                            if (!usesOnlyTimestampCompatibleMembers(parent)) {
                                 return;
                             }
                             // Stay silent unless a real `Timestamp` binding is in scope. The

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -5,10 +5,46 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
-const FAST_DEEP_EQUAL_MODULES = new Set([
-    'fast-deep-equal',
-    'fast-deep-equal/es6',
-]);
+const microdiffModules_1 = require("../utils/microdiffModules");
+const fastDeepEqualModules_1 = require("../utils/fastDeepEqualModules");
+const DIFF_EXPORT_NAME = 'diff';
+/**
+ * Whether a declaration imports values — a `import type ...` declaration binds
+ * nothing at runtime, so it neither supplies a callable `diff` nor satisfies
+ * the fast-deep-equal import the fix emits.
+ */
+function isValueImport(declaration) {
+    return declaration.importKind !== 'type';
+}
+/**
+ * Whether a specifier binds microdiff's diff function: the module default, or
+ * its named `diff` export under whatever local name. Type-only specifiers are
+ * excluded for the same reason a type-only declaration is.
+ *
+ * The check matters because microdiff's other exports are types — a file
+ * importing only `Difference` binds no `diff` at all, and treating that import
+ * as proof of one turns any local `diff(...)` in the file into a violation.
+ */
+function bindsMicrodiffDiff(specifier) {
+    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        return true;
+    }
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.name === DIFF_EXPORT_NAME);
+}
+/**
+ * Whether a specifier binds a callable equality function rather than the module
+ * object: the default export the package is, or a named specifier of it. A
+ * namespace import binds the module, and a bare `import '...'` binds nothing at
+ * all — reading either as the file's equality function leaves the emitted
+ * `isEqual(...)` call with no declaration behind it.
+ */
+function bindsFastDeepEqualFunction(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.importKind !== 'type'));
+}
 /**
  * Whether every declaration of a visible binding is a fast-deep-equal import,
  * i.e. the name already means the comparison function the fix wants to call.
@@ -26,7 +62,8 @@ function bindsFastDeepEqual(variable) {
             }
             const declaration = specifier.parent;
             return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                FAST_DEEP_EQUAL_MODULES.has(declaration.source.value));
+                isValueImport(declaration) &&
+                fastDeepEqualModules_1.FAST_DEEP_EQUAL_MODULES.has(String(declaration.source.value)));
         }));
 }
 /**
@@ -52,9 +89,9 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             useFastDeepEqual: "What's wrong: This code uses `{{diffName}}(...).length` as a deep equality check.\n" +
                 'Why it matters: `{{diffName}}` allocates a full change list (paths, types, values) before you compare it to zero, which hides the boolean intent and wastes memory/time.\n' +
                 'How to fix: Call `{{fastEqualName}}(left, right)` for equality (or prefix with `!` for inequality) using the same two arguments instead of counting diff length.',
-            addFastDeepEqualImport: "What's wrong: This file checks equality via `{{diffName}}(...).length` but does not import `fast-deep-equal`.\n" +
-                'Why it matters: Without `fast-deep-equal`, equality checks keep building diff entries just to count them, adding overhead and obscuring intent.\n' +
-                'How to fix: Add a default import for `fast-deep-equal` as `{{fastEqualName}}` and use `{{fastEqualName}}(a, b)` for equality checks.',
+            addFastDeepEqualImport: "What's wrong: This file checks equality via `{{diffName}}(...).length` but does not import a deep-equality function.\n" +
+                'Why it matters: Without `@blumintinc/fast-deep-equal`, equality checks keep building diff entries just to count them, adding overhead and obscuring intent.\n' +
+                'How to fix: Add a default import from `@blumintinc/fast-deep-equal` as `{{fastEqualName}}` and use `{{fastEqualName}}(a, b)` for equality checks.',
         },
     },
     defaultOptions: [],
@@ -67,8 +104,8 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         const reportedNodes = new Set();
         let plannedFastDeepEqualImport = false;
         /**
-         * The `import ... from 'fast-deep-equal'` statement rides on a single
-         * violation's fix, so that violation is the file's import carrier. A
+         * The `import ... from '@blumintinc/fast-deep-equal'` statement rides on a
+         * single violation's fix, so that violation is the file's import carrier. A
          * suppressed carrier would take the import down with it while the surviving
          * violations still emit `isEqual(...)` calls, leaving them unbound.
          */
@@ -415,28 +452,29 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             return fixes;
         }
         /**
-         * The `import ... from 'fast-deep-equal'` edit, scheduled at most once per
-         * file. Claiming the carrier slot is a side effect, so this runs last —
-         * after every reason to decline the fix has been ruled out — otherwise a
-         * declining violation takes the import down with it and leaves the
-         * surviving violations' `isEqual(...)` calls unbound.
+         * The `import ... from '@blumintinc/fast-deep-equal'` edit, scheduled at
+         * most once per file. Claiming the carrier slot is a side effect, so this
+         * runs last — after every reason to decline the fix has been ruled out —
+         * otherwise a declining violation takes the import down with it and leaves
+         * the surviving violations' `isEqual(...)` calls unbound.
+         *
+         * The specifier is the scoped fork: it is the dependency this codebase
+         * declares, so any other name would be written as an import that resolves
+         * nowhere.
          */
         function planFastDeepEqualImport(fixer) {
             if (hasFastDeepEqualImport || plannedFastDeepEqualImport) {
                 return [];
             }
             plannedFastDeepEqualImport = true;
+            const importStatement = (0, fastDeepEqualModules_1.fastDeepEqualImport)(fastDeepEqualImportName);
             const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const microdiffImport = importDeclarations.find((declaration) => declaration.source.value === 'microdiff');
+            const microdiffImport = importDeclarations.find((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
             const anchor = microdiffImport ?? importDeclarations[importDeclarations.length - 1];
             if (anchor) {
-                return [
-                    fixer.insertTextAfter(anchor, `\nimport ${fastDeepEqualImportName} from 'fast-deep-equal';`),
-                ];
+                return [fixer.insertTextAfter(anchor, `\n${importStatement}`)];
             }
-            return [
-                fixer.insertTextBeforeRange([0, 0], `import ${fastDeepEqualImportName} from 'fast-deep-equal';\n`),
-            ];
+            return [fixer.insertTextBeforeRange([0, 0], `${importStatement}\n`)];
         }
         /**
          * Create a fix for replacing microdiff equality check with fast-deep-equal
@@ -508,24 +546,31 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         return {
             // Track imports of microdiff and fast-deep-equal
             ImportDeclaration(node) {
-                const importSource = node.source.value;
-                // Check for microdiff import
-                if (importSource === 'microdiff') {
-                    hasMicrodiffImport = true;
-                    // Get the local name of the imported diff function
-                    node.specifiers.forEach((specifier) => {
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            specifier.imported.name === 'diff') {
-                            microdiffImportName = specifier.local.name;
-                        }
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                            microdiffImportName = specifier.local.name;
-                        }
+                const importSource = String(node.source.value);
+                if (!isValueImport(node)) {
+                    return;
+                }
+                // A microdiff import counts only once it binds the diff function
+                // itself. Every other export of the package is a type, so
+                // `import { Difference } from '@blumintinc/microdiff'` brings in
+                // nothing callable — reading it as microdiff's presence turns an
+                // unrelated local `diff(...)` in that file into a violation whose fix
+                // rewrites it to an equality check.
+                if (microdiffModules_1.MICRODIFF_MODULES.has(importSource)) {
+                    node.specifiers.filter(bindsMicrodiffDiff).forEach((specifier) => {
+                        hasMicrodiffImport = true;
+                        microdiffImportName = specifier.local.name;
                     });
                 }
-                // Check for fast-deep-equal import
-                if (importSource === 'fast-deep-equal' ||
-                    importSource === 'fast-deep-equal/es6') {
+                // An equality function the file already has, under any of the
+                // specifiers that resolve to one — the scoped fork this codebase
+                // depends on, its React entry point, and upstream. Missing one of them
+                // costs the fix twice over: a second import of a function already in
+                // scope, and, when that import's local name is the one the fix emits, a
+                // collision with it that makes the fix decline outright and leaves the
+                // report with no remedy.
+                if (fastDeepEqualModules_1.FAST_DEEP_EQUAL_MODULES.has(importSource) &&
+                    node.specifiers.some(bindsFastDeepEqualFunction)) {
                     hasFastDeepEqualImport = true;
                     // Get the local name of the imported isEqual function
                     node.specifiers.forEach((specifier) => {

package/lib/rules/no-handler-suffix.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noHandlerSuffix = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const DEFAULT_OPTIONS = {
     ignoreClassMethods: false,
@@ -26,6 +27,12 @@ function isUnsafeAllowPattern(pattern) {
     const nestedQuantifierPattern = /\((?:[^()\\]|\\.)*[+*{][^)]*\)\s*[+*{]/;
     return nestedQuantifierPattern.test(pattern);
 }
+// A pattern that compiles can still hang the linter, so allowlist sources are
+// refused for catastrophic-backtracking risk as well as for syntax.
+const UNSAFE_ALLOW_PATTERN_REJECTION = {
+    isRejected: isUnsafeAllowPattern,
+    describe: (optionName) => `unsafe ${optionName} (avoid nested quantifiers that risk catastrophic backtracking)`,
+};
 function getStaticKeyName(key) {
     if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
         return key.name;
@@ -131,34 +138,7 @@ exports.noHandlerSuffix = (0, createRule_1.createRule)({
         const resolvedOptions = { ...DEFAULT_OPTIONS, ...(options ?? {}) };
         const allowNames = new Set(resolvedOptions.allowNames);
         const interfaceAllowlist = new Set(resolvedOptions.interfaceAllowlist);
-        const invalidAllowPatterns = [];
-        const unsafeAllowPatterns = [];
-        const allowPatterns = (resolvedOptions.allowPatterns ?? []).flatMap((pattern) => {
-            try {
-                if (isUnsafeAllowPattern(pattern)) {
-                    unsafeAllowPatterns.push(pattern);
-                    return [];
-                }
-                return [new RegExp(pattern)];
-            }
-            catch (error) {
-                const reason = error && typeof error === 'object' && 'message' in error
-                    ? ` (${String(error.message)})`
-                    : '';
-                invalidAllowPatterns.push(`${pattern}${reason}`);
-                return [];
-            }
-        });
-        if (invalidAllowPatterns.length > 0 || unsafeAllowPatterns.length > 0) {
-            const errorParts = [];
-            if (invalidAllowPatterns.length > 0) {
-                errorParts.push(`invalid allowPatterns: ${invalidAllowPatterns.join(', ')}`);
-            }
-            if (unsafeAllowPatterns.length > 0) {
-                errorParts.push(`unsafe allowPatterns (avoid nested quantifiers that risk catastrophic backtracking): ${unsafeAllowPatterns.join(', ')}`);
-            }
-            throw new Error(`no-handler-suffix: ${errorParts.join('; ')}`);
-        }
+        const allowPatterns = (0, compilePatternOption_1.compilePatternOption)('no-handler-suffix', 'allowPatterns', resolvedOptions.allowPatterns ?? [], undefined, UNSAFE_ALLOW_PATTERN_REJECTION);
         if (isInAllowedFile(filename, resolvedOptions.allowFilePatterns ?? [])) {
             return {};
         }

package/lib/rules/no-render-function-components.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRenderFunctionComponents = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 /**
@@ -95,7 +96,10 @@ exports.noRenderFunctionComponents = (0, createRule_1.createRule)({
             ...DEFAULT_RENDER_PROP_NAMES,
             ...userRenderPropNames,
         ]);
-        const allowNamePatterns = (options?.allowNames ?? []).map((pattern) => new RegExp(pattern));
+        // Rejecting a malformed `allowNames` entry rather than dropping it keeps the
+        // consumer's allowlist honest: a silently discarded pattern would report the
+        // functions they deliberately exempted with no indication why.
+        const allowNamePatterns = (0, compilePatternOption_1.compilePatternOption)('no-render-function-components', 'allowNames', options?.allowNames ?? []);
         const candidates = [];
         function isAllowed(name) {
             return allowNamePatterns.some((pattern) => pattern.test(name));

package/lib/rules/no-separate-loading-state.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noSeparateLoadingState = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const compilePatternOption_1 = require("../utils/compilePatternOption");
 const createRule_1 = require("../utils/createRule");
 const LOADING_PATTERNS = [
     /^is.*Loading$/i,
@@ -34,7 +35,18 @@ exports.noSeparateLoadingState = (0, createRule_1.createRule)({
     },
     defaultOptions: [{}],
     create(context, [options]) {
-        const effectivePatterns = options?.patterns?.map((p) => new RegExp(p, 'i')) ?? LOADING_PATTERNS;
+        // Rejecting a malformed `patterns` entry rather than falling back to
+        // `LOADING_PATTERNS` keeps the consumer's detection list honest: a silent
+        // fallback would look configured while leaving the names they meant to flag
+        // unreported.
+        //
+        // The `undefined` check is load-bearing: an absent `patterns` falls back to
+        // the built-ins, while an explicit empty list stays empty, so the option can
+        // disable name matching entirely.
+        const configuredPatterns = options?.patterns === undefined
+            ? undefined
+            : (0, compilePatternOption_1.compilePatternOption)('no-separate-loading-state', 'patterns', options.patterns, 'i');
+        const effectivePatterns = configuredPatterns ?? LOADING_PATTERNS;
         const setterTrackers = [];
         function isLoadingPattern(name) {
             return effectivePatterns.some((pattern) => pattern.test(name));

package/lib/utils/compilePatternOption.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pattern options are declared as bare `string[]` because JSON Schema cannot
+ * express "is a compilable regex". Schema validation therefore hands any string
+ * straight to `new RegExp`, and an exception raised while building a rule aborts
+ * the entire lint run — every file, every other rule — with an opaque
+ * `Error while loading rule …` naming neither the option nor the offending
+ * value.
+ *
+ * Rejecting the configuration is the right response: silently dropping a
+ * pattern would leave the consumer's allowlist inert, so the code they
+ * deliberately excluded would be reported anyway with no indication why. This
+ * helper makes the rejection actionable and uniform — every failure is
+ * collected and rethrown as a single error naming the rule, the option and each
+ * bad pattern alongside the underlying regex error.
+ */
+export type PatternRejection = {
+    /**
+     * Refuses a pattern that compiles but is still unacceptable — a source with
+     * nested quantifiers, say, which risks catastrophic backtracking. Checked
+     * before compilation, so a refused pattern is never also reported as invalid.
+     */
+    isRejected: (pattern: string) => boolean;
+    /**
+     * Builds the clause head for refused patterns, e.g.
+     * `unsafe allowPatterns (avoid nested quantifiers…)`. Receives the option name
+     * so callers need not repeat it.
+     */
+    describe: (optionName: string) => string;
+};
+/**
+ * Compiles a user-supplied list of regex sources, throwing one actionable
+ * configuration error listing every pattern that failed.
+ *
+ * @param ruleName Rule id used to prefix the thrown message.
+ * @param optionName Option the patterns came from, named in the thrown message.
+ * @param patterns Regex source strings supplied by the consumer.
+ * @param flags Flags applied to every compiled pattern (`'i'`, say).
+ * @param rejection Optional extra admissibility check applied before compiling.
+ */
+export declare function compilePatternOption(ruleName: string, optionName: string, patterns: readonly string[], flags?: string, rejection?: PatternRejection): RegExp[];

package/lib/utils/compilePatternOption.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Pattern options are declared as bare `string[]` because JSON Schema cannot
+ * express "is a compilable regex". Schema validation therefore hands any string
+ * straight to `new RegExp`, and an exception raised while building a rule aborts
+ * the entire lint run — every file, every other rule — with an opaque
+ * `Error while loading rule …` naming neither the option nor the offending
+ * value.
+ *
+ * Rejecting the configuration is the right response: silently dropping a
+ * pattern would leave the consumer's allowlist inert, so the code they
+ * deliberately excluded would be reported anyway with no indication why. This
+ * helper makes the rejection actionable and uniform — every failure is
+ * collected and rethrown as a single error naming the rule, the option and each
+ * bad pattern alongside the underlying regex error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilePatternOption = void 0;
+function describeError(error) {
+    return error && typeof error === 'object' && 'message' in error
+        ? ` (${String(error.message)})`
+        : '';
+}
+/**
+ * Compiles a user-supplied list of regex sources, throwing one actionable
+ * configuration error listing every pattern that failed.
+ *
+ * @param ruleName Rule id used to prefix the thrown message.
+ * @param optionName Option the patterns came from, named in the thrown message.
+ * @param patterns Regex source strings supplied by the consumer.
+ * @param flags Flags applied to every compiled pattern (`'i'`, say).
+ * @param rejection Optional extra admissibility check applied before compiling.
+ */
+function compilePatternOption(ruleName, optionName, patterns, flags, rejection) {
+    const invalid = [];
+    const rejected = [];
+    const compiled = patterns.flatMap((pattern) => {
+        try {
+            if (rejection?.isRejected(pattern)) {
+                rejected.push(pattern);
+                return [];
+            }
+            return [new RegExp(pattern, flags)];
+        }
+        catch (error) {
+            invalid.push(`${pattern}${describeError(error)}`);
+            return [];
+        }
+    });
+    if (invalid.length === 0 && rejected.length === 0) {
+        return compiled;
+    }
+    const clauses = [];
+    if (invalid.length > 0) {
+        clauses.push(`invalid ${optionName}: ${invalid.join(', ')}`);
+    }
+    if (rejected.length > 0 && rejection) {
+        clauses.push(`${rejection.describe(optionName)}: ${rejected.join(', ')}`);
+    }
+    throw new Error(`${ruleName}: ${clauses.join('; ')}`);
+}
+exports.compilePatternOption = compilePatternOption;
+//# sourceMappingURL=compilePatternOption.js.map

package/lib/utils/fastDeepEqualModules.d.ts

@@ -0,0 +1,30 @@
+/**
+ * BluMint's fast-deep-equal fork: the dependency this codebase declares, and
+ * therefore the only specifier a fixer may emit. An unscoped `fast-deep-equal`
+ * import resolves nowhere here (TS2307).
+ */
+export declare const FAST_DEEP_EQUAL_MODULE = "@blumintinc/fast-deep-equal";
+/**
+ * Every specifier that resolves to a deep-equality function of the same shape:
+ * the fork, its React entry point, upstream, and upstream's ESM build. A file on
+ * any of them already has the comparison this rule asks for, so all four have to
+ * be read identically when deciding whether an import is still needed.
+ *
+ * The literals live here rather than in each rule because the microdiff pair
+ * drifted twice: a rule carrying only the unscoped name is inert on every call
+ * site in a codebase that depends on the fork, and a fixer emitting the unscoped
+ * name writes an import that does not resolve.
+ */
+export declare const FAST_DEEP_EQUAL_MODULES: ReadonlySet<string>;
+/**
+ * The import statement a fixer writes to bind the equality function to
+ * `localName`.
+ *
+ * It is assembled here, beside the literal, rather than in the rule that emits
+ * it: `src/tests/enforce-dynamic-imports.test.ts` derives the modules this
+ * plugin's fixers inject by resolving module-scope string constants *within each
+ * source file*, so a specifier interpolated from an imported constant reads as
+ * unresolved and drops out of the check that every injected module is one the
+ * recommended config accepts.
+ */
+export declare const fastDeepEqualImport: (localName: string) => string;

package/lib/utils/fastDeepEqualModules.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastDeepEqualImport = exports.FAST_DEEP_EQUAL_MODULES = exports.FAST_DEEP_EQUAL_MODULE = void 0;
+/**
+ * BluMint's fast-deep-equal fork: the dependency this codebase declares, and
+ * therefore the only specifier a fixer may emit. An unscoped `fast-deep-equal`
+ * import resolves nowhere here (TS2307).
+ */
+exports.FAST_DEEP_EQUAL_MODULE = '@blumintinc/fast-deep-equal';
+/**
+ * Every specifier that resolves to a deep-equality function of the same shape:
+ * the fork, its React entry point, upstream, and upstream's ESM build. A file on
+ * any of them already has the comparison this rule asks for, so all four have to
+ * be read identically when deciding whether an import is still needed.
+ *
+ * The literals live here rather than in each rule because the microdiff pair
+ * drifted twice: a rule carrying only the unscoped name is inert on every call
+ * site in a codebase that depends on the fork, and a fixer emitting the unscoped
+ * name writes an import that does not resolve.
+ */
+exports.FAST_DEEP_EQUAL_MODULES = new Set([
+    exports.FAST_DEEP_EQUAL_MODULE,
+    '@blumintinc/fast-deep-equal/react',
+    'fast-deep-equal',
+    'fast-deep-equal/es6',
+]);
+/**
+ * The import statement a fixer writes to bind the equality function to
+ * `localName`.
+ *
+ * It is assembled here, beside the literal, rather than in the rule that emits
+ * it: `src/tests/enforce-dynamic-imports.test.ts` derives the modules this
+ * plugin's fixers inject by resolving module-scope string constants *within each
+ * source file*, so a specifier interpolated from an imported constant reads as
+ * unresolved and drops out of the check that every injected module is one the
+ * recommended config accepts.
+ */
+const fastDeepEqualImport = (localName) => `import ${localName} from '${exports.FAST_DEEP_EQUAL_MODULE}';`;
+exports.fastDeepEqualImport = fastDeepEqualImport;
+//# sourceMappingURL=fastDeepEqualModules.js.map

package/lib/utils/microdiffModules.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BluMint's microdiff fork: the dependency this codebase declares, and the
+ * specifier every real call site resolves against.
+ */
+export declare const MICRODIFF_MODULE = "@blumintinc/microdiff";
+/**
+ * Every specifier that resolves to microdiff. The fork and upstream are the
+ * same library under two names, so a file on either one is diffing
+ * structurally and has to be matched identically.
+ *
+ * The literal lives here rather than in each rule because the pair drifted
+ * twice: a rule carrying only the unscoped name is inert on every call site in
+ * a codebase that depends on the fork.
+ */
+export declare const MICRODIFF_MODULES: ReadonlySet<string>;

package/lib/utils/microdiffModules.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MICRODIFF_MODULES = exports.MICRODIFF_MODULE = void 0;
+/**
+ * BluMint's microdiff fork: the dependency this codebase declares, and the
+ * specifier every real call site resolves against.
+ */
+exports.MICRODIFF_MODULE = '@blumintinc/microdiff';
+/**
+ * Every specifier that resolves to microdiff. The fork and upstream are the
+ * same library under two names, so a file on either one is diffing
+ * structurally and has to be matched identically.
+ *
+ * The literal lives here rather than in each rule because the pair drifted
+ * twice: a rule carrying only the unscoped name is inert on every call site in
+ * a codebase that depends on the fork.
+ */
+exports.MICRODIFF_MODULES = new Set([
+    exports.MICRODIFF_MODULE,
+    'microdiff',
+]);
+//# sourceMappingURL=microdiffModules.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,72 @@
 [
+  {
+    "version": "1.20.52",
+    "date": "2026-07-31T19:23:46.059Z",
+    "rules": [
+      {
+        "name": "enforce-m3-sentence-case",
+        "changeType": "fix",
+        "issues": [
+          1534
+        ],
+        "summary": "validate ignorePatterns regexes with an actionable error (closes #1534)"
+      },
+      {
+        "name": "no-render-function-components",
+        "changeType": "fix",
+        "issues": [
+          1536
+        ],
+        "summary": "validate allowNames regexes with an actionable error (closes #1536)"
+      },
+      {
+        "name": "no-separate-loading-state",
+        "changeType": "fix",
+        "issues": [
+          1535
+        ],
+        "summary": "validate patterns regexes with an actionable error (closes #1535)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.51",
+    "date": "2026-07-31T15:20:05.562Z",
+    "rules": [
+      {
+        "name": "enforce-dynamic-imports",
+        "changeType": "fix",
+        "issues": [],
+        "summary": "allow the scoped @blumintinc/fast-deep-equal specifier; allow the scoped @blumintinc/microdiff specifier"
+      },
+      {
+        "name": "enforce-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1531
+        ],
+        "summary": "emit a default import from @blumintinc/microdiff and stop stranding the call site (closes #1531)"
+      },
+      {
+        "name": "enforce-timestamp-now",
+        "changeType": "fix",
+        "issues": [
+          1528,
+          1530
+        ],
+        "summary": "reject type-only imports as evidence of a value binding (closes #1530); only rewrite new Date() when every use is Timestamp-compatible (closes #1528)"
+      },
+      {
+        "name": "fast-deep-equal-over-microdiff",
+        "changeType": "fix",
+        "issues": [
+          1532,
+          1533
+        ],
+        "summary": "emit and recognize @blumintinc/fast-deep-equal (closes #1533); recognize the scoped @blumintinc/microdiff fork (closes #1532)"
+      }
+    ]
+  },
   {
     "version": "1.20.50",
     "date": "2026-07-31T12:53:09.792Z",