Selecting header in a parenthesized multi-line JSX declaration, or the first variable of a multi-line var a = ..., b = ...; list, inserted the log before the closing ); or between the declarators, which broke the file. A const declared inside a callback passed to an outer declaration, like useState(() => {...}) or a useSWR fetcher, got its log after the outer statement, where it is out of scope. Fix: the log is anchored to the end of the innermost declaration that actually binds the selected name.

Selecting a variable initialized by a multi-line new IntersectionObserver(...), <JwtPayload>jwt.verify(...) or obj?.method?.(...) inserted the log on the next line, inside the argument list. Fix: every call-like initializer, including new, type assertions, optional chains, yield and import(), is anchored to the end of its full declaration.

Selecting variant put the log above const {, where the variable is not initialized yet, which throws at runtime. Bindings destructured from a multi-line yield call(...) or await import(...) had the same problem. Fix: destructuring patterns are matched at any depth, including defaults, array patterns and rest elements, so the log goes after the declaration.

Selecting the object of a method call, like links in links.map(...) or user.roles in if (!user.roles.includes('admin')), inserted the log right after the call: inside JSX markup or an argument list, inside the if body, between chained calls, or after a throw where it never runs. Fix: the log is placed relative to the enclosing statement, before a condition, a throw, or a multi-line statement the call is only part of, and after the statement otherwise.

Selecting id inserted the log inside the object literal, a syntax error, or after the return, where it never runs, and it printed the bare key, which is not a variable. emit({ kind }), fetch(url, { body }) and export default { name } behaved the same. Fix: the log prints the property's value, user.id, before the enclosing statement.

Selecting ready inserted the log inside the literal and printed only ready. Keys of declared objects wrapped in as const or satisfies also lost their variable name in the logged path. Fix: the log prints the full path, such as this.state.ready or module.exports.a, after the assignment.

Selecting a parameter of a function whose body sits on its signature line, like this setter, an empty stub onBlur(event) {}, or const onSubmit = (event) => {};, put the log in the class body, before the function, or between object properties. Fix: the body is opened onto its own lines and the log goes at its top, as it already did for empty functions.

Selecting user rewrote the selector arrow so it logged user inside its own initializer, which throws, only because the arrow reads a property named user. Object keys and nested methods triggered the same wrong rewrite. Fix: an arrow is rewritten only when it owns the selected variable, as a parameter or a real reference in its body.

Selecting action.type inserted the log above the function, where action does not exist. export default memo(Card), TypeScript import fs = require('fs') and labelled loops were misplaced in similar ways, and a value inside a single-line throw was logged after it. Fix: these are statement boundaries now: heads are logged before the statement, exports and imports after it, and throws before the throw.

Selecting err inserted the log above the try, where the error binding does not exist. Fix: catch parameters, plain or destructured, are treated like function parameters and logged at the top of the catch body.

Selecting user.role inserted the log at the end of the !user branch, so it only ran when user was missing, and then it threw. Fix: else-if conditions are logged at the top of the else-if body.

Selecting item.label put the log before the outer return, where item does not exist. Inline handlers, returned closures, effect cleanups and Promise executors had the same problem. Fix: a selection belongs to the function whose body contains it, and it is logged there.

Selecting globalThis.prisma logged it before the assignment, printing the old value. module.exports = {...} at the very start of a file did the same. Fix: every reassignment of a member, with any operator, is logged after the full statement.

Selecting connection, or any variable reassigned to a multi-line object, awaited call or ternary without const or let, logged it before the statement, printing the previous value. A plain ||= call could even put the log inside the object argument. Fix: variable reassignments, with any operator, are logged after the full statement, like declarations.