@blumintinc/eslint-plugin-blumint 1.20.67 → 1.20.69

package/lib/index.js

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

package/lib/rules/enforce-early-destructuring.js

@@ -3,6 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceEarlyDestructuring = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+/**
+ * Source forms that already bind tighter than `??`, so wrapping them in the
+ * hoisted `(obj) ?? {}` initializer adds parentheses a formatter then strips.
+ *
+ * The set is deliberately limited to what this rule can actually emit: only an
+ * identifier-rooted source is ever hoisted, so a call, conditional or logical
+ * source never reaches here. Anything absent keeps its parentheses, which is the
+ * safe direction — a stray pair is cosmetic, a missing pair changes what the
+ * initializer evaluates. `as` and `satisfies` are excluded on purpose: TypeScript
+ * rejects them beside `??` unparenthesized.
+ */
+const TIGHTER_THAN_NULLISH = new Set([
+    utils_1.AST_NODE_TYPES.Identifier,
+    utils_1.AST_NODE_TYPES.ThisExpression,
+    utils_1.AST_NODE_TYPES.MemberExpression,
+    utils_1.AST_NODE_TYPES.ChainExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+const nullishSourceText = (objectText, init) => init && TIGHTER_THAN_NULLISH.has(init.type) ? objectText : `(${objectText})`;
 const HOOK_NAMES = new Set([
     'useEffect',
     'useMemo',
@@ -875,7 +894,7 @@ function generateHoistingFixes(groups, callback, depsArray, depTexts, insertionS
     for (const group of groups.values()) {
         const sortedProps = Array.from(group.properties.values()).sort((a, b) => a.order - b.order);
         const pattern = `{ ${sortedProps.map((p) => p.text).join(', ')} }`;
-        hoistedLines.push(`${indent}const ${pattern} = (${group.objectText}) ?? {};`);
+        hoistedLines.push(`${indent}const ${pattern} = ${nullishSourceText(group.objectText, group.inits[0])} ?? {};`);
     }
     reservedNamesByScope.set(scope, updatedReservedNames);
     const newDepSet = new Set(newDepTexts);

package/lib/rules/enforce-render-hits-memoization.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'requireMemoizedTransformBefore' | 'requireMemoizedRender' | 'requireMemoizedRenderHits' | 'noDirectComponentInRender';
-export declare const enforceRenderHitsMemoization: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const enforceRenderHitsMemoization: TSESLint.RuleModule<MessageIds, [], TSESLint.RuleListener>;
 export {};

package/lib/rules/enforce-render-hits-memoization.js

@@ -3,6 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceRenderHitsMemoization = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+/**
+ * Declaration forms whose binding is created once for the program's lifetime.
+ *
+ * `let` and `var` are deliberately excluded: a reassignable binding can hand
+ * `useRenderHits` a different function on a later render, which is precisely
+ * the instability this rule exists to catch.
+ */
+function isStableDeclaration(def) {
+    switch (def.type) {
+        case utils_1.TSESLint.Scope.DefinitionType.FunctionName:
+            return true;
+        case utils_1.TSESLint.Scope.DefinitionType.ImportBinding:
+            // A type-only import binds no value, so its local name names nothing
+            // callable — the same reason the memoization-callee set rejects one.
+            return (def.parent.importKind !== 'type' &&
+                (def.node.type !== utils_1.AST_NODE_TYPES.ImportSpecifier ||
+                    def.node.importKind !== 'type'));
+        case utils_1.TSESLint.Scope.DefinitionType.Variable:
+            return def.parent.kind === 'const';
+        default:
+            return false;
+    }
+}
 exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
     name: 'enforce-render-hits-memoization',
     meta: {
@@ -13,14 +38,36 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            requireMemoizedTransformBefore: 'transformBefore prop must be memoized using useCallback',
-            requireMemoizedRender: 'render prop must be memoized using useCallback',
-            requireMemoizedRenderHits: 'renderHits must be used inside useMemo or useCallback',
+            requireMemoizedTransformBefore: 'transformBefore is recreated on every render, so useRenderHits sees a new transform identity each pass and re-derives (and re-renders) the whole hit list even when the hits did not change. Memoize it with useCallback, useMemo, or useLatestCallback so the reference stays stable across renders.',
+            requireMemoizedRender: 'render is recreated on every render, so useRenderHits sees a new render identity each pass and re-renders every hit even when the hits did not change. Memoize it with useCallback, useMemo, or useLatestCallback so the reference stays stable across renders.',
+            requireMemoizedRenderHits: 'renderHits builds a fresh element for every hit, so calling it outside a memoization boundary re-creates the entire list on each render. Wrap the call in useCallback, useMemo, or useLatestCallback so the elements are rebuilt only when the hits they came from change.',
             noDirectComponentInRender: 'Do not pass React components directly to render prop, use a memoized arrow function instead',
         },
     },
     defaultOptions: [],
     create(context) {
+        // Every callee this rule accepts as a memoization boundary. `useCallback`
+        // and `useMemo` are seeded bare because the rule never resolves React's
+        // import either; local names bound from `use-latest-callback` are added as
+        // its imports are visited.
+        //
+        // `useLatestCallback` belongs in the same set rather than a separate one:
+        // nothing here inspects a dependency array, so the hook taking none (it
+        // keeps the latest callback behind a ref that is stable for the component's
+        // whole life) costs the rule no precision. It has to be here because
+        // `use-latest-callback` — 'error' in the same recommended config, and
+        // fixable — rewrites every `useCallback` into it, and ESLint re-lints until
+        // the output settles, so one `eslint --fix` run does both steps. Without
+        // this entry correctly memoized code goes in and a demand to memoize it
+        // comes out, and the demand names the very hook the sibling fixer just
+        // removed, so following it loops forever (issue #1585).
+        const memoizationCallees = new Set([
+            'useCallback',
+            'useMemo',
+            LATEST_CALLBACK_HOOK,
+        ]);
+        const isMemoizationCallee = (node) => node.type === utils_1.AST_NODE_TYPES.Identifier &&
+            memoizationCallees.has(node.name);
         const isReactComponent = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
@@ -29,17 +76,30 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         const isMemoizedCall = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
                 return false;
-            if (!node.callee || node.callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+            if (!node.callee)
                 return false;
-            return (node.callee.name === 'useCallback' || node.callee.name === 'useMemo');
+            return isMemoizationCallee(node.callee);
+        };
+        const isWithinMemoizationCall = (node) => {
+            let current = node;
+            while (current?.parent) {
+                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isMemoizationCallee(current.parent.callee)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
         };
         const isMemoizedVariable = (node) => {
             if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
                 return false;
-            // Get the variable declaration for this identifier
-            const variable = context
-                .getScope()
-                .variables.find((v) => v.name === node.name);
+            // The whole scope chain has to be searched rather than the current
+            // scope's own variable list: a useRenderHits call sitting inside a nested
+            // block or a nested component reaches its memoized declaration through an
+            // enclosing scope, and reading one scope's `variables` would miss it and
+            // demand a useCallback around a value that already has one.
+            const variable = utils_1.ASTUtils.findVariable(context.getScope(), node);
             if (!variable)
                 return false;
             // Check if the variable is initialized with a memoized call
@@ -55,6 +115,45 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             }
             return false;
         };
+        /**
+         * A prop pointing at a declaration that lives outside every component body.
+         *
+         * Module scope creates the binding once for the program's lifetime, so its
+         * identity is strictly more stable than anything a hook can hand back:
+         * demanding a `useCallback` wrapper around it asks for work that can only
+         * make the reference less stable, never more.
+         *
+         * Both `module` and `global` count. Under `sourceType: 'script'` — the
+         * parser default, and what a consumer's config may well leave in place — a
+         * top-level declaration binds to the *global* scope and no module scope
+         * exists at all (issue #1578), so keying on `module` alone would silently
+         * drop the carve-out for exactly the consumers who never opted into module
+         * parsing.
+         *
+         * The shape is not hypothetical:
+         * `no-empty-dependency-use-callbacks` — 'error' in the same recommended
+         * config, and fixable — hoists a dependency-free callback to module scope
+         * and drops the hook, so one `eslint --fix` run rewrites memoized code into
+         * exactly this form. Without the carve-out the config demands the very hook
+         * its own fixer just removed (issue #1586).
+         */
+        const isStableOuterScopeBinding = (node) => {
+            if (node.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            // The scope chain has to be walked rather than a single scope's variable
+            // list read: the useRenderHits call sits inside the component, so a
+            // module-scope declaration is never among the current scope's own
+            // variables.
+            const variable = utils_1.ASTUtils.findVariable(context.getScope(), node);
+            if (!variable)
+                return false;
+            const scopeType = variable.scope.type;
+            if (scopeType !== utils_1.TSESLint.Scope.ScopeType.module &&
+                scopeType !== utils_1.TSESLint.Scope.ScopeType.global) {
+                return false;
+            }
+            return variable.defs.some(isStableDeclaration);
+        };
         const isInsideMemoizedCall = (node) => {
             // Handle the case when node is already a memoized call
             if (isMemoizedCall(node))
@@ -62,18 +161,13 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             // Check if the node is a reference to a memoized variable
             if (isMemoizedVariable(node))
                 return true;
+            // A declaration outside every component body needs no memoization: it is
+            // already as stable as a reference can be.
+            if (isStableOuterScopeBinding(node))
+                return true;
             // Check if the node is inside a memoization hook call
-            let current = node;
-            while (current?.parent) {
-                if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callee = current.parent.callee;
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                        return true;
-                    }
-                }
-                current = current.parent;
-            }
+            if (isWithinMemoizationCall(node))
+                return true;
             // Check if the node is a reference to a memoized value
             const scope = context.getScope();
             // Make sure node is an Identifier before accessing name property
@@ -88,44 +182,22 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
             for (const def of variable.defs) {
                 const parent = def.node.parent;
                 if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callee = parent.init.callee;
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                        return true;
-                    }
+                    parent.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isMemoizationCallee(parent.init.callee)) {
+                    return true;
                 }
             }
             // Check if any reference is inside a memoized call
             for (const ref of variable.references) {
-                let current = ref.identifier;
-                while (current?.parent) {
-                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        const callee = current.parent.callee;
-                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                            return true;
-                        }
-                    }
-                    current = current.parent;
-                }
+                if (isWithinMemoizationCall(ref.identifier))
+                    return true;
             }
             // Check if the node is a property of an object that is memoized
             const parent = node.parent;
             if (parent?.type === utils_1.AST_NODE_TYPES.Property &&
                 parent.parent?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                const objectExpression = parent.parent;
-                let current = objectExpression;
-                while (current?.parent) {
-                    if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                        const callee = current.parent.callee;
-                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                            return true;
-                        }
-                    }
-                    current = current.parent;
-                }
+                if (isWithinMemoizationCall(parent.parent))
+                    return true;
             }
             return false;
         };
@@ -133,6 +205,23 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
         let renderHitsName = 'renderHits';
         return {
             ImportDeclaration(node) {
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name, falling back to `useLatestCallback2` when `useLatestCallback`
+                // is already taken in the file, so the alias is not hypothetical.
+                if (node.source.value === LATEST_CALLBACK_MODULE &&
+                    (!node.importKind || node.importKind === 'value')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                specifier.importKind !== 'type' &&
+                                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                            memoizationCallees.add(specifier.local.name);
+                        }
+                    }
+                }
                 if (node.source.value.endsWith('useRenderHits')) {
                     for (const specifier of node.specifiers) {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
@@ -160,43 +249,19 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                     const options = node.arguments[0];
                     if (options.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
                         return;
-                    // Variable to track if we need to check properties (check both by default)
-                    const checkProps = {
-                        transformBefore: true,
-                        render: true,
-                    };
-                    // First pass: Check if transformBefore or render properties exist as shorthand
-                    for (const prop of options.properties) {
-                        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
-                            continue;
-                        if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
-                            continue;
-                        // If it's shorthand property syntax like { transformBefore } and already a memoized variable
-                        if (prop.key.name === 'transformBefore' &&
-                            prop.shorthand &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            checkProps.transformBefore = !isMemoizedVariable(prop.key);
-                        }
-                        else if (prop.key.name === 'render' &&
-                            prop.shorthand &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            checkProps.render = !isMemoizedVariable(prop.key);
-                        }
-                    }
-                    // Second pass: Check non-shorthand properties
+                    // Shorthand props are checked exactly like written-out ones. `{ render }`
+                    // and `render: render` describe the same value, and the config's own
+                    // fixable `object-shorthand: ['error', 'always']` rewrites the second
+                    // into the first, so exempting the shorthand form would let a single
+                    // `eslint --fix` erase every report this rule makes about a prop whose
+                    // variable happens to share the API's name — the shape idiomatic code
+                    // reaches for first (issue #1588).
                     for (const prop of options.properties) {
                         if (prop.type !== utils_1.AST_NODE_TYPES.Property)
                             continue;
                         if (prop.key.type !== utils_1.AST_NODE_TYPES.Identifier)
                             continue;
-                        // Skip shorthand properties that we already checked
-                        if (prop.shorthand)
-                            continue;
-                        if (prop.key.name === 'transformBefore' &&
-                            checkProps.transformBefore) {
-                            // Skip if the value is already a memoized call
-                            if (isMemoizedCall(prop.value))
-                                continue;
+                        if (prop.key.name === 'transformBefore') {
                             if (!isInsideMemoizedCall(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -204,7 +269,7 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                                 });
                             }
                         }
-                        else if (prop.key.name === 'render' && checkProps.render) {
+                        else if (prop.key.name === 'render') {
                             if (isReactComponent(prop.value)) {
                                 context.report({
                                     node: prop.value,
@@ -222,17 +287,8 @@ exports.enforceRenderHitsMemoization = (0, createRule_1.createRule)({
                 }
                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
                     node.callee.name === renderHitsName) {
-                    let current = node;
-                    while (current?.parent) {
-                        if (current.parent.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                            const callee = current.parent.callee;
-                            if (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                (callee.name === 'useCallback' || callee.name === 'useMemo')) {
-                                return;
-                            }
-                        }
-                        current = current.parent;
-                    }
+                    if (isWithinMemoizationCall(node))
+                        return;
                     context.report({
                         node,
                         messageId: 'requireMemoizedRenderHits',

package/lib/rules/enforce-transform-memoization.js

@@ -4,6 +4,8 @@ exports.enforceTransformMemoization = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 exports.enforceTransformMemoization = (0, createRule_1.createRule)({
     name: 'enforce-transform-memoization',
     meta: {
@@ -26,7 +28,14 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
         const scopeManager = sourceCode.scopeManager;
         const adaptValueNames = new Set(['adaptValue']);
         const memoizingHooks = new Set(['useMemo', 'useCallback']);
-        const stabilizingUtilities = new Set(['useEvent']);
+        // Hooks that hand back a reference stable for the component's whole life and
+        // take no dependency array, so there is none to audit. `useLatestCallback`
+        // belongs here because `use-latest-callback` — 'error' in the same
+        // recommended config, and fixable — rewrites every `useCallback` into it and
+        // drops the array. ESLint re-lints until the output settles, so one
+        // `eslint --fix` run does both steps: without this entry, correctly
+        // memoized code goes in and a demand to memoize it comes out (issue #1584).
+        const stabilizingUtilities = new Set(['useEvent', LATEST_CALLBACK_HOOK]);
         const getPropertyName = (key) => {
             if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return key.name;
@@ -378,6 +387,23 @@ exports.enforceTransformMemoization = (0, createRule_1.createRule)({
         return {
             ImportDeclaration(node) {
                 const sourceValue = typeof node.source.value === 'string' ? node.source.value : '';
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name, and falls back to `useLatestCallback2` when `useLatestCallback`
+                // is already taken in the file, so the alias is not hypothetical.
+                if (sourceValue === LATEST_CALLBACK_MODULE &&
+                    (!node.importKind || node.importKind === 'value')) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                            (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                                specifier.importKind !== 'type' &&
+                                specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                            stabilizingUtilities.add(specifier.local.name);
+                        }
+                    }
+                }
                 for (const specifier of node.specifiers) {
                     if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&

package/lib/rules/optimize-object-boolean-conditions.js

@@ -101,6 +101,12 @@ function isPrimitiveTypeNode(node) {
  * operands: comparisons and arithmetic yield numbers/strings/booleans, and `!`,
  * `typeof` and friends yield booleans/strings/numbers.
  */
+/** `as const` — a type reference whose name is the `const` contextual keyword. */
+function isConstAssertion(typeNode) {
+    return (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        typeNode.typeName.name === 'const');
+}
 function isPrimitiveExpression(node) {
     if (!node) {
         return false;
@@ -120,7 +126,19 @@ function isPrimitiveExpression(node) {
         case utils_1.AST_NODE_TYPES.BinaryExpression:
             return true;
         case utils_1.AST_NODE_TYPES.TSAsExpression:
-            return isPrimitiveTypeNode(node.typeAnnotation);
+            // `as const` narrows rather than retypes, so the asserted expression
+            // decides. Recursing keeps `{ a: 1 } as const` an object while accepting
+            // `0 as const` — the form global-const-style and
+            // enforce-object-literal-as-const rewrite bare constants into, so without
+            // this the plugin's own fixers manufacture the report (#1581).
+            return isConstAssertion(node.typeAnnotation)
+                ? isPrimitiveExpression(node.expression)
+                : isPrimitiveTypeNode(node.typeAnnotation);
+        // `satisfies` never changes the value, only checks it.
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            return isPrimitiveExpression(node.expression);
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            return isPrimitiveExpression(node.expression);
         default:
             return false;
     }

package/lib/rules/prefer-type-over-interface.js

@@ -47,6 +47,38 @@ function isInsideModuleAugmentation(node) {
     }
     return false;
 }
+/**
+ * Declaration merging is what `interface` can do and `type` cannot, so a name
+ * carrying more than one declaration is not a stylistic choice: rewriting one
+ * of the halves emits two declarations of the same name (TS2300) and silently
+ * splits the merged shape, so members that used to coexist no longer do.
+ *
+ * The check keys on the **declaring scope**, not on a count of the name across
+ * the file, because merging is a property of the declaration space. Two
+ * same-named interfaces in different function bodies or blocks are distinct
+ * types that never merge, and each of those still converts cleanly.
+ *
+ * Any second definition counts, not only another interface. `class A {}` and
+ * `enum A {}` occupy the same type-space slot a type alias would claim, so
+ * those conversions break the build too; `function A() {}` and
+ * `namespace A {}` are value-space only and would survive the rewrite, but
+ * they are rare enough that treating every co-declaration as merged costs
+ * almost nothing and keeps the rule from having to model TypeScript's merging
+ * table.
+ */
+function isMergedDeclaration(context, node) {
+    // The variable is located by the definition that points back at *this*
+    // declaration rather than by taking the first entry, so a parser that also
+    // surfaces the type parameters here cannot make the count read off the
+    // wrong name.
+    const declared = context
+        .getDeclaredVariables(node)
+        .find((variable) => variable.defs.some((definition) => definition.node === node));
+    // A scope manager that never registered the name tells us nothing about
+    // merging; falling through preserves the report rather than exempting on a
+    // missing signal.
+    return declared !== undefined && declared.defs.length > 1;
+}
 exports.preferTypeOverInterface = (0, createRule_1.createRule)({
     name: 'prefer-type-over-interface',
     meta: {
@@ -70,6 +102,12 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
                 if (isInsideModuleAugmentation(node)) {
                     return;
                 }
+                // Reporting without a fix would be unactionable here — the author
+                // cannot honour it without collapsing the merge by hand — and an
+                // unactionable report is what manufactures `eslint-disable` (#1568).
+                if (isMergedDeclaration(context, node)) {
+                    return;
+                }
                 context.report({
                     node,
                     messageId: 'preferType',

package/lib/rules/prefer-union-from-const-array.js

@@ -54,17 +54,28 @@ function isNameInScope(scope, name) {
  * between consecutive lines. Reading it from the source keeps emitted code in
  * the author's units instead of assuming a two-space, space-indented file.
  */
-function indentUnitOf(text) {
+function indentUnitOf(sourceCode) {
+    const text = sourceCode.getText();
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry whatever alignment the comment uses
+    // — the `*` one column in from its own indentation, or, for commented-out
+    // code, the original code's depths. Neither is a nesting step of the file, and
+    // counting them makes a JSDoc-heavy file look 1-space indented. Keying on the
+    // comment's range rather than a leading `*` also covers a body without them.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
     const frequencies = new Map();
     let previous = '';
+    let offset = 0;
     for (const line of text.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
         if (line.trim() === '') {
             continue;
         }
-        // A block comment's continuation lines align on the `*` one column in from
-        // the comment's own indentation. That is comment alignment, not a nesting
-        // step, and counting it makes any JSDoc-heavy file look 1-space indented.
-        if (line.trimStart().startsWith('*')) {
+        if (continuesBlockComment(lineStart)) {
             continue;
         }
         const match = /^[ \t]*/.exec(line);
@@ -121,7 +132,7 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
         let indentUnit = null;
         const fileIndentUnit = () => {
             if (indentUnit === null) {
-                indentUnit = indentUnitOf(sourceCode.getText());
+                indentUnit = indentUnitOf(sourceCode);
             }
             return indentUnit;
         };

package/lib/rules/use-latest-callback.d.ts

@@ -1,3 +1,8 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const useLatestCallback: TSESLint.RuleModule<"useLatestCallback", [], TSESLint.RuleListener>;
+type Options = [
+    {
+        printWidth?: number;
+    }
+];
+export declare const useLatestCallback: TSESLint.RuleModule<"useLatestCallback", Options, TSESLint.RuleListener>;
 export default useLatestCallback;

package/lib/rules/use-latest-callback.js

@@ -4,6 +4,13 @@ exports.useLatestCallback = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+/**
+ * Matches Prettier's own default. Dropping the dependency array lets the call
+ * collapse onto one line, so the fixer decides a line break a formatter owns: a
+ * line it emits past this width is rewritten on the next `prettier --write`, and
+ * fails `prettier --check` in the meantime.
+ */
+const DEFAULT_PRINT_WIDTH = 80;
 const LATEST_CALLBACK_MODULE = 'use-latest-callback';
 const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 /**
@@ -44,6 +51,7 @@ const findLatestCallbackImport = (program) => {
     }
     return null;
 };
+const isComma = (token) => !!token && token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ',';
 /** The leading whitespace of the line the offset sits on. */
 const indentationAt = (sourceCode, offset) => {
     const text = sourceCode.getText();
@@ -51,6 +59,75 @@ const indentationAt = (sourceCode, offset) => {
     const match = /^[ \t]*/.exec(text.slice(lineStart, offset));
     return match ? match[0] : '';
 };
+/** The indentation of an offset that starts its own line, else null. */
+const ownLineIndentAt = (sourceCode, offset) => {
+    const text = sourceCode.getText();
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const lead = text.slice(lineStart, offset);
+    return lead.trim() === '' ? lead : null;
+};
+/**
+ * The file's own nesting step, taken as the most common indentation increase
+ * between consecutive lines. Reading it from the source keeps emitted code in
+ * the author's units instead of assuming a two-space, space-indented file.
+ */
+const indentUnitOf = (sourceCode) => {
+    const text = sourceCode.getText();
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry whatever alignment the comment uses
+    // — the `*` one column in from its own indentation, or, for commented-out
+    // code, the original code's depths. Neither is a nesting step of the file, and
+    // counting them makes a JSDoc-heavy file look 1-space indented. Keying on the
+    // comment's range rather than a leading `*` also covers a body without them.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
+    const frequencies = new Map();
+    let previous = '';
+    let offset = 0;
+    for (const line of text.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        if (line.trim() === '') {
+            continue;
+        }
+        if (continuesBlockComment(lineStart)) {
+            continue;
+        }
+        const match = /^[ \t]*/.exec(line);
+        const indent = match ? match[0] : '';
+        if (indent.length > previous.length && indent.startsWith(previous)) {
+            const delta = indent.slice(previous.length);
+            frequencies.set(delta, (frequencies.get(delta) ?? 0) + 1);
+        }
+        previous = indent;
+    }
+    let unit = '  ';
+    let best = 0;
+    for (const [delta, count] of frequencies) {
+        if (count > best) {
+            unit = delta;
+            best = count;
+        }
+    }
+    return unit;
+};
+/** The source with every planned edit applied, used to measure emitted lines. */
+const applyEdits = (text, edits) => {
+    const ordered = [...edits].sort((a, b) => b.range[0] - a.range[0]);
+    let result = text;
+    for (const edit of ordered) {
+        result = `${result.slice(0, edit.range[0])}${edit.text}${result.slice(edit.range[1])}`;
+    }
+    return result;
+};
+/** The length of the line `offset` sits on. */
+const lineLengthAt = (text, offset) => {
+    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
+    const lineBreak = text.indexOf('\n', offset);
+    return (lineBreak === -1 ? text.length : lineBreak) - lineStart;
+};
 /**
  * Ranges whose interior line breaks carry string data rather than formatting.
  * A multi-line template literal (or a string spliced together with line
@@ -65,42 +142,42 @@ const stringDataRangesOf = (sourceCode, node) => sourceCode
     token.loc.start.line !== token.loc.end.line)
     .map((token) => token.range);
 /**
- * The callback's text re-indented for the line the rewritten call puts it on.
+ * A per-line transform moving text written at `fromIndent` to `toIndent`, or
+ * null when neither indentation is a prefix of the other (tabs against spaces),
+ * where no delta can be applied without corrupting the layout.
+ */
+const lineShifterBetween = (fromIndent, toIndent) => {
+    if (fromIndent === toIndent) {
+        return (line) => line;
+    }
+    if (fromIndent.startsWith(toIndent)) {
+        const removed = fromIndent.slice(toIndent.length);
+        return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
+    }
+    if (toIndent.startsWith(fromIndent)) {
+        const added = toIndent.slice(fromIndent.length);
+        return (line) => `${added}${line}`;
+    }
+    return null;
+};
+/**
+ * The callback's text with its continuation lines moved from the depth it was
+ * written at to `toIndent`, or null when that move is not expressible.
  *
- * Dropping the dependency array lets the call collapse onto one line, and when
- * the original spelled the callback on a line of its own that collapse removes
- * exactly one nesting level. Emitting the callback verbatim would leave every
- * interior line indented for the level it no longer occupies (issue #1559), so
- * each line moves by the difference between the callback's original indentation
- * and the indentation of the line the call starts on. Preserving the original
- * multi-line layout instead is not an option: a lone function argument is
- * hugged onto the call line by the formatter, so the broken-out form would be
- * reformatted away on the next write.
+ * Dropping the dependency array changes the nesting level the callback sits at,
+ * so emitting it verbatim would leave every interior line indented for a level
+ * it no longer occupies (issue #1559). The first line is excluded because it is
+ * spliced in directly after the call's open paren (or after a fresh indent when
+ * the call is broken open), so it has no indentation of its own left to adjust.
  */
-const reindentedCallbackText = (sourceCode, call, callback) => {
+const reindentedText = (sourceCode, callback, fromIndent, toIndent) => {
     const text = sourceCode.getText(callback);
-    const callIndent = indentationAt(sourceCode, call.range[0]);
-    const callbackIndent = indentationAt(sourceCode, callback.range[0]);
-    // A callback already on the call's line loses no nesting level, so its body
-    // must be reproduced byte for byte.
-    if (callIndent === callbackIndent) {
+    if (!text.includes('\n')) {
         return text;
     }
-    const shiftLine = (() => {
-        if (callbackIndent.startsWith(callIndent)) {
-            const removed = callbackIndent.slice(callIndent.length);
-            return (line) => line.startsWith(removed) ? line.slice(removed.length) : line;
-        }
-        if (callIndent.startsWith(callbackIndent)) {
-            const added = callIndent.slice(callbackIndent.length);
-            return (line) => `${added}${line}`;
-        }
-        // Indent characters that disagree give no delta that can be applied
-        // without corrupting the layout, so the text is left as the author wrote it.
-        return null;
-    })();
+    const shiftLine = lineShifterBetween(fromIndent, toIndent);
     if (!shiftLine) {
-        return text;
+        return null;
     }
     const stringData = stringDataRangesOf(sourceCode, callback);
     const carriesStringData = (offset) => stringData.some(([start, end]) => start < offset && offset < end);
@@ -110,8 +187,6 @@ const reindentedCallbackText = (sourceCode, call, callback) => {
         .map((line, index) => {
         const lineStart = offset;
         offset += line.length + 1;
-        // The first line is spliced in after the call's open paren, so it has no
-        // indentation of its own left to adjust.
         if (index === 0 || line.trim() === '' || carriesStringData(lineStart)) {
             return line;
         }
@@ -119,6 +194,75 @@ const reindentedCallbackText = (sourceCode, call, callback) => {
     })
         .join('\n');
 };
+/**
+ * The callback's text for the collapsed, single-line call form. An indentation
+ * delta that cannot be applied leaves the text as the author wrote it, which is
+ * still valid code at the depth the formatter will correct it from.
+ */
+const collapsedCallbackText = (sourceCode, call, callback) => reindentedText(sourceCode, callback, indentationAt(sourceCode, callback.range[0]), indentationAt(sourceCode, call.range[0])) ?? sourceCode.getText(callback);
+/**
+ * Whether Prettier answers an over-long call by breaking the argument list
+ * open. It does for an arrow, and for a parameter-less function expression —
+ * but a function expression WITH parameters is instead hugged onto the call
+ * line with its parameter list broken, a shape this fixer cannot author. Left
+ * collapsed, such a call at least keeps the first line Prettier keeps.
+ */
+const breaksOpenWhenLong = (callback) => callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression ||
+    callback.params.length === 0;
+/**
+ * Whether the callback's own head — its parameter list, up to where its body
+ * begins — is spelled across several lines. An arrow written that way is never
+ * hugged onto the call's line, because that would leave the call's open paren
+ * and the arrow's dangling at the end of one line; Prettier breaks the argument
+ * list open instead however short the collapsed line measures. A function
+ * expression is the exception handled above: its broken parameter list IS hugged.
+ */
+const headSpansLines = (sourceCode, callback) => callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+    sourceCode
+        .getText()
+        .slice(callback.range[0], callback.body.range[0])
+        .includes('\n');
+/**
+ * Whether the rewritten call should end its argument list with a comma. The
+ * answer is the formatter's `trailingComma` setting, which is read off the call
+ * being rewritten whenever it was already broken open — that is exactly the
+ * shape the setting governs. A call the author kept on one line says nothing
+ * about it, so the modern default (and Prettier's own, from v3) is assumed.
+ */
+const wantsTrailingComma = (sourceCode, call) => {
+    const lastArgument = call.arguments[call.arguments.length - 1];
+    const closeParen = sourceCode.getLastToken(call);
+    if (!lastArgument || !closeParen) {
+        return true;
+    }
+    if (isComma(sourceCode.getTokenBefore(closeParen))) {
+        return true;
+    }
+    return closeParen.loc.start.line === lastArgument.loc.end.line;
+};
+/**
+ * The rewritten call with its argument list broken open — the callee on its own
+ * line, the callback one nesting step in, and the closing paren back at the
+ * statement's indentation. Null when the callback's lines cannot be moved to
+ * that depth, which asks the caller to keep the collapsed form.
+ */
+const brokenOpenCallText = (sourceCode, call, callback, head, indentUnit) => {
+    const callIndent = indentationAt(sourceCode, call.range[0]);
+    // A callback the author already broke onto its own line keeps the exact
+    // indentation it was written at, so that layout survives byte for byte.
+    const ownLineIndent = ownLineIndentAt(sourceCode, callback.range[0]);
+    const calleeIndent = ownLineIndent !== null &&
+        ownLineIndent.length > callIndent.length &&
+        ownLineIndent.startsWith(callIndent)
+        ? ownLineIndent
+        : `${callIndent}${indentUnit}`;
+    const moved = reindentedText(sourceCode, callback, indentationAt(sourceCode, callback.range[0]), calleeIndent);
+    if (moved === null) {
+        return null;
+    }
+    const comma = wantsTrailingComma(sourceCode, call) ? ',' : '';
+    return `${head}(\n${calleeIndent}${moved}${comma}\n${callIndent})`;
+};
 exports.useLatestCallback = (0, createRule_1.createRule)({
     name: 'use-latest-callback',
     meta: {
@@ -128,13 +272,27 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         fixable: 'code',
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    printWidth: {
+                        type: 'number',
+                        minimum: 1,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             useLatestCallback: 'Replace {{currentHook}} with {{recommendedHook}} from "use-latest-callback" so the callback keeps a stable reference while still reading the latest props/state. useCallback recreates functions whenever dependencies change, which can trigger needless renders and stale closures. Drop the dependency array when switching to {{recommendedHook}}.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const printWidth = typeof options.printWidth === 'number' && options.printWidth > 0
+            ? options.printWidth
+            : DEFAULT_PRINT_WIDTH;
         const filename = context.getFilename();
         if (filename.includes('/node_modules/')) {
             return {};
@@ -360,9 +518,6 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                 // The react import statement participates in the change set only when
                 // it binds useCallback or anchors a React.useCallback member call.
                 const touchesImport = specifiers.length > 0 || hasReactMemberUseCallback;
-                const isComma = (token) => !!token &&
-                    token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
-                    token.value === ',';
                 /**
                  * Splices out one named specifier and the comma that separates it from
                  * the list, touching nothing else. Re-emitting the surviving specifiers
@@ -480,13 +635,46 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     }
                     return fixes;
                 };
-                const conversionFix = (fixer, conversion) => {
-                    const callbackText = reindentedCallbackText(sourceCode, conversion.node, conversion.node.arguments[0]);
-                    const typeParams = conversion.node.typeParameters
-                        ? sourceCode.getText(conversion.node.typeParameters)
-                        : '';
-                    // Replace useCallback with useLatestCallback and remove the dependency array
-                    return fixer.replaceText(conversion.node, `${recommendedHook}${typeParams}(${callbackText})`);
+                /**
+                 * The replacement text for every batched call, collapsed onto one line
+                 * except where that line would overrun the print width.
+                 *
+                 * Prettier hugs a lone function argument onto the call line while it
+                 * fits, so collapsing is the shape that survives the next write — and
+                 * over-wrapping is not the safe direction, since a broken-open call
+                 * short enough to fit is collapsed straight back. Past the width the
+                 * two swap places, so the emitted line is MEASURED against the source
+                 * with every collapse already applied, rather than predicted from the
+                 * call's parts (issue #1579).
+                 */
+                const conversionTexts = () => {
+                    const headOf = (call) => `${recommendedHook}${call.typeParameters ? sourceCode.getText(call.typeParameters) : ''}`;
+                    const collapsed = batchedConversions.map((conversion) => ({
+                        conversion,
+                        edit: {
+                            range: conversion.node.range,
+                            text: `${headOf(conversion.node)}(${collapsedCallbackText(sourceCode, conversion.node, conversion.node.arguments[0])})`,
+                        },
+                    }));
+                    const source = sourceCode.getText();
+                    const simulated = applyEdits(source, collapsed.map(({ edit }) => edit));
+                    const shiftBefore = (offset) => collapsed
+                        .filter(({ edit }) => edit.range[1] <= offset)
+                        .reduce((total, { edit }) => total + edit.text.length - (edit.range[1] - edit.range[0]), 0);
+                    const indentUnit = indentUnitOf(sourceCode);
+                    const texts = new Map();
+                    for (const { conversion, edit } of collapsed) {
+                        const { node } = conversion;
+                        const start = node.range[0] + shiftBefore(node.range[0]);
+                        const callback = node.arguments[0];
+                        const overflows = lineLengthAt(simulated, start) > printWidth ||
+                            headSpansLines(sourceCode, callback);
+                        const broken = overflows && breaksOpenWhenLong(callback)
+                            ? brokenOpenCallText(sourceCode, node, callback, headOf(node), indentUnit)
+                            : null;
+                        texts.set(node, broken ?? edit.text);
+                    }
+                    return texts;
                 };
                 // Every call-site conversion and the import rewrite ride on ONE fix
                 // from ONE report. ESLint discards a multi-part fix wholesale when any
@@ -512,8 +700,9 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         if (!batchedConversions.every(reachesHook)) {
                             return null;
                         }
+                        const texts = conversionTexts();
                         return [
-                            ...batchedConversions.map((conversion) => conversionFix(fixer, conversion)),
+                            ...batchedConversions.map((conversion) => fixer.replaceText(conversion.node, texts.get(conversion.node))),
                             ...importFixes(fixer),
                         ];
                     },

package/lib/utils/ruleTester.d.ts

@@ -17,9 +17,11 @@ type ParserOptionsCarrier = {
  * and its rule silently drops out of the fixer, convergence, collision and
  * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
  *
- * A file needing parser options the shared instances do not declare — ES module
- * scope analysis, a type-aware `project` — attaches them per case rather than
- * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * A file needing parser options the shared instances do not declare — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. RuleTester deep merges each case's config over the tester's,
  * and options a case declares itself still win over the ones applied here, so a
  * case keeps any override it already had. Carrying the options on the case also
  * means the harvested corpus records the parser configuration a snippet was

package/lib/utils/ruleTester.js

@@ -3,12 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withParserOptions = exports.ruleTesterMarkdown = exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const eslint_1 = require("eslint");
+/**
+ * `sourceType: 'module'` matches how the linted codebase actually parses: every
+ * consumer source file is an ES module, so its top-level declarations live in a
+ * module scope nested inside the global one.
+ *
+ * `@typescript-eslint/parser` defaults to `'script'`, under which a top-level
+ * `import`/`const` still binds — the binding hangs off the *global* scope rather
+ * than a module scope. References therefore still resolve either way, but the
+ * scope shape differs: under `'script'` `globalScope.variables` carries the
+ * file's own declarations and there is no module scope at all. A rule that
+ * discriminates on `scope.type`, walks `globalScope.childScopes`, or reads
+ * `globalScope.variables` would otherwise be exercised against a shape no real
+ * file has. `src/tests/rule-tester-parse-mode.test.ts` pins this.
+ */
+const SHARED_PARSER_OPTIONS = {
+    sourceType: 'module',
+};
 exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
+    parserOptions: { ...SHARED_PARSER_OPTIONS },
 });
 exports.ruleTesterJsx = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
     parserOptions: {
+        ...SHARED_PARSER_OPTIONS,
         ecmaFeatures: {
             jsx: true,
         },
@@ -32,9 +51,11 @@ exports.ruleTesterMarkdown = new eslint_1.RuleTester({
  * and its rule silently drops out of the fixer, convergence, collision and
  * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
  *
- * A file needing parser options the shared instances do not declare — ES module
- * scope analysis, a type-aware `project` — attaches them per case rather than
- * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * A file needing parser options the shared instances do not declare — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. RuleTester deep merges each case's config over the tester's,
  * and options a case declares itself still win over the ones applied here, so a
  * case keeps any override it already had. Carrying the options on the case also
  * means the harvested corpus records the parser configuration a snippet was

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,74 @@
 [
+  {
+    "version": "1.20.69",
+    "date": "2026-08-01T20:48:40.484Z",
+    "rules": [
+      {
+        "name": "enforce-early-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1580
+        ],
+        "summary": "stop parenthesizing a source that already binds tighter than ?? (closes #1580)"
+      },
+      {
+        "name": "enforce-render-hits-memoization",
+        "changeType": "fix",
+        "issues": [
+          1585,
+          1586,
+          1588
+        ],
+        "summary": "report shorthand props (closes #1588); accept a module-scope function as already stable (closes #1586); recognise useLatestCallback as a memoization boundary (closes #1585)"
+      },
+      {
+        "name": "enforce-transform-memoization",
+        "changeType": "fix",
+        "issues": [
+          1584
+        ],
+        "summary": "recognise useLatestCallback as a stabilizing wrapper (closes #1584)"
+      },
+      {
+        "name": "optimize-object-boolean-conditions",
+        "changeType": "fix",
+        "issues": [
+          1581
+        ],
+        "summary": "see through `as const` when judging a primitive (closes #1581)"
+      },
+      {
+        "name": "prefer-type-over-interface",
+        "changeType": "fix",
+        "issues": [
+          1583
+        ],
+        "summary": "exempt merged interface declarations (closes #1583)"
+      },
+      {
+        "name": "use-latest-callback",
+        "changeType": "fix",
+        "issues": [
+          1579
+        ],
+        "summary": "keep the call broken open when collapsing overflows the print width (closes #1579)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.68",
+    "date": "2026-08-01T18:03:14.950Z",
+    "rules": [
+      {
+        "name": "prefer-union-from-const-array",
+        "changeType": "fix",
+        "issues": [
+          1577
+        ],
+        "summary": "exclude block comments by range when inferring the indent unit (closes #1577)"
+      }
+    ]
+  },
   {
     "version": "1.20.67",
     "date": "2026-08-01T17:17:30.817Z",