@blumintinc/eslint-plugin-blumint 1.20.147 → 1.20.148

package/lib/index.js

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

package/lib/rules/class-methods-read-top-to-bottom.js

@@ -8,14 +8,72 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 // derive names from the same function: any disagreement makes the two arrays
 // differ in length and silently skips the whole class body.
 const getMemberName = ClassGraphBuilder_1.classMemberNameOf;
+/**
+ * The class members each member reads once its own body executes, keyed by
+ * member name. A method (or accessor) contributes its whole body; a field
+ * holding a function contributes that function's body, since `this.f()` runs it
+ * with the instance bound.
+ *
+ * An initializer that invokes such a member runs that body during
+ * construction, which makes those reads exactly as eager as the initializer's
+ * own — the syntactic eager-read scan stops at the call and cannot see them.
+ */
+function readsWhenInvokedOf(node, className) {
+    const readsByMember = new Map();
+    for (const member of node.body) {
+        const name = getMemberName(member);
+        if (name === null) {
+            continue;
+        }
+        // The constructor is unreachable from an initializer — field initializers
+        // run inside it — so its body constrains nothing.
+        if (member.type === 'MethodDefinition' && member.kind !== 'constructor') {
+            readsByMember.set(name, ASTHelpers_1.ASTHelpers.classMemberNamesReferenced(member, className));
+            continue;
+        }
+        if (member.type === 'PropertyDefinition' &&
+            (member.value?.type === 'ArrowFunctionExpression' ||
+                member.value?.type === 'FunctionExpression')) {
+            // The function's body is passed rather than the function itself, because
+            // a `function` expression called as `this.f()` binds `this` to the
+            // instance even though the node type otherwise rebinds it.
+            readsByMember.set(name, ASTHelpers_1.ASTHelpers.classMemberNamesReferenced(member.value.body, className));
+        }
+    }
+    return readsByMember;
+}
+/**
+ * Every member name an initializer reads during construction, following each
+ * invoked member into what its own body reads until the set stops growing.
+ *
+ * The closure is deliberately blind to whether a named member is called or
+ * merely referenced: treating a bare reference as an invocation only adds
+ * constraints, and an extra constraint costs a declined reorder while a missing
+ * one ships a class that throws at construction.
+ */
+function eagerReadClosureOf(initializer, className, readsWhenInvoked) {
+    const reached = new Set();
+    const pending = ASTHelpers_1.ASTHelpers.classMemberNamesReadEagerly(initializer, className);
+    while (pending.length > 0) {
+        const name = pending.pop();
+        if (reached.has(name)) {
+            continue;
+        }
+        reached.add(name);
+        pending.push(...(readsWhenInvoked.get(name) || []));
+    }
+    return [...reached];
+}
 /**
  * Whether the proposed order still declares every field above the initializer
  * that reads it. Only field-to-field reads constrain the layout: methods (and
  * private methods) are installed before any initializer runs, so relocating one
- * is unobservable.
+ * is unobservable — but a field read reached THROUGH such a method still
+ * constrains it, because the call happens while the initializer runs.
  */
 function initializerReadsPrecedeDeclarations(node, sortedOrder, graph, className) {
     const positionOf = new Map(sortedOrder.map((name, index) => [name, index]));
+    const readsWhenInvoked = readsWhenInvokedOf(node, className);
     return node.body.every((member) => {
         if (member.type !== 'PropertyDefinition' || !member.value) {
             return true;
@@ -23,13 +81,24 @@ function initializerReadsPrecedeDeclarations(node, sortedOrder, graph, className
         const reader = getMemberName(member);
         const readerPosition = reader === null ? undefined : positionOf.get(reader);
         if (readerPosition === undefined) {
-            return true;
+            // An initializer the sorted order cannot place is one whose reads cannot
+            // be compared against it, so no order can be certified safe.
+            return false;
         }
-        return ASTHelpers_1.ASTHelpers.classMemberNamesReadEagerly(member.value, className)
-            .filter((name) => graph[name]?.type === 'property' && name !== reader)
+        return eagerReadClosureOf(member.value, className, readsWhenInvoked)
+            .filter((name) => name !== reader)
             .every((name) => {
+            const target = graph[name];
+            // A read the sort cannot place — inherited, mixed in, or a constructor
+            // parameter property — leaves the layout uncertifiable.
+            if (!target) {
+                return false;
+            }
+            if (target.type !== 'property') {
+                return true;
+            }
             const readPosition = positionOf.get(name);
-            return readPosition === undefined || readPosition < readerPosition;
+            return readPosition !== undefined && readPosition < readerPosition;
         });
     });
 }

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

@@ -691,6 +691,140 @@ function hasPriorConditionalGuard(node, baseName, visitorKeys) {
         Boolean(statement.test) &&
         testContainsObjectMember(statement.test, baseName, visitorKeys));
 }
+/**
+ * Statement forms that can skip the declaration nested beneath them, so a
+ * declaration inside one is not reached on every pass through the callback.
+ * `finally` is folded in with the rest of `try`: the distinction costs a branch
+ * and buys back a shape nobody writes.
+ */
+const CONDITIONAL_CONTAINERS = new Set([
+    utils_1.AST_NODE_TYPES.IfStatement,
+    utils_1.AST_NODE_TYPES.TryStatement,
+    utils_1.AST_NODE_TYPES.SwitchStatement,
+    utils_1.AST_NODE_TYPES.SwitchCase,
+    utils_1.AST_NODE_TYPES.ForStatement,
+    utils_1.AST_NODE_TYPES.ForInStatement,
+    utils_1.AST_NODE_TYPES.ForOfStatement,
+    utils_1.AST_NODE_TYPES.WhileStatement,
+    utils_1.AST_NODE_TYPES.DoWhileStatement,
+]);
+/**
+ * Whether the pattern binds anything below its own root. Only the root gets the
+ * synthesized `?? {}` rescue; a nested pattern is re-emitted verbatim because a
+ * synthesized `= {}` under it would be checked against every binding beneath it
+ * (see formatPropertyText). So a nested pattern dereferences an intermediate
+ * that nothing in the hoisted text guards.
+ */
+function patternBindsBeneathRoot(pattern) {
+    const stack = [...pattern.properties];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        if (current.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+            current.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+            return true;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Property) {
+            stack.push(current.value);
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.RestElement) {
+            stack.push(current.argument);
+            continue;
+        }
+        // A default's right-hand side is an expression, never a binding site, so
+        // only the left of an assignment pattern can hide a further pattern.
+        if (current.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+            stack.push(current.left);
+        }
+    }
+    return false;
+}
+function containsTerminatingStatement(node, visitorKeys) {
+    const stack = [node];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        // A `return` belonging to a nested function exits that function, not the
+        // block the declaration sits in, so it guards nothing here.
+        if (current !== node && isAnyFunctionLikeNode(current)) {
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement ||
+            current.type === utils_1.AST_NODE_TYPES.ThrowStatement ||
+            current.type === utils_1.AST_NODE_TYPES.BreakStatement ||
+            current.type === utils_1.AST_NODE_TYPES.ContinueStatement) {
+            return true;
+        }
+        const keys = visitorKeys[current.type] ?? [];
+        for (const key of keys) {
+            const value = current[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (child && typeof child === 'object') {
+                        stack.push(child);
+                    }
+                }
+            }
+            else if (value && typeof value === 'object') {
+                stack.push(value);
+            }
+        }
+    }
+    return false;
+}
+function isEarlyExitGuard(statement, visitorKeys) {
+    return (statement.type === utils_1.AST_NODE_TYPES.IfStatement &&
+        containsTerminatingStatement(statement, visitorKeys));
+}
+/**
+ * Whether some conditional between the declaration and the callback body decides
+ * that the declaration runs at all — either a container that can skip it, or an
+ * earlier sibling that can leave the block before reaching it.
+ *
+ * Only the span up to the callback matters: the hoist lands immediately before
+ * the statement holding the hook call, so it keeps every conditional wrapping
+ * the hook itself and escapes exactly the ones inside the callback.
+ */
+function isConditionallyReached(node, callback, visitorKeys) {
+    let current = node;
+    while (current !== callback.body) {
+        const parent = current.parent;
+        if (!parent)
+            return false;
+        if (CONDITIONAL_CONTAINERS.has(parent.type)) {
+            return true;
+        }
+        if (parent.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+            const index = parent.body.indexOf(current);
+            if (index > 0 &&
+                parent.body
+                    .slice(0, index)
+                    .some((statement) => isEarlyExitGuard(statement, visitorKeys))) {
+                return true;
+            }
+        }
+        current = parent;
+    }
+    return false;
+}
+/**
+ * A nested destructure whose execution a guard controls stays put, whatever the
+ * guard tests. `hasPriorConditionalGuard` and `isTypeNarrowingContext` recognise
+ * only a guard naming the destructured object, which misses the ubiquitous
+ * `if (ready)` / `if (!isLoaded) return;` / `try` spellings that license the
+ * dereference without mentioning it. Hoisting past one of those evaluates the
+ * nested pattern on every render, where `?? {}` covers the root and leaves the
+ * intermediate to throw.
+ *
+ * The flat case keeps hoisting: there the `?? {}` rescue is the whole pattern.
+ */
+function isGuardedNestedDestructure(declaration, pattern, callback, visitorKeys) {
+    return (patternBindsBeneathRoot(pattern) &&
+        isConditionallyReached(declaration, callback, visitorKeys));
+}
 function isIdentifierReference(node) {
     const parent = node.parent;
     if (!parent)
@@ -747,7 +881,8 @@ function buildDestructuringGroups(callback, depTextSet, visitorKeys, sourceCode)
                         continue;
                     const baseName = getBaseIdentifier(declarator.init);
                     if (hasPriorConditionalGuard(current, baseName, visitorKeys) ||
-                        isTypeNarrowingContext(current, baseName, visitorKeys)) {
+                        isTypeNarrowingContext(current, baseName, visitorKeys) ||
+                        isGuardedNestedDestructure(current, declarator.id, callback, visitorKeys)) {
                         continue;
                     }
                     const existingGroup = groups.get(depKey);

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

@@ -126,6 +126,96 @@ function findInsertionPoint(node) {
     }
     return null;
 }
+/**
+ * Whether an optional link sits at or below `expr` on its member/call spine,
+ * making everything further right in the chain unreachable when that link is
+ * nullish. `a?.b.run(x)` short-circuits at `a?.b`, so the optional flag the
+ * check needs is not the outer call's own.
+ */
+function hasOptionalLink(expr) {
+    let current = expr;
+    while (current) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                if (current.optional)
+                    return true;
+                current = current.object;
+                break;
+            case utils_1.AST_NODE_TYPES.CallExpression:
+                if (current.optional)
+                    return true;
+                current = current.callee;
+                break;
+            case utils_1.AST_NODE_TYPES.ChainExpression:
+            case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+                current = current.expression;
+                break;
+            default:
+                return false;
+        }
+    }
+    return false;
+}
+/**
+ * Whether `child` sits in a position of `parent` that control flow may skip.
+ * Positions evaluated regardless of the branch taken — an `if` test, a `&&`
+ * left operand, a `switch` discriminant, a `do` body, an optional chain's
+ * object spine — are excluded, since hoisting above them preserves evaluation.
+ */
+function isSkippableBranch(child, parent) {
+    switch (parent.type) {
+        case utils_1.AST_NODE_TYPES.IfStatement:
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return parent.consequent === child || parent.alternate === child;
+        case utils_1.AST_NODE_TYPES.LogicalExpression:
+            return parent.right === child;
+        case utils_1.AST_NODE_TYPES.SwitchStatement:
+            return parent.discriminant !== child;
+        // A case's test and body are both reached only once the switch selects it.
+        case utils_1.AST_NODE_TYPES.SwitchCase:
+            return true;
+        // A loop body may run zero times; a `do` body always runs once, so it is
+        // not listed here.
+        case utils_1.AST_NODE_TYPES.WhileStatement:
+        case utils_1.AST_NODE_TYPES.ForStatement:
+        case utils_1.AST_NODE_TYPES.ForInStatement:
+        case utils_1.AST_NODE_TYPES.ForOfStatement:
+            return parent.body === child;
+        // Arguments and computed keys of an optional chain go unevaluated when the
+        // chain short-circuits, so they guard their subtree exactly as an `if` does.
+        case utils_1.AST_NODE_TYPES.MemberExpression:
+            return parent.object !== child && hasOptionalLink(parent);
+        case utils_1.AST_NODE_TYPES.CallExpression:
+            return parent.callee !== child && hasOptionalLink(parent);
+        default:
+            return false;
+    }
+}
+/**
+ * Whether the climb from the hook call to the insertion statement escapes a
+ * position that control flow may skip. A guard that wraps the hook without a
+ * block of its own gives the climb no in-branch statement position, so the memo
+ * lands above the guard while its dependency array `[<base>]` dereferences the
+ * guarded value on every render — turning code that does not throw into code
+ * that does. The dereference was safe only because of the surrounding
+ * narrowing, which the hoisted position no longer enjoys, so the fix is
+ * withheld and the report stands alone. A braced guard needs no bail: the
+ * insertion block is then the guarded block itself.
+ */
+function crossesConditionalGuard(node, insertion) {
+    let current = node;
+    while (current !== insertion.statement) {
+        const parent = current.parent;
+        // An insertion statement absent from the hook's ancestor chain contradicts
+        // how it was derived; decline rather than guess at the geometry.
+        if (!parent)
+            return true;
+        if (isSkippableBranch(current, parent))
+            return true;
+        current = parent;
+    }
+    return false;
+}
 /**
  * Collects the identifiers a hoisted `stableHash(<base>)` expression would
  * read: the root object of the member chain plus any computed keys. Property
@@ -496,6 +586,8 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         const insertion = findInsertionPoint(node);
                         if (!insertion)
                             return null;
+                        if (crossesConditionalGuard(node, insertion))
+                            return null;
                         for (const { member } of lengthDeps) {
                             if (!isBaseSafeToHoist(context, getBaseExpression(member), insertion)) {
                                 return null;

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

@@ -11,6 +11,16 @@ const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
  * — see `callsCorrespondingSetter`.
  */
 const EFFECT_HOOK_NAMES = new Set(['useEffect']);
+/**
+ * Hooks that do not run their callback: they hand it back as a value, so the
+ * body executes only if — and when — the consumer invokes it.
+ *
+ * why: the dependency array is evaluated on every render, while such a body may
+ * never run at all, or run only once the data it reads has arrived. A path the
+ * body dereferences is therefore not licensed to appear in the array; see
+ * `collectGuardedPaths`.
+ */
+const DEFERRED_BODY_HOOK_NAMES = new Set(['useCallback']);
 function isHookCall(node) {
     const callee = node.callee;
     return (callee.type === utils_1.AST_NODE_TYPES.Identifier && HOOK_NAMES.has(callee.name));
@@ -20,6 +30,11 @@ function isEffectHookCall(node) {
     return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
         EFFECT_HOOK_NAMES.has(callee.name));
 }
+function isDeferredBodyHookCall(node) {
+    const callee = node.callee;
+    return (callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        DEFERRED_BODY_HOOK_NAMES.has(callee.name));
+}
 /**
  * The rule whose suppression marks a dependency array as hand-maintained.
  */
@@ -236,8 +251,8 @@ function isCallCallee(node) {
         parent.callee === current);
 }
 /**
- * Renders `node`'s access path when the chain is rooted at `objectName`, or
- * null when it is rooted elsewhere or holds a link with no stable rendering.
+ * The links of `node`'s access path when the chain is rooted at `objectName`,
+ * or null when it is rooted elsewhere or holds a link with no stable rendering.
  *
  * why: guard collection asks a different question than `buildAccessPath` —
  * "which value did this condition establish something about?" rather than
@@ -245,7 +260,7 @@ function isCallCallee(node) {
  * function's narrowing policy (method carve-outs, whole-object escalation) nor
  * its side effects on the usage set.
  */
-function renderMemberPathIfRootedAt(node, objectName) {
+function memberPathSegmentsIfRootedAt(node, objectName) {
     const segments = [];
     let current = node;
     while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -284,7 +299,28 @@ function renderMemberPathIfRootedAt(node, objectName) {
         base.name !== objectName) {
         return null;
     }
-    return renderPathSegments(objectName, segments);
+    return segments;
+}
+function renderMemberPathIfRootedAt(node, objectName) {
+    const segments = memberPathSegmentsIfRootedAt(node, objectName);
+    return segments ? renderPathSegments(objectName, segments) : null;
+}
+/**
+ * How many links of `segments` a dependency array may evaluate on a render that
+ * never reaches the position the path was read in.
+ *
+ * why: the array already dereferences the dependency object, so its first link
+ * is as safe as the entry it replaces. Every further link dereferences a value
+ * whose existence only the skipped position established, unless it is spelled
+ * `?.` — an optional link short-circuits instead of throwing and so extends the
+ * prefix.
+ */
+function eagerlyReachableLength(segments) {
+    let length = 1;
+    while (length < segments.length && segments[length].optional) {
+        length += 1;
+    }
+    return length;
 }
 /**
  * Every path of `objectName` whose dereferenceability the hook body establishes
@@ -297,14 +333,23 @@ function renderMemberPathIfRootedAt(node, objectName) {
  * unconditional `TypeError`. The paths collected here mark where a path must
  * stop; see `safePrefixOf`.
  *
+ * A condition is not the only licence a body can hold. A `try`/`catch` swallows
+ * the very `TypeError` a deep dereference raises, and a body that runs later —
+ * an inner callback, the function a `useCallback` hands back — may not run at
+ * all on the render whose array is being evaluated. Neither licence travels
+ * into the array, so both stop a path exactly as a condition does.
+ *
  * The collection is deliberately over-broad — it accepts any member path
  * appearing anywhere in a condition, not only one that provably governs the
  * access. Over-collecting costs a coarser dependency (the memo recomputes more
  * often than strictly needed); under-collecting is the crash.
+ *
+ * `bodyIsDeferred` says the hook itself never runs the body it was handed.
  */
-function collectGuardedPaths(hookBody, objectName) {
+function collectGuardedPaths(hookBody, objectName, bodyIsDeferred) {
     const guarded = new Set();
     const visited = new Set();
+    const deferredVisited = new Set();
     function markConditionPaths(node) {
         if (!node)
             return;
@@ -324,6 +369,35 @@ function collectGuardedPaths(hookBody, objectName) {
         }
         forEachChildNode(node, markConditionPaths);
     }
+    /**
+     * Records where every path read inside a position the array cannot reach —
+     * a protected `try` block, a body that runs later — has to stop.
+     *
+     * Unlike a condition, such a position licenses the whole dereference chain
+     * rather than one link of it, so the stopping point is derived from the path
+     * itself: everything the array can evaluate on its own is kept, and the first
+     * link that would have to trust the skipped code ends it.
+     */
+    function markDeferredPaths(node) {
+        if (!node || deferredVisited.has(node))
+            return;
+        deferredVisited.add(node);
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            const segments = memberPathSegmentsIfRootedAt(node, objectName);
+            if (segments) {
+                const reachable = eagerlyReachableLength(segments);
+                if (reachable < segments.length) {
+                    guarded.add(renderPathSegments(objectName, segments.slice(0, reachable)));
+                }
+                // A computed key can still hold a read of its own.
+                if (node.computed) {
+                    markDeferredPaths(node.property);
+                }
+                return;
+            }
+        }
+        forEachChildNode(node, markDeferredPaths);
+    }
     function walk(node) {
         if (!node || visited.has(node))
             return;
@@ -367,8 +441,33 @@ function collectGuardedPaths(hookBody, objectName) {
                 markConditionPaths(asserted);
             }
         }
+        else if (node.type === utils_1.AST_NODE_TYPES.TryStatement) {
+            // A `catch` is a licence to dereference: the author writes the deep
+            // access knowing the TypeError it can raise is swallowed. The array
+            // evaluates the same access outside the `try`, where the throw is
+            // uncaught, so the path stops before the link the `catch` covers.
+            //
+            // The handler is what makes the difference: a `try`/`finally` with no
+            // handler re-raises, so its block reads like ordinary code. The handler's
+            // own body is deferred instead — it runs only if something threw.
+            if (node.handler) {
+                markDeferredPaths(node.block);
+                markDeferredPaths(node.handler.body);
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+            // An inner callback runs on someone else's schedule — an event, a
+            // resolved promise, an iteration over an array that may be empty — so a
+            // path it reads says nothing about the render evaluating the array.
+            markDeferredPaths(node.body);
+        }
         forEachChildNode(node, walk);
     }
+    if (bodyIsDeferred) {
+        markDeferredPaths(hookBody);
+    }
     walk(hookBody);
     return guarded;
 }
@@ -421,14 +520,14 @@ function callsCorrespondingSetter(hookBody, dependencyName) {
     }
     return visit(hookBody);
 }
-function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
+function getObjectUsagesInHook(hookBody, objectName, typeInfo, bodyIsDeferred = false) {
     const usages = new Map(); // Track usage and its position
     // why: derived dependency paths (first-optional intermediate, array base)
     // must be re-rendered from structured links — string surgery on the
     // rendered path cannot place `?.` markers correctly.
     const pathSegments = new Map();
     const visited = new Set();
-    const guardedPaths = collectGuardedPaths(hookBody, objectName);
+    const guardedPaths = collectGuardedPaths(hookBody, objectName, bodyIsDeferred);
     let needsEntireObject = false;
     let isUsed = false;
     /**
@@ -1060,6 +1159,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                 }
                 const callbackBody = callbackArg.body;
                 const isEffect = isEffectHookCall(node);
+                const bodyIsDeferred = isDeferredBodyHookCall(node);
                 const manuallyManagedDeps = hasManuallyManagedDeps(node);
                 // Check each dependency in the array
                 depsArg.elements.forEach((element) => {
@@ -1077,7 +1177,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                             }
                         }
                         // For testing without TypeScript services, we'll assume all identifiers are objects
-                        const result = getObjectUsagesInHook(callbackBody, objectName, dependencyTypeInfo);
+                        const result = getObjectUsagesInHook(callbackBody, objectName, dependencyTypeInfo, bodyIsDeferred);
                         // If the object is not used at all, suggest removing it
                         if (result.notUsed) {
                             // why: deleting an entry from an array the author maintains by

package/lib/rules/parallelize-async-operations.js

@@ -379,6 +379,31 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
          * from that instance (`super.users` versus `this.posts`) stay distinct.
          */
         const INSTANCE_RECEIVER_KEY = 'this';
+        /**
+         * Strips the wrappers that punctuate an expression without changing which
+         * value it denotes, so one path is recognized however it is spelled
+         * (`a.b`, `a?.b`, `a!.b`, `(a as T).b`).
+         */
+        function unwrapExpression(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                current = current.expression;
+            }
+            return current;
+        }
+        /**
+         * Walks a member chain down to the expression it is rooted at: the binding,
+         * the instance, or whatever else the chain starts from.
+         */
+        function getPathRoot(node) {
+            let root = unwrapExpression(node);
+            while (root.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                root = unwrapExpression(root.object);
+            }
+            return root;
+        }
         /**
          * Builds a stable textual key for the object a method is invoked on, so two
          * awaits can be compared for "same receiver" by string equality.
@@ -548,6 +573,104 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             visit(node);
             return keys;
         }
+        /**
+         * Collects the member paths an expression DEREFERENCES: the object of a
+         * member access that is itself a member access, keyed the same way a
+         * receiver is.
+         *
+         * Depth is what makes the path a REQUIREMENT rather than a mere read.
+         * Evaluating `store.data.id` demands that `store.data` already hold an
+         * object, and throws when it does not; evaluating `store.data` demands
+         * nothing, since an unfilled slot yields `undefined` and passing `undefined`
+         * onward is silent. Only the former can turn the Promise.all rewrite into a
+         * crash, so only the former mints a key here.
+         *
+         * The traversal stops at function boundaries, the opposite of
+         * getInstancePathKeys: the hazard is eager evaluation at array-literal
+         * construction, and a path inside a callback handed to the operation is
+         * dereferenced when that callback runs, which the rewrite does not move.
+         *
+         * The root node travels with the key because the two questions the barrier
+         * asks of a path -- which slot it names, and where its root is bound -- are
+         * answered by different things.
+         */
+        function getDereferencedPaths(node) {
+            const paths = [];
+            const visit = (current) => {
+                if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const object = unwrapExpression(current.object);
+                    if (object.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const key = getReceiverKey(object);
+                        if (key !== null) {
+                            paths.push({ key, root: getPathRoot(object) });
+                        }
+                    }
+                }
+                if (FUNCTION_BOUNDARY_TYPES.has(current.type)) {
+                    return;
+                }
+                for (const key in current) {
+                    if (key === 'parent' || key === 'range' || key === 'loc')
+                        continue;
+                    const child = current[key];
+                    if (!child || typeof child !== 'object')
+                        continue;
+                    if (Array.isArray(child)) {
+                        for (const item of child) {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                visit(item);
+                            }
+                        }
+                    }
+                    else if ('type' in child) {
+                        visit(child);
+                    }
+                }
+            };
+            visit(node);
+            return paths;
+        }
+        /**
+         * Reports whether a path is rooted at state an opaque call could reach
+         * without ever being handed it: a module-scope binding (a module-level
+         * `const`, or an import), or a name that resolves nowhere and is therefore
+         * an implicit global.
+         *
+         * A function-local root fails the test. A parameter or a local `const` is
+         * not visible to a callee that receives neither, so a bare-identifier call
+         * cannot rebind it, and reading a slot beneath it after that call is not the
+         * hazard this barrier answers.
+         *
+         * The instance fails it too: `this` names an object a free function was not
+         * given, so an instance path can only be written through code the run
+         * itself shows -- which the closure-write barrier already reads.
+         */
+        function isAmbientlyReachableRoot(path, root, declaredNames) {
+            if (root.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            if (isInstancePathKey(path) || declaredNames.has(root.name)) {
+                return false;
+            }
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, root), root.name);
+            if (!variable) {
+                return true;
+            }
+            return (variable.scope.type === utils_1.TSESLint.Scope.ScopeType.module ||
+                variable.scope.type === utils_1.TSESLint.Scope.ScopeType.global);
+        }
+        /**
+         * Reports whether an awaited expression is a call through a bare identifier
+         * (`hydrate()`, `initAnalytics()`), the one callee shape that names no
+         * receiver at all. Such a call's effects are reachable only through the
+         * module scope it closes over, so nothing in the run describes what it
+         * touches. Handles optional-call ChainExpressions.
+         */
+        function hasBareIdentifierCallee(awaitExpr) {
+            const argument = unwrapExpression(awaitExpr.argument);
+            return (argument.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                unwrapExpression(argument.callee).type === utils_1.AST_NODE_TYPES.Identifier);
+        }
         /**
          * Extracts the receiver key of an awaited *named-method* call: the key of
          * the `object` of a `MemberExpression` callee, when the accessed member is
@@ -584,6 +707,105 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             }
             return getReceiverKey(callee.object);
         }
+        /**
+         * Finds the function a class declares for a member name, searching the
+         * class body that encloses a node. Both spellings of a method-valued member
+         * qualify: a `MethodDefinition` and a `PropertyDefinition` initialized with
+         * a function.
+         *
+         * The NEAREST enclosing class body is the one searched. A method reached
+         * through `super` resolves against a base class, and an inner class shadows
+         * an outer one, so the answer can name a function other than the one that
+         * actually runs -- but the caller only ever ADDS the resolved body's writes
+         * to the writes it already sees, so a wrong answer can only introduce a
+         * barrier, the direction this rule's trade-off prefers.
+         */
+        function findClassMethodFunction(node, memberName) {
+            let current = node;
+            while (current && current.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+                current = current.parent;
+            }
+            if (!current) {
+                return null;
+            }
+            for (const member of current.body) {
+                if (member.type !== utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    member.type !== utils_1.AST_NODE_TYPES.PropertyDefinition) {
+                    continue;
+                }
+                if (member.computed) {
+                    continue;
+                }
+                const key = member.key;
+                const name = key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier
+                    ? `#${key.name}`
+                    : key.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? key.name
+                        : null;
+                if (name !== memberName) {
+                    continue;
+                }
+                const value = member.value;
+                if (value && FUNCTION_BOUNDARY_TYPES.has(value.type)) {
+                    return value;
+                }
+            }
+            return null;
+        }
+        /**
+         * Resolves an awaited call to the function this file DECLARES for its
+         * callee: a hoisted `function` declaration, a binding initialized with a
+         * function, or a method of the enclosing class reached through
+         * `this`/`super`.
+         *
+         * The body is where an operation's ordering constraint usually lives.
+         * `await hydrate()` discards its result and mentions nothing it touches, so
+         * every barrier keyed on the run's own text reads it as independent, while
+         * the body assigns the very state the next await dereferences. Reading the
+         * body turns that guess into a fact wherever the file supplies one.
+         *
+         * Only one level is followed, so a write reached through a helper's own
+         * helper stays invisible. A callee that resolves nowhere -- an import, a
+         * parameter, a method on some other object -- yields null and leaves the
+         * syntactic barriers to answer for it.
+         */
+        function resolveCalleeFunction(awaitExpr) {
+            const argument = unwrapExpression(awaitExpr.argument);
+            if (argument.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return null;
+            }
+            const callee = unwrapExpression(argument.callee);
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, callee), callee.name);
+                if (!variable) {
+                    return null;
+                }
+                for (const definition of variable.defs) {
+                    const declaration = definition.node;
+                    if (declaration.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                        return declaration;
+                    }
+                    if (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        declaration.init &&
+                        FUNCTION_BOUNDARY_TYPES.has(declaration.init.type)) {
+                        return declaration.init;
+                    }
+                }
+                return null;
+            }
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return null;
+            }
+            const object = unwrapExpression(callee.object);
+            if (object.type !== utils_1.AST_NODE_TYPES.ThisExpression &&
+                object.type !== utils_1.AST_NODE_TYPES.Super) {
+                return null;
+            }
+            const memberName = getMemberSegment(callee);
+            return memberName === null
+                ? null
+                : findClassMethodFunction(awaitExpr, memberName);
+        }
         /**
          * Matches the `Promise` combinators that take an array of promises and
          * return a single promise standing in for the whole group. Awaiting one of
@@ -1196,11 +1418,32 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             // a write to `this.alpha` leaves a later `this.beta` parallelizable while
             // a write to `this.state` still blocks a later `this.state.mutator`.
             // (#1924)
+            //
+            // A write inside the awaited call's own BODY reaches the enclosing scope
+            // exactly as a write inside a callback does -- `await hydrate()`, where
+            // `hydrate` assigns `store.state`, publishes that slot by the time it
+            // settles. The body is not part of the awaited expression, so the
+            // traversal above cannot see it; wherever the file declares the callee,
+            // its writes are read from there and joined to the ones spelled out in
+            // the run. (#1989)
             const assignedState = awaitNodes.map((node) => {
                 const awaitExpr = getAwaitExpression(node);
-                return awaitExpr
-                    ? getAssignedState(awaitExpr.argument)
-                    : { names: new Set(), instancePaths: new Set() };
+                if (!awaitExpr) {
+                    return { names: new Set(), instancePaths: new Set() };
+                }
+                const written = getAssignedState(awaitExpr.argument);
+                const calleeFunction = resolveCalleeFunction(awaitExpr);
+                if (!calleeFunction) {
+                    return written;
+                }
+                const calleeWritten = getAssignedState(calleeFunction);
+                return {
+                    names: new Set([...written.names, ...calleeWritten.names]),
+                    instancePaths: new Set([
+                        ...written.instancePaths,
+                        ...calleeWritten.instancePaths,
+                    ]),
+                };
             });
             const readInstancePaths = awaitNodes.map((node) => {
                 const awaitExpr = getAwaitExpression(node);
@@ -1249,6 +1492,75 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     return true;
                 }
             }
+            // 12. Deferred-dereference barrier. A statement AFTER an await occupies a
+            // deferred position: it is evaluated only once the preceding promise
+            // settles. The rewrite splices its awaited operand into a `Promise.all`
+            // ARRAY LITERAL, whose elements evaluate eagerly at construction. Any slot
+            // the later operand must dereference is therefore read BEFORE the earlier
+            // operation runs, so a slot that operation installs is read while still
+            // `undefined` and the element throws a TypeError -- code that returned a
+            // value before the fix crashes after it. The two awaits are genuinely
+            // ordered, so the run is not a latency mistake and the rule declines to
+            // report it rather than merely declining the fix. (#1989)
+            //
+            // The write itself is invisible: it happens inside the awaited call's own
+            // BODY, so no value flows out of the await, no variable is declared, and
+            // no assignment appears anywhere the closure-write barrier looks. What the
+            // run does show is REACH -- whether the earlier operation could have
+            // installed the slot at all -- and only a discarded-result await qualifies
+            // as the writer, since a captured result is a value dependency the
+            // identifier comparison already sees.
+            //
+            // Reach comes in two shapes, and only these two, so that sibling slots
+            // under a shared namespace (`api.users.getAll()` then
+            // `api.posts.getRecent()`) stay parallelizable:
+            //
+            //   (a) The earlier call is invoked ON a receiver that CONTAINS the slot
+            //       (`this.connect()` then `this.client.send()`, `store.load()` then
+            //       `send(store.data.id)`). A method can fill any slot beneath its own
+            //       receiver, which is what makes such a pair ordered. This widens the
+            //       shared-receiver barrier from equality to containment: barrier 7
+            //       compares two receivers, whereas here the earlier receiver is
+            //       compared against a path the later operand merely reads.
+            //
+            //   (b) The earlier call goes through a bare identifier (`hydrate()`,
+            //       `initAnalytics()`) and the slot hangs off module-scope state. Such
+            //       a call names no receiver, so the run says nothing about what it
+            //       touches, while module-scope state is reachable from inside it
+            //       without ever being passed in. Function-local roots and instance
+            //       paths are excluded: a free function handed neither cannot rebind
+            //       them, so writes that reach them are visible in the run and belong
+            //       to the closure-write barrier.
+            const dereferencedPaths = awaitNodes.map((node) => {
+                const awaitExpr = getAwaitExpression(node);
+                return awaitExpr ? getDereferencedPaths(awaitExpr.argument) : [];
+            });
+            for (let i = 1; i < awaitNodes.length; i++) {
+                const paths = dereferencedPaths[i];
+                if (paths.length === 0)
+                    continue;
+                for (let j = 0; j < i; j++) {
+                    if (awaitNodes[j].type !== utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                        continue;
+                    }
+                    const priorExpr = getAwaitExpression(awaitNodes[j]);
+                    if (!priorExpr)
+                        continue;
+                    const priorReceiver = receiverKeys[j];
+                    for (const path of paths) {
+                        if (priorReceiver !== null &&
+                            (path.key === priorReceiver ||
+                                path.key.startsWith(`${priorReceiver}.`))) {
+                            return true;
+                        }
+                        if (priorReceiver === null &&
+                            hasBareIdentifierCallee(priorExpr) &&
+                            isAmbientlyReachableRoot(path.key, path.root, variableNames)) {
+                            return true;
+                        }
+                    }
+                }
+            }
             return false;
         }
         /**

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -823,6 +823,68 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
             return values.some((value) => referencesThis(value) || referencesPrivateName(value));
         }
+        /**
+         * Whether stepping from `child` up to `parent` crosses a boundary that
+         * decides WHETHER — or how many times — the child is evaluated, or that
+         * owns bindings the child may read.
+         *
+         * The question is about the child's POSITION, not the parent's type alone:
+         * an `if` test, a `for` init and a `for…of` right-hand side are evaluated
+         * exactly once, before control reaches the construct they head, so text
+         * lifted out of them runs precisely when it used to. A while/do-while test
+         * is re-evaluated per iteration, so it is a boundary like the bodies are.
+         */
+        function crossingGuardsEvaluation(child, parent) {
+            switch (parent.type) {
+                case utils_1.AST_NODE_TYPES.IfStatement:
+                    return parent.test !== child;
+                case utils_1.AST_NODE_TYPES.WhileStatement:
+                case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                    return true;
+                case utils_1.AST_NODE_TYPES.ForStatement:
+                    return parent.init !== child;
+                case utils_1.AST_NODE_TYPES.ForInStatement:
+                case utils_1.AST_NODE_TYPES.ForOfStatement:
+                    return parent.right !== child;
+                case utils_1.AST_NODE_TYPES.LogicalExpression:
+                    // `&&`/`||`/`??` evaluate the right operand only for some values of
+                    // the left; the left operand always runs.
+                    return parent.right === child;
+                case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                    return parent.test !== child;
+                default:
+                    return false;
+            }
+        }
+        /**
+         * Whether the ternary form's hoist would carry the branch values across a
+         * guard that decides whether they are evaluated, or out of a scope that
+         * owns bindings they read.
+         *
+         * The hoist walk treats a braceless body as transparent — it stops only at
+         * a `BlockStatement`/`Program`/`SwitchCase` — so `if (box) return kind ===
+         * 'a' ? box.a.v : box.b.v;` lands the `Record` ABOVE the guard and
+         * dereferences both values with the narrowing left behind (#1990). Braces
+         * are what make the hoist safe: with them the walk stops inside the guarded
+         * block, where the values are still narrowed and every loop binding is
+         * still in scope, so the boundary test also cures the scope violation that
+         * hoisting out of `for (const r of rows)` produces (TS2304).
+         *
+         * Nothing else sees this: the branch values are ordinary member reads, so
+         * `EAGER_UNSAFE_NODES` passes them, and `isNarrowingExempt` inspects only
+         * narrowing by the discriminant's own root, never narrowing applied by a
+         * surrounding statement.
+         */
+        function hoistCrossesGuard(node) {
+            let child = node;
+            while (child.parent && !CONTAINER_TYPES.has(child.parent.type)) {
+                if (crossingGuardsEvaluation(child, child.parent)) {
+                    return true;
+                }
+                child = child.parent;
+            }
+            return false;
+        }
         // ---- Name derivation ----------------------------------------------------
         function toUpperSnake(name) {
             return name
@@ -1075,6 +1137,9 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (flags.hoistEscapesClass) {
                 return 'the Record would hoist outside the class body, where the branch values’ `this`/`#private` reads do not resolve; extract it manually inside the class';
             }
+            if (flags.hoistCrossesGuard) {
+                return 'the Record would hoist above the guard or loop that decides whether the branch values are evaluated, dropping their narrowing and any binding the guard scopes; add braces around the branch — or lift the guarded expression into its own statement — then convert';
+            }
             if (!flags.inStatementList) {
                 return 'the dispatch is the whole body of a braceless branch, where a declaration is not allowed; add braces around it, then convert';
             }
@@ -1090,6 +1155,9 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             const { entries, contributingValues, dText, form, assignTargetText, fullCoverage, hasNullish, canPlaceFix, commentBlocked, } = analysis;
             const eagerSafe = contributingValues.every((expr) => !containsEagerUnsafe(expr));
             const hoistEscapesClass = form === 'expr' && hoistLeavesClassBody(node, contributingValues);
+            // Only the ternary hoists; every other form is replaced where it stands,
+            // so no guard can be crossed.
+            const crossesGuard = form === 'expr' && hoistCrossesGuard(node);
             // Every non-ternary form replaces the construct with a declaration plus a
             // statement, which needs a statement LIST to land in. As the sole body of
             // a braceless `if`/`else`/loop the construct sits where exactly one
@@ -1106,6 +1174,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 eagerSafe &&
                 canPlaceFix &&
                 !hoistEscapesClass &&
+                !crossesGuard &&
                 inStatementList &&
                 !commentBlocked) {
                 derivation = deriveLookupName(discriminantOf(node), fixScope);
@@ -1121,6 +1190,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                             eagerSafe,
                             canPlaceFix,
                             hoistEscapesClass,
+                            hoistCrossesGuard: crossesGuard,
                             inStatementList,
                             commentSafe: !commentBlocked,
                             derivation,

package/lib/utils/ASTHelpers.d.ts

@@ -49,6 +49,17 @@ export declare class ASTHelpers {
      * happens to share a member's name is not a reference to that member.
      */
     static classMethodDependenciesOf(node: TSESTree.Node | null, graph: Graph, className: string): string[];
+    /**
+     * Every class member a node reaches through `this.<member>` (or
+     * `<ClassName>.<member>`), fields included and unfiltered by any graph.
+     *
+     * Whatever a member's body reads, it reads as soon as that body runs, so a
+     * caller deciding whether an invocation is order-sensitive needs the field
+     * reads that `classMethodDependenciesOf` drops. A read nested in a callback
+     * counts: `arr.map((x) => this.field)` runs the callback before the
+     * enclosing body returns.
+     */
+    static classMemberNamesReferenced(node: TSESTree.Node | null, className: string): string[];
     /**
      * Collects the class members a property initializer reads while that
      * initializer runs.

package/lib/utils/ASTHelpers.js

@@ -308,15 +308,26 @@ class ASTHelpers {
      * happens to share a member's name is not a reference to that member.
      */
     static classMethodDependenciesOf(node, graph, className) {
-        const dependencies = [];
-        this.collectClassMemberReferences(node, className, true, dependencies);
-        return [
-            ...new Set(dependencies.filter((dep) => {
-                // Only include dependencies that exist exactly in the graph
-                // This prevents substring matches (e.g., 'nextMatches' vs 'nextMatchesWithResults')
-                return (graph?.[dep] !== undefined && graph?.[dep]?.type !== 'property');
-            })),
-        ];
+        return this.classMemberNamesReferenced(node, className).filter((dep) => {
+            // Only include dependencies that exist exactly in the graph
+            // This prevents substring matches (e.g., 'nextMatches' vs 'nextMatchesWithResults')
+            return graph?.[dep] !== undefined && graph?.[dep]?.type !== 'property';
+        });
+    }
+    /**
+     * Every class member a node reaches through `this.<member>` (or
+     * `<ClassName>.<member>`), fields included and unfiltered by any graph.
+     *
+     * Whatever a member's body reads, it reads as soon as that body runs, so a
+     * caller deciding whether an invocation is order-sensitive needs the field
+     * reads that `classMethodDependenciesOf` drops. A read nested in a callback
+     * counts: `arr.map((x) => this.field)` runs the callback before the
+     * enclosing body returns.
+     */
+    static classMemberNamesReferenced(node, className) {
+        const references = [];
+        this.collectClassMemberReferences(node, className, true, references);
+        return [...new Set(references)];
     }
     /**
      * Collects the class members a property initializer reads while that

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,58 @@
 [
+  {
+    "version": "1.20.148",
+    "date": "2026-08-13T13:06:17.038Z",
+    "rules": [
+      {
+        "name": "class-methods-read-top-to-bottom",
+        "changeType": "fix",
+        "issues": [
+          1988
+        ],
+        "summary": "follow eager initializer reads through invoked members (closes #1988)"
+      },
+      {
+        "name": "enforce-early-destructuring",
+        "changeType": "fix",
+        "issues": [
+          1993
+        ],
+        "summary": "keep a guarded nested destructure in place (closes #1993)"
+      },
+      {
+        "name": "no-array-length-in-deps",
+        "changeType": "fix",
+        "issues": [
+          1992
+        ],
+        "summary": "withhold the hoist out of a skippable branch (closes #1992)"
+      },
+      {
+        "name": "no-entire-object-hook-deps",
+        "changeType": "fix",
+        "issues": [
+          1991
+        ],
+        "summary": "stop a dep path at a try or deferred body (closes #1991)"
+      },
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1989
+        ],
+        "summary": "decline ordered awaits whose later operand dereferences an installed slot (closes #1989)"
+      },
+      {
+        "name": "prefer-map-over-conditional-dispatch",
+        "changeType": "fix",
+        "issues": [
+          1990
+        ],
+        "summary": "decline the hoist across a guard (closes #1990)"
+      }
+    ]
+  },
   {
     "version": "1.20.147",
     "date": "2026-08-13T06:24:35.769Z",