@blumintinc/eslint-plugin-blumint 1.20.145 → 1.20.147

package/lib/index.js

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

package/lib/rules/enforce-memoize-async.js

@@ -196,6 +196,246 @@ function declaresFunctionParameter(params) {
     }
     return parameterAnnotation(params[0])?.type === utils_1.AST_NODE_TYPES.TSFunctionType;
 }
+/**
+ * A database transaction handle is valid only for the attempt that created it,
+ * and a transaction body is re-run whenever the driver retries — Firestore
+ * retries an attempt whose reads a concurrent write invalidated. A memoized
+ * body hands the retry the first attempt's cached promise, so the retry queues
+ * no writes on its own handle, commits empty, and the caller reads the first
+ * attempt's return value and reports success. Memoizing the method that OWNS
+ * the transaction is the same defect one level up: the whole transaction, writes
+ * included, then runs once per instance.
+ */
+const TRANSACTION_TYPE_NAME = 'Transaction';
+const RUN_TRANSACTION_NAME = 'runTransaction';
+/**
+ * Keys that hold source positions or the tree's only back-edge rather than
+ * child nodes; `parent` would make a subtree walk non-terminating.
+ */
+const NON_TRAVERSABLE_KEYS = new Set(['parent', 'range', 'loc', 'type']);
+/** Every node of `root`'s subtree, `root` included. */
+function* subtreeOf(root) {
+    yield root;
+    for (const [key, value] of Object.entries(root)) {
+        if (NON_TRAVERSABLE_KEYS.has(key)) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const element of value) {
+                if (ASTHelpers_1.ASTHelpers.isNode(element)) {
+                    yield* subtreeOf(element);
+                }
+            }
+        }
+        else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+            yield* subtreeOf(value);
+        }
+    }
+}
+/** The name a call invokes, for `f()` and for `o.f()` alike. */
+function calleeName(node) {
+    const callee = withoutChain(node.callee);
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name;
+    }
+    return undefined;
+}
+/**
+ * Whether the node is a `runTransaction(…)` call, under any receiver:
+ * `db.runTransaction`, `firestore.runTransaction` and a bare imported
+ * `runTransaction` all open a retryable transaction.
+ */
+function isRunTransactionCall(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        calleeName(node) === RUN_TRANSACTION_NAME);
+}
+/** Whether the method opens a transaction anywhere in its own body. */
+function ownsTransaction(fn) {
+    for (const node of subtreeOf(fn)) {
+        if (isRunTransactionCall(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a type name denotes the transaction handle. The rightmost segment is
+ * the type's own name, so the qualified spellings — `FirebaseFirestore.
+ * Transaction`, `admin.firestore.Transaction` — answer alongside the bare one;
+ * a locally aliased import (`import { Transaction as Txn }`) answers through
+ * the alias set the file's imports define.
+ */
+function namesTransaction(typeName, aliases) {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return (typeName.name === TRANSACTION_TYPE_NAME || aliases.has(typeName.name));
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return typeName.right.name === TRANSACTION_TYPE_NAME;
+    }
+    return false;
+}
+/**
+ * Whether a declared type hands the method a transaction handle: written
+ * directly, as one arm of a union or intersection, or as a property of an
+ * object type — the shape a destructured `{ transaction }: { transaction:
+ * Transaction }` parameter carries.
+ *
+ * Type ARGUMENTS are deliberately not entered: `Map<string, Transaction>` or
+ * `Promise<Transaction>` describes a collection of handles or a handle yet to
+ * exist, neither of which is the attempt-scoped handle this carve-out is about.
+ */
+function declaresTransactionType(annotation, aliases) {
+    if (!annotation) {
+        return false;
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return namesTransaction(annotation.typeName, aliases);
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+        annotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        return annotation.types.some((member) => declaresTransactionType(member, aliases));
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return annotation.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+            declaresTransactionType(member.typeAnnotation?.typeAnnotation, aliases));
+    }
+    return false;
+}
+/**
+ * The type annotation a parameter declares, including the destructuring shapes
+ * `parameterAnnotation` does not reach: an object or array pattern carries its
+ * annotation on the pattern itself.
+ */
+function bindingAnnotation(param) {
+    if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+        param.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        return param.typeAnnotation?.typeAnnotation;
+    }
+    return parameterAnnotation(param);
+}
+/**
+ * Whether the method declares a parameter typed as a transaction handle.
+ *
+ * The test reads the ANNOTATION, not the parameter's name: a parameter merely
+ * named `transaction` is as likely to hold a payment or a ledger entry, and the
+ * rule's other carve-outs (void result, callback parameter) are annotation-driven
+ * for the same reason. A bare `async apply(transaction)` therefore keeps
+ * reporting — it declares nothing to honour, and under the `noImplicitAny` its
+ * consumers compile with it does not type-check anyway. Where the handle arrives
+ * through an unresolvable alias (`args: MembershipArgs`), the call-site test
+ * below is what recognises it.
+ */
+function declaresTransactionParameter(params, aliases) {
+    return params.some((param) => declaresTransactionType(bindingAnnotation(param), aliases));
+}
+/**
+ * The expression itself, with any `ChainExpression` wrapper removed. ESTree
+ * wraps a whole optional chain in that node, so `this?.body` and
+ * `this.body.bind?.(this)` reach a bare member/call test as something else
+ * entirely. Nullish spellings carry the transaction handle exactly as the plain
+ * ones do, and reading through the wrapper is what keeps the carve-out from
+ * lapsing on them — a lapse that would restore the empty-commit autofix.
+ */
+function withoutChain(node) {
+    return node.type === utils_1.AST_NODE_TYPES.ChainExpression
+        ? withoutChain(node.expression)
+        : node;
+}
+/** The own-method name a `this.foo` reference reads, if it reads one. */
+function thisMemberName(node) {
+    const expression = withoutChain(node);
+    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.computed &&
+        withoutChain(expression.object).type === utils_1.AST_NODE_TYPES.ThisExpression &&
+        expression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.property.name;
+    }
+    // `this.body.bind(this)` passes the same method, one wrapper out.
+    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        expression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.callee.computed &&
+        expression.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        expression.callee.property.name === 'bind') {
+        return thisMemberName(expression.callee.object);
+    }
+    return undefined;
+}
+/** Whether the subtree mentions the binding, under any nesting. */
+function mentionsBinding(node, name) {
+    for (const descendant of subtreeOf(node)) {
+        if (descendant.type === utils_1.AST_NODE_TYPES.Identifier &&
+            descendant.name === name) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Own methods a `runTransaction` argument hands the attempt to: the method
+ * passed as the callback itself, and every `this.method(…)` the callback body
+ * invokes with the attempt's handle among its arguments.
+ *
+ * Passing the handle on is what makes a method part of the attempt, so a
+ * helper the callback calls WITHOUT it — a config read, a lookup that takes no
+ * transaction — is untouched and keeps reporting.
+ */
+function collectTransactionParticipants(argument, participants) {
+    const passed = thisMemberName(argument);
+    if (passed) {
+        participants.add(passed);
+        return;
+    }
+    if (argument.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        argument.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return;
+    }
+    const handle = argument.params[0];
+    if (handle?.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return;
+    }
+    for (const node of subtreeOf(argument.body)) {
+        if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+            continue;
+        }
+        const method = thisMemberName(node.callee);
+        if (method &&
+            node.arguments.some((arg) => mentionsBinding(arg, handle.name))) {
+            participants.add(method);
+        }
+    }
+}
+/** Every own method the class hands a transaction handle to. */
+function transactionParticipantsOf(body) {
+    const participants = new Set();
+    for (const node of subtreeOf(body)) {
+        if (!isRunTransactionCall(node)) {
+            continue;
+        }
+        for (const argument of node.arguments) {
+            collectTransactionParticipants(argument, participants);
+        }
+    }
+    return participants;
+}
+/** The statically known name of a method, for matching call sites against it. */
+function methodName(node) {
+    if (node.computed) {
+        return undefined;
+    }
+    const { key } = node;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return undefined;
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -290,6 +530,66 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
             }
             return memoizeImportCache;
         };
+        /**
+         * Local names bound to an imported `Transaction` type, so that an aliased
+         * import (`import { Transaction as Txn } from 'firebase-admin/firestore'`)
+         * is read as the handle it is. The module is not constrained: a handle is
+         * re-exported through as many paths as a codebase has layers, and the
+         * imported NAME already carries the signal.
+         */
+        let transactionAliasCache = null;
+        const transactionAliases = () => {
+            if (!transactionAliasCache) {
+                transactionAliasCache = new Set();
+                for (const statement of context.sourceCode.ast.body) {
+                    if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                        continue;
+                    }
+                    for (const spec of statement.specifiers) {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            spec.imported.name === TRANSACTION_TYPE_NAME) {
+                            transactionAliasCache.add(spec.local.name);
+                        }
+                    }
+                }
+            }
+            return transactionAliasCache;
+        };
+        /**
+         * The class-level scan is shared by every method of the class, so it runs
+         * once per class body rather than once per candidate method.
+         */
+        const participantCache = new WeakMap();
+        const transactionParticipants = (body) => {
+            let participants = participantCache.get(body);
+            if (!participants) {
+                participants = transactionParticipantsOf(body);
+                participantCache.set(body, participants);
+            }
+            return participants;
+        };
+        /**
+         * Whether the method takes part in a database transaction attempt, either
+         * by opening one or by being handed the attempt's handle. Caching such a
+         * method is never an optimisation: a retried attempt would replay the first
+         * attempt's promise, writing nothing on its own handle while the caller
+         * reads a success it did not get.
+         */
+        const participatesInTransaction = (node, fn) => {
+            if (declaresTransactionParameter(fn.params, transactionAliases())) {
+                return true;
+            }
+            if (ownsTransaction(fn)) {
+                return true;
+            }
+            const body = node.parent;
+            if (body?.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+                return false;
+            }
+            const name = methodName(node);
+            return name !== undefined && transactionParticipants(body).has(name);
+        };
         return {
             MethodDefinition(node) {
                 // Only process async instance methods (skip static methods)
@@ -341,6 +641,17 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (declaresVoidResult(node.value.returnType)) {
                     return;
                 }
+                // A transaction handle is valid only for the attempt that created it,
+                // so a result derived from one must not outlive that attempt. Caching
+                // the body of a `runTransaction` callback — or the method that owns the
+                // call — turns the retry a concurrent write provokes into a silent
+                // no-op: the retry replays the first attempt's promise, queues nothing
+                // on its own handle, commits empty, and reports the first attempt's
+                // value as success. The fixer would apply that unattended under
+                // `--fix`, so both report and fix are withheld.
+                if (participatesInTransaction(node, node.value)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator

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

@@ -194,6 +194,184 @@ function unwrapExpression(expr) {
     }
     return current;
 }
+/** Applies `visitChild` to every AST child of `node`, skipping `parent` links. */
+function forEachChildNode(node, visitChild) {
+    for (const key in node) {
+        if (key === 'parent')
+            continue;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const child = node[key];
+        if (!child || typeof child !== 'object')
+            continue;
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    visitChild(item);
+                }
+            }
+        }
+        else if ('type' in child) {
+            visitChild(child);
+        }
+    }
+}
+/**
+ * Whether `node` is the callee of a call — `u.date.toISOString` in
+ * `u.date.toISOString()` — looking through the wrappers that can sit between
+ * the member expression and its call (`?.` chains, `!`, `as T`).
+ */
+function isCallCallee(node) {
+    let current = node;
+    let parent = node.parent;
+    while (parent &&
+        (parent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+            parent.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+            parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+        current = parent;
+        parent = parent.parent;
+    }
+    return (!!parent &&
+        parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        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.
+ *
+ * why: guard collection asks a different question than `buildAccessPath` —
+ * "which value did this condition establish something about?" rather than
+ * "which dependency should replace the object?" — so it must not apply that
+ * function's narrowing policy (method carve-outs, whole-object escalation) nor
+ * its side effects on the usage set.
+ */
+function renderMemberPathIfRootedAt(node, objectName) {
+    const segments = [];
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const memberExpr = current;
+        if (memberExpr.computed) {
+            const literalValue = memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal
+                ? memberExpr.property.value
+                : undefined;
+            if (typeof literalValue !== 'number' &&
+                typeof literalValue !== 'string') {
+                return null;
+            }
+            segments.unshift({
+                text: typeof literalValue === 'number'
+                    ? `[${literalValue}]`
+                    : `[${JSON.stringify(literalValue)}]`,
+                computed: true,
+                optional: memberExpr.optional,
+            });
+        }
+        else {
+            if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            segments.unshift({
+                text: memberExpr.property.name,
+                computed: false,
+                optional: memberExpr.optional,
+            });
+        }
+        current = unwrapExpression(memberExpr.object);
+    }
+    const base = unwrapExpression(current);
+    if (segments.length === 0 ||
+        base.type !== utils_1.AST_NODE_TYPES.Identifier ||
+        base.name !== objectName) {
+        return null;
+    }
+    return renderPathSegments(objectName, segments);
+}
+/**
+ * Every path of `objectName` whose dereferenceability the hook body establishes
+ * with a guard rather than with the plain shape of the source.
+ *
+ * why: a dependency array is an array literal, so every element is evaluated
+ * eagerly on every render — outside the `if`, the `&&`, the ternary and the
+ * `!` assertion that made the access safe inside the body. Extending a
+ * dependency path *through* such a link therefore turns guarded code into an
+ * unconditional `TypeError`. The paths collected here mark where a path must
+ * stop; see `safePrefixOf`.
+ *
+ * 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.
+ */
+function collectGuardedPaths(hookBody, objectName) {
+    const guarded = new Set();
+    const visited = new Set();
+    function markConditionPaths(node) {
+        if (!node)
+            return;
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+            const path = renderMemberPathIfRootedAt(node, objectName);
+            if (path) {
+                guarded.add(path);
+                // why: only the outermost link of the chain is what the condition
+                // established. `if (a.b.c)` dereferences `a.b` unconditionally, so it
+                // proves nothing about `a.b` and must not truncate paths there. A
+                // computed key can still hold a condition-worthy read of its own.
+                if (node.computed) {
+                    markConditionPaths(node.property);
+                }
+                return;
+            }
+        }
+        forEachChildNode(node, markConditionPaths);
+    }
+    function walk(node) {
+        if (!node || visited.has(node))
+            return;
+        visited.add(node);
+        if (node.type === utils_1.AST_NODE_TYPES.IfStatement ||
+            node.type === utils_1.AST_NODE_TYPES.ConditionalExpression ||
+            node.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+            node.type === utils_1.AST_NODE_TYPES.DoWhileStatement ||
+            node.type === utils_1.AST_NODE_TYPES.ForStatement) {
+            // Covers `if (a.b)`, `a.b ? x : y`, and the early-return form
+            // `if (!a.b) return;` — the `!` is reached by walking the test.
+            markConditionPaths(node.test);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+            // `a.b && a.b.c`, `a.b || fallback`, `a.b ?? fallback`: the left operand
+            // decides whether the right one runs at all.
+            markConditionPaths(node.left);
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.UnaryExpression) {
+            if (node.operator === '!' || node.operator === 'typeof') {
+                markConditionPaths(node.argument);
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
+            if (node.operator === 'instanceof') {
+                markConditionPaths(node.left);
+            }
+            else if (node.operator === 'in') {
+                markConditionPaths(node.right);
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+            // `a.b!.c` — the assertion is the author's guard, and it exists only in
+            // the type system. The emitted dependency has to stop at `a.b`.
+            //
+            // Unlike a condition, an assertion speaks about exactly one value, so
+            // this does NOT descend: in `load(a.b)!` the `!` covers the call's
+            // result and says nothing about `a.b`.
+            const asserted = unwrapExpression(node.expression);
+            if (asserted.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                markConditionPaths(asserted);
+            }
+        }
+        forEachChildNode(node, walk);
+    }
+    walk(hookBody);
+    return guarded;
+}
 /**
  * Whether the hook body anywhere calls the state setter that corresponds to
  * `dependencyName` (dep `count` -> `setCount(...)`).
@@ -250,8 +428,46 @@ function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
     // rendered path cannot place `?.` markers correctly.
     const pathSegments = new Map();
     const visited = new Set();
+    const guardedPaths = collectGuardedPaths(hookBody, objectName);
     let needsEntireObject = false;
     let isUsed = false;
+    /**
+     * The longest prefix of `segments` that a dependency array may evaluate
+     * unconditionally.
+     *
+     * why: the hook body reaches a deep path under guards the array cannot
+     * carry, so the deepest path the body reads is not always a legal dependency.
+     * Truncating at the first unsafe link yields a coarser dependency — the memo
+     * recomputes whenever the parent object's identity changes rather than only
+     * when the leaf does — which can only cost precision, never correctness, and
+     * still delivers the narrowing this rule exists for.
+     */
+    function safePrefixOf(segments) {
+        let limit = segments.length;
+        // A link the source reached with `?.` is one the author expects to be
+        // nullish. When the very next link is spelled *without* `?.`, the source
+        // only survives because something outside the expression established the
+        // value — a guard, a narrowing assertion, an invariant. The dependency
+        // array inherits none of it, so the path stops at the optional link.
+        // A trailing optional link (`a.b?.[0]`, `state?.[0]`) is safe as written
+        // and keeps its full rendering.
+        for (let index = 0; index < segments.length - 1; index += 1) {
+            if (segments[index].optional && !segments[index + 1].optional) {
+                limit = index + 1;
+                break;
+            }
+        }
+        // A prefix whose dereferenceability a condition established is unusable in
+        // the array for the same reason. The shortest such prefix wins, since it is
+        // the most conservative stopping point.
+        for (let index = 1; index < limit; index += 1) {
+            if (guardedPaths.has(renderPathSegments(objectName, segments.slice(0, index)))) {
+                limit = index;
+                break;
+            }
+        }
+        return segments.slice(0, limit);
+    }
     // Built-in array methods that indicate usage of the entire array
     const ARRAY_METHODS = new Set([
         'map',
@@ -314,6 +530,36 @@ function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
         // Collect all links from leaf to root
         while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             const memberExpr = current;
+            // A member called through a chain never terminates a dependency path:
+            // depend on the receiver instead.
+            //
+            // why: two reasons converge. A method reached through a chain
+            // (`u.date.toISOString`) is a prototype-shared reference — the same value
+            // for every receiver of that type — so pinning it in the array makes the
+            // hook stop invalidating and serve a stale value forever. And it is the
+            // link that dereferences the receiver, so a receiver whose safety came
+            // from a guard (`if (u.date)`, `u.date!`) throws when the array is
+            // evaluated on a render that never entered the guard.
+            //
+            // Two conditions bound this. The link must be spelled without `?.`: a
+            // fully optional chain (`userData?.date?.toISOString`) short-circuits
+            // instead of throwing, which is exactly the per-link rendering this rule
+            // already gets right. And the receiver must itself be a member path —
+            // where it is the dependency object (`userData?.getName?.()`), falling
+            // back to it would surrender the narrowing entirely, and a function held
+            // directly on a plain dependency object is per-instance state whose
+            // identity legitimately changes; `isMethodMember` decides that case with
+            // the type checker.
+            if (!memberExpr.optional && isCallCallee(memberExpr)) {
+                const receiver = unwrapExpression(memberExpr.object);
+                if (receiver.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const receiverPath = buildAccessPath(receiver);
+                    if (receiverPath) {
+                        usages.set(receiverPath, memberExpr.range?.[0] || 0);
+                    }
+                    return null;
+                }
+            }
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
                 // why: only a *literal* string/number computed key (obj[0],
@@ -613,8 +859,25 @@ function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
         }
     }
     visit(hookBody);
+    // Replace every collected path with the prefix that survives evaluation
+    // outside the hook body. Distinct reads can collapse onto one dependency
+    // (`a.b` and a truncated `a.b.c` are the same entry), so the earliest source
+    // position is kept for the ordering below.
+    const safeUsages = new Map();
+    usages.forEach((position, rawPath) => {
+        const segments = pathSegments.get(rawPath);
+        const safeSegments = segments ? safePrefixOf(segments) : undefined;
+        const safePath = safeSegments
+            ? renderPathSegments(objectName, safeSegments)
+            : rawPath;
+        if (safeSegments) {
+            pathSegments.set(safePath, safeSegments);
+        }
+        const recorded = safeUsages.get(safePath);
+        safeUsages.set(safePath, recorded === undefined ? position : Math.min(recorded, position));
+    });
     // Process paths and determine which ones to include
-    const paths = Array.from(usages.keys());
+    const paths = Array.from(safeUsages.keys());
     const finalPaths = new Set();
     paths.forEach((path) => {
         // Always include the main path
@@ -658,8 +921,8 @@ function getObjectUsagesInHook(hookBody, objectName, typeInfo) {
     });
     // Sort paths: longer/more specific paths first, then by optional chaining preference
     const sortedPaths = filteredPaths.sort((a, b) => {
-        const posA = usages.get(a) || 0;
-        const posB = usages.get(b) || 0;
+        const posA = safeUsages.get(a) || 0;
+        const posB = safeUsages.get(b) || 0;
         // For paths with the same base, put longer ones first
         const aDepth = a.split('.').length + (a.includes('[') ? 1 : 0);
         const bDepth = b.split('.').length + (b.includes('[') ? 1 : 0);