@blumintinc/eslint-plugin-blumint 1.20.148 → 1.20.150

package/lib/index.js

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

package/lib/rules/enforce-exported-function-types.js

@@ -748,35 +748,6 @@ exports.enforceExportedFunctionTypes = (0, createRule_1.createRule)({
                     return;
                 checkComponentProps(component.fn);
             },
-            // Skip type checking for React components since we handle them separately
-            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > TSTypeAnnotation > TSTypeReference'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > TSTypeAnnotation > TSTypeReference'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > Identifier'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > Identifier'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > Identifier'() { },
-            'FunctionDeclaration[id.name=/^[A-Z]/] > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
-            'VariableDeclarator[id.name=/^[A-Z]/] > ArrowFunctionExpression > Identifier[typeAnnotation] > TSTypeAnnotation > TSTypeReference > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName > TSQualifiedName'() { },
         };
     },
 });

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

@@ -385,6 +385,16 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
          * Track variable assignments to detect variables derived from query key constants
          */
         const variableAssignments = new Map();
+        /**
+         * Names whose declaration leaves them holding `undefined` — `let key;` and
+         * `let key = undefined;` alike. Both falsy and nullish, which is what makes
+         * a later `||=`/`??=` onto one of them assign unconditionally.
+         */
+        const declaredUndefined = new Set();
+        /** Declarations and assignments seen per name, to bound the above to the provable case. */
+        const declarationCounts = new Map();
+        const assignmentCounts = new Map();
+        const isUndefinedIdentifier = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'undefined';
         /**
          * Check if a node represents a valid query key usage
          */
@@ -631,13 +641,45 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             },
             // Track variable declarations that might derive from query key constants
             VariableDeclarator(node) {
-                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier && node.init) {
-                    variableAssignments.set(node.id.name, node.init);
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const { name } = node.id;
+                declarationCounts.set(name, (declarationCounts.get(name) ?? 0) + 1);
+                if (node.init) {
+                    variableAssignments.set(name, node.init);
+                }
+                if (!node.init || isUndefinedIdentifier(node.init)) {
+                    declaredUndefined.add(name);
                 }
             },
             AssignmentExpression(node) {
-                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier && node.right) {
-                    variableAssignments.set(node.left.name, node.right);
+                if (node.left.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const { name } = node.left;
+                const assignmentCount = (assignmentCounts.get(name) ?? 0) + 1;
+                assignmentCounts.set(name, assignmentCount);
+                // Only a plain `=` makes the right-hand side the variable's value in
+                // general. A compound assignment leaves the prior value reachable
+                // (`key ||= K` is the old key OR K), so recording the operand would
+                // launder an unapproved key into an approved one.
+                if (node.operator === '=') {
+                    variableAssignments.set(name, node.right);
+                    return;
+                }
+                // The exception is a `||=`/`??=` onto a variable still holding
+                // `undefined`, which is both falsy and nullish: the assignment always
+                // happens, so the operand IS the value. A single declaration and a
+                // single assignment are what keep that provable — a second assignment
+                // anywhere puts a prior value back in play. `+=` is excluded because it
+                // concatenates onto `undefined` and yields neither operand.
+                //
+                // The operand is recorded rather than exempted, so it still has to be
+                // an approved constant to pass.
+                if ((node.operator === '||=' || node.operator === '??=') &&
+                    declaredUndefined.has(name) &&
+                    declarationCounts.get(name) === 1 &&
+                    assignmentCount === 1) {
+                    variableAssignments.set(name, node.right);
                 }
             },
             // Check useRouterState calls

package/lib/rules/no-array-length-in-deps.js

@@ -5,6 +5,7 @@ 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 hungarianNaming_1 = require("../utils/hungarianNaming");
 const importInsertion_1 = require("../utils/importInsertion");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
@@ -62,10 +63,45 @@ function getLastPropertyName(expr) {
     }
     return null;
 }
+/**
+ * The name used when the base contributes nothing spellable. Free of any type
+ * marker by construction, and the concept the memo actually stands for — the
+ * hash of the dependency's CONTENT, which is what depending on `.length`
+ * failed to track.
+ */
+const BASE_FREE_HASH_NAME = 'contentHash';
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+ * Names for the memo binding, in descending order of how much of the base they
+ * keep. `no-hungarian` ships as an error and is NOT fixable, so a name it
+ * rejects turns this fixer's work into a manual rename in a file that was clean
+ * beforehand (#1997) — every candidate is therefore checked against the same
+ * predicate that rule applies, and the first acceptable one wins.
+ *
+ * Which candidate that is follows from what `no-hungarian` rejects:
+ *
+ * - `<base>Hash` reads as the domain concept for almost every base and is the
+ *   preferred spelling.
+ * - A single-letter `b`/`i` base makes `bHash`/`iHash` look like a Hungarian
+ *   type prefix (b=boolean, i=integer) glued to a capital. `hashOf<Base>` says
+ *   the same thing with the base out of the leading position.
+ * - A base that IS a type word or its abbreviation (`obj`, `arr`, `str`,
+ *   `array`, `number`, ...) taints every name that carries it as a segment, so
+ *   no base-preserving candidate can succeed. Dropping the type-coded base is
+ *   exactly the rename `no-hungarian` asks for.
+ */
+function baseDerivedNames(base) {
+    return [`${base}Hash`, `hashOf${capitalize(base)}`];
+}
 function generateUniqueName(base, taken) {
-    const candidate = `${base}Hash`;
+    const candidate = baseDerivedNames(base).find((name) => !(0, hungarianNaming_1.encodesTypeMarker)(name)) ??
+        BASE_FREE_HASH_NAME;
     if (!taken.has(candidate))
         return candidate;
+    // A numeric suffix disambiguates without reopening the naming question: it
+    // adds no word boundary, so it cannot turn an accepted name into a marker.
     let i = 2;
     while (taken.has(`${candidate}${i}`)) {
         i++;

package/lib/rules/no-type-assertion-returns.js

@@ -352,10 +352,6 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     checkFunctionReturnType(node);
                 }
             },
-            // Check for array methods with type assertions
-            CallExpression() {
-                // Skip this check as we'll handle it in the TSAsExpression and TSTypeAssertion handlers
-            },
             // Check for type assertions in expressions
             TSAsExpression(node) {
                 // Allow 'as const' assertions if configured

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

@@ -122,6 +122,16 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
         const defaultImports = new Map();
         // Track re-exports and variable assignments
         const variableAssignments = new Map();
+        /**
+         * Names whose declaration leaves them holding `undefined` — `let key;` and
+         * `let key = undefined;` alike. Both falsy and nullish, which is what makes
+         * a later `||=`/`??=` onto one of them assign unconditionally.
+         */
+        const declaredUndefined = new Set();
+        /** Declarations and assignments seen per name, to bound the above to the provable case. */
+        const declarationCounts = new Map();
+        const assignmentCounts = new Map();
+        const isUndefinedIdentifier = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'undefined';
         const validQueryKeySources = new Set([
             'util/routing/queryKeys',
             'constants',
@@ -444,15 +454,46 @@ exports.preferGlobalRouterStateKey = (0, createRule_1.createRule)({
             },
             // Track variable declarations that might derive from query key constants
             VariableDeclarator(node) {
-                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier && node.init) {
-                    variableAssignments.set(node.id.name, node.init);
+                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const { name } = node.id;
+                declarationCounts.set(name, (declarationCounts.get(name) ?? 0) + 1);
+                if (node.init) {
+                    variableAssignments.set(name, node.init);
+                }
+                if (!node.init || isUndefinedIdentifier(node.init)) {
+                    declaredUndefined.add(name);
                 }
             },
             // Track assignment expressions
             AssignmentExpression(node) {
-                if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.operator === '=') {
-                    variableAssignments.set(node.left.name, node.right);
+                if (node.left.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                const { name } = node.left;
+                const assignmentCount = (assignmentCounts.get(name) ?? 0) + 1;
+                assignmentCounts.set(name, assignmentCount);
+                // Only a plain `=` makes the right-hand side the variable's value in
+                // general. A compound assignment leaves the prior value reachable
+                // (`key ||= K` is the old key OR K), so recording the operand would
+                // launder an unapproved key into an approved one.
+                if (node.operator === '=') {
+                    variableAssignments.set(name, node.right);
+                    return;
+                }
+                // The exception is a `||=`/`??=` onto a variable still holding
+                // `undefined`, which is both falsy and nullish: the assignment always
+                // happens, so the operand IS the value. A single declaration and a
+                // single assignment are what keep that provable — a second assignment
+                // anywhere puts a prior value back in play. `+=` is excluded because it
+                // concatenates onto `undefined` and yields neither operand.
+                //
+                // The operand is recorded rather than exempted, so it still has to be
+                // an approved constant to pass.
+                if ((node.operator === '||=' || node.operator === '??=') &&
+                    declaredUndefined.has(name) &&
+                    declarationCounts.get(name) === 1 &&
+                    assignmentCount === 1) {
+                    variableAssignments.set(name, node.right);
                 }
             },
             // Check useRouterState calls

package/lib/utils/hungarianNaming.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+export declare function encodesTypeMarker(name: string): boolean;

package/lib/utils/hungarianNaming.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodesTypeMarker = void 0;
+// Abbreviation type markers. No English word is spelled this way, so their
+// presence as a whole camelCase segment is unambiguously a type tag.
+const ABBREVIATION_MARKERS = ['str', 'num', 'int', 'bool', 'arr', 'obj'];
+const COMMON_TYPES = [
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Object',
+    'RegExp',
+    'Promise',
+    'Symbol',
+    'BigInt',
+];
+const TYPE_MARKERS = [
+    ...ABBREVIATION_MARKERS,
+    'array',
+    ...COMMON_TYPES,
+    'Class',
+    'Interface',
+    'Enum',
+];
+const ABBREVIATION_MARKER_SET = new Set(ABBREVIATION_MARKERS);
+const FULL_TYPE_WORDS = new Set(COMMON_TYPES.map((word) => word.toLowerCase()));
+// Single-letter Hungarian type prefixes (b=boolean, i=integer/index), matched
+// only as a strict camelCase prefix. This is the arm that rejects `bHash`.
+const SINGLE_LETTER_PREFIXES = new Set(['b', 'i']);
+const CAMEL_SEGMENT_REGEX = /[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g;
+function splitCamelSegmentsRaw(name) {
+    return name.match(CAMEL_SEGMENT_REGEX) ?? [];
+}
+// A built-in type word carrying an internal capital (BigInt) splits into parts
+// whose tail collides with an abbreviation marker (Int/int), so the parts are
+// re-merged into one atomic segment before segment matching.
+const MULTI_CAPITAL_TYPE_WORD_PARTS = COMMON_TYPES.map(splitCamelSegmentsRaw).filter((parts) => parts.length > 1);
+function mergeMultiCapitalTypeWords(segments) {
+    const merged = [];
+    let index = 0;
+    while (index < segments.length) {
+        const match = MULTI_CAPITAL_TYPE_WORD_PARTS.find((parts) => parts.every((part, offset) => segments[index + offset]?.toLowerCase() === part.toLowerCase()));
+        if (match) {
+            merged.push(segments.slice(index, index + match.length).join(''));
+            index += match.length;
+        }
+        else {
+            merged.push(segments[index]);
+            index += 1;
+        }
+    }
+    return merged;
+}
+function splitCamelSegments(name) {
+    return mergeMultiCapitalTypeWords(splitCamelSegmentsRaw(name));
+}
+function isPascalCaseName(name) {
+    return /^[A-Z]/.test(name) && name !== name.toUpperCase();
+}
+// A PascalCase name whose type word qualifies a DIFFERENT head noun names a
+// concept or relation (StringToNumber, NumberAmountEditor), not the value's own
+// runtime type.
+function isSemanticTypeConcept(name) {
+    const segments = splitCamelSegments(name);
+    if (segments.length < 2) {
+        return false;
+    }
+    const hasTypeWord = segments.some((segment) => FULL_TYPE_WORDS.has(segment.toLowerCase()));
+    if (!hasTypeWord) {
+        return false;
+    }
+    return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
+}
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+function encodesTypeMarker(name) {
+    if (isPascalCaseName(name) && isSemanticTypeConcept(name)) {
+        return false;
+    }
+    if (name.length > 1 &&
+        SINGLE_LETTER_PREFIXES.has(name[0]) &&
+        /[A-Z]/.test(name[1])) {
+        return true;
+    }
+    const normalizedName = name.toLowerCase();
+    return TYPE_MARKERS.some((marker) => {
+        const normalizedMarker = marker.toLowerCase();
+        if (normalizedName === normalizedMarker) {
+            return false;
+        }
+        // An abbreviation marker is a type tag only as a whole segment: "int"
+        // inside "Mint" or "point" is a word fragment, not a tag.
+        if (ABBREVIATION_MARKER_SET.has(normalizedMarker)) {
+            return splitCamelSegments(name).some((segment) => segment.toLowerCase() === normalizedMarker);
+        }
+        // A full type word tags the value's type only at a word boundary in
+        // leading or trailing position; a middle segment qualifies a domain concept.
+        if (normalizedName.startsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            /[A-Z0-9]/.test(name[normalizedMarker.length])) {
+            return true;
+        }
+        return (normalizedName.endsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            (/[A-Z0-9]/.test(name[name.length - normalizedMarker.length - 1]) ||
+                /[A-Z]/.test(name[name.length - normalizedMarker.length])));
+    });
+}
+exports.encodesTypeMarker = encodesTypeMarker;
+//# sourceMappingURL=hungarianNaming.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,57 @@
 [
+  {
+    "version": "1.20.150",
+    "date": "2026-08-13T19:12:01.840Z",
+    "rules": [
+      {
+        "name": "enforce-exported-function-types",
+        "changeType": "fix",
+        "issues": [
+          2000
+        ],
+        "summary": "drop 28 inert empty-bodied selectors (closes #2000)"
+      },
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          1999,
+          2001
+        ],
+        "summary": "follow a `||=`/`??=` onto an undefined key (#2001); guard variable tracking on a plain `=` assignment (closes #1999)"
+      },
+      {
+        "name": "no-type-assertion-returns",
+        "changeType": "fix",
+        "issues": [
+          2002
+        ],
+        "summary": "drop the inert empty CallExpression handler (closes #2002)"
+      },
+      {
+        "name": "prefer-global-router-state-key",
+        "changeType": "fix",
+        "issues": [
+          2001
+        ],
+        "summary": "follow a `||=`/`??=` onto an undefined key (closes #2001)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.149",
+    "date": "2026-08-13T16:22:27.196Z",
+    "rules": [
+      {
+        "name": "no-array-length-in-deps",
+        "changeType": "fix",
+        "issues": [
+          1997
+        ],
+        "summary": "emit a hash name no-hungarian accepts (closes #1997)"
+      }
+    ]
+  },
   {
     "version": "1.20.148",
     "date": "2026-08-13T13:06:17.038Z",