sela-core 0.1.0-alpha.1

package/dist/services/TraceBackEngine.js

@@ -0,0 +1,672 @@
+"use strict";
+// src/services/TraceBackEngine.ts
+//
+// Ticket #2 — Stage 2: The AST Trace-Back Engine.
+//
+// Given a node at (or under) a failing call-site — e.g. a token inside
+// `await targetButton.nth(3).click()` — climb the PropertyAccess / Call
+// spine to the leftmost receiver, resolve that receiver's DEFINITION, and
+// classify it:
+//
+//   • VariableDeclaration / PropertyDeclaration (POM) → mutation TARGET
+//   • Parameter / ArrowFunction / FunctionDeclaration → factory   → ABORT(hard)
+//   • TemplateExpression w/ substitution, ?? / || / ?: init       → ABORT(hard)
+//   • destructuring binding, reassigned let/var                   → ABORT(hard)
+//   • imported / unresolved symbol                                → ABORT(soft, cross-file)
+//
+// Playwright semantics handled natively: locator / getByRole / getByText /
+// getByTestId / …, frameLocator (iframes), `.parent.locator('.child')` and
+// `'.parent >> .child'` chaining (shadow DOM), action modifiers
+// (.nth/.first/.last/.filter), and awaited execution (await/parens unwrap).
+//
+// The engine is PURE and never writes. It composes with Stage 1: every
+// successful target carries an AnchorKey (computeAnchor) so the drain loop
+// can relocate it later without line numbers.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceBackEngine = void 0;
+exports.categorizeMethod = categorizeMethod;
+exports.climbToTopCall = climbToTopCall;
+exports.getLeftmostReceiver = getLeftmostReceiver;
+exports.resolveValueDeclaration = resolveValueDeclaration;
+exports.stripTrailingActions = stripTrailingActions;
+const ts_morph_1 = require("ts-morph");
+const AnchorResolver_1 = require("./AnchorResolver");
+// ═══════════════════════════════════════════════════════════════════
+// PLAYWRIGHT METHOD TAXONOMY
+// ═══════════════════════════════════════════════════════════════════
+const SELECTOR_METHODS = new Set([
+    "locator",
+    "getByRole",
+    "getByText",
+    "getByLabel",
+    "getByPlaceholder",
+    "getByTestId",
+    "getByAltText",
+    "getByTitle",
+]);
+/** Iframe / frame traversal — must be climbed through seamlessly. */
+const FRAME_METHODS = new Set(["frameLocator", "contentFrame"]);
+/** Sub-selection that does NOT change the locator's identity root. */
+const MODIFIER_METHODS = new Set([
+    "nth",
+    "first",
+    "last",
+    "filter",
+    "and",
+    "or",
+]);
+/** Terminal actions / queries — strippable trailing calls. */
+const ACTION_METHODS = new Set([
+    "click",
+    "dblclick",
+    "fill",
+    "type",
+    "pressSequentially",
+    "press",
+    "check",
+    "uncheck",
+    "setChecked",
+    "hover",
+    "focus",
+    "blur",
+    "tap",
+    "selectOption",
+    "selectText",
+    "setInputFiles",
+    "clear",
+    "dragTo",
+    "screenshot",
+    "scrollIntoViewIfNeeded",
+    "waitFor",
+    "isVisible",
+    "isHidden",
+    "isEnabled",
+    "isDisabled",
+    "isChecked",
+    "isEditable",
+    "textContent",
+    "innerText",
+    "innerHTML",
+    "inputValue",
+    "getAttribute",
+    "count",
+    "all",
+    "allInnerTexts",
+    "allTextContents",
+    "boundingBox",
+    "evaluate",
+    "evaluateHandle",
+    "elementHandle",
+    "highlight",
+    "dispatchEvent",
+]);
+/** Stable chain roots that are NOT user variables (no trace-back needed). */
+const PAGE_ROOT_NAMES = new Set([
+    "page",
+    "context",
+    "browser",
+    "playwright",
+    "request",
+    "frame",
+]);
+function categorizeMethod(name) {
+    if (FRAME_METHODS.has(name))
+        return "frame";
+    if (SELECTOR_METHODS.has(name))
+        return "selector";
+    if (MODIFIER_METHODS.has(name))
+        return "modifier";
+    if (ACTION_METHODS.has(name))
+        return "action";
+    return "unknown";
+}
+const MAX_DEPTH = 12;
+// ═══════════════════════════════════════════════════════════════════
+// ENTRY POINTS
+// ═══════════════════════════════════════════════════════════════════
+class TraceBackEngine {
+    /** Phase 0 convenience: resolve (1-based line, 0-based col) → node → trace. */
+    static traceFromPosition(sourceFile, line, column) {
+        let pos;
+        try {
+            pos = sourceFile.compilerNode.getPositionOfLineAndCharacter(line - 1, column);
+        }
+        catch {
+            return abort("hard", "DEFINITION_NOT_FOUND", `bad position ${line}:${column}`);
+        }
+        const node = sourceFile.getDescendantAtPos(pos);
+        if (!node) {
+            return abort("hard", "DEFINITION_NOT_FOUND", `no node at ${line}:${column}`);
+        }
+        return TraceBackEngine.traceFromNode(node);
+    }
+    /** Phases 1–5. */
+    static traceFromNode(start) {
+        // ── Phase 1: climb to the top-level call of the failing statement ──
+        const topCall = climbToTopCall(start);
+        if (!topCall) {
+            return abort("hard", "UNSUPPORTED", `no enclosing call expression for ${start.getKindName()}`);
+        }
+        // ── Phase 2: descend the spine → leftmost receiver + chain ──────────
+        const { leftmost, chain } = getLeftmostReceiver(topCall);
+        // Case C/D: receiver is a property access (POM `this.x` / `obj.x`).
+        if (ts_morph_1.Node.isPropertyAccessExpression(leftmost)) {
+            return tracePropertyReceiver(leftmost, chain, topCall);
+        }
+        // Case A: receiver is a page-root identifier → inline or var-initializer.
+        if (ts_morph_1.Node.isIdentifier(leftmost) && PAGE_ROOT_NAMES.has(leftmost.getText())) {
+            return traceRootedChain(leftmost.getText(), topCall, chain);
+        }
+        // Case B: receiver is a local variable → resolve + classify.
+        if (ts_morph_1.Node.isIdentifier(leftmost)) {
+            return traceVariableReceiver(leftmost, chain, 0);
+        }
+        return abort("hard", "UNSUPPORTED", `leftmost receiver is ${leftmost.getKindName()}`, leftmost);
+    }
+}
+exports.TraceBackEngine = TraceBackEngine;
+// ═══════════════════════════════════════════════════════════════════
+// PHASE 1 — climb to the statement's top call
+// ═══════════════════════════════════════════════════════════════════
+function climbToTopCall(start) {
+    let n = start;
+    let top = null;
+    let enclosingStmt;
+    while (n) {
+        if (ts_morph_1.Node.isCallExpression(n))
+            top = n;
+        if (ts_morph_1.Node.isStatement(n))
+            enclosingStmt = n;
+        const p = n.getParent();
+        if (!p)
+            break;
+        // Stop at the statement/scope boundary — we want the OUTERMOST call of
+        // this expression, not a call further up the tree.
+        if (ts_morph_1.Node.isBlock(p) || ts_morph_1.Node.isSourceFile(p))
+            break;
+        n = p;
+    }
+    if (top)
+        return top;
+    // Fallback: `start` was a SIBLING of the call, not an ancestor — e.g. the
+    // `await` keyword in `await btn.click()` (climbing never reaches the
+    // CallExpression, which is a CHILD of the AwaitExpression). Descend the
+    // enclosing statement and return its OUTERMOST call (largest end offset =
+    // the last-closing call in a chain like `btn.nth(3).click()`).
+    const scope = enclosingStmt ?? start;
+    const calls = scope.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression);
+    if (calls.length === 0)
+        return null;
+    let best = calls[0];
+    for (const c of calls) {
+        if (c.getEnd() > best.getEnd())
+            best = c;
+    }
+    return best;
+}
+// ═══════════════════════════════════════════════════════════════════
+// PHASE 2 — leftmost receiver + chain extraction
+// ═══════════════════════════════════════════════════════════════════
+function getLeftmostReceiver(topCall) {
+    const chain = [];
+    let expr = topCall;
+    // Bound the descent so a pathological tree can't loop forever.
+    for (let i = 0; i < 256; i++) {
+        expr = unwrap(expr);
+        if (ts_morph_1.Node.isCallExpression(expr)) {
+            const callee = unwrap(expr.getExpression());
+            if (ts_morph_1.Node.isPropertyAccessExpression(callee)) {
+                chain.push({
+                    name: callee.getName(),
+                    category: categorizeMethod(callee.getName()),
+                });
+                expr = callee.getExpression();
+                continue;
+            }
+            // Call on a non-property (e.g. a factory invocation getRow()) — descend.
+            expr = callee;
+            continue;
+        }
+        if (ts_morph_1.Node.isPropertyAccessExpression(expr)) {
+            // Property access NOT followed by a call at the leftmost position:
+            // `this.submitBtn` / `loginPage.submitBtn`. The base is the receiver.
+            break;
+        }
+        break;
+    }
+    chain.reverse();
+    return { leftmost: expr, chain };
+}
+// ═══════════════════════════════════════════════════════════════════
+// CASE A — chain rooted directly at page / context / …
+// ═══════════════════════════════════════════════════════════════════
+function traceRootedChain(rootReceiver, topCall, chain) {
+    const locatorChain = stripTrailingActions(topCall);
+    // Dynamic-selector guard: page.locator(`#row-${id}`) is not safely
+    // mutable at source.
+    if (containsDynamicSelectorArg(locatorChain)) {
+        return abort("hard", "DYNAMIC_SELECTOR", "selector built from a template literal with substitutions", locatorChain);
+    }
+    // If the chain is the initializer of a variable, the real target is that
+    // declaration (start happened to land inside the declaration). Otherwise
+    // it is a bare inline call-site.
+    const enclosingDecl = getEnclosingVariableDeclaration(locatorChain);
+    if (enclosingDecl &&
+        enclosingDecl.getInitializer() &&
+        isWithin(locatorChain, enclosingDecl.getInitializer())) {
+        const target = makeTarget("VariableDeclaration", enclosingDecl.getInitializer(), enclosingDecl, rootReceiver);
+        return { status: "target", target, callSiteChain: chain, dependencyChain: [target] };
+    }
+    const target = makeTarget("InlineCallSite", locatorChain, null, rootReceiver);
+    return { status: "target", target, callSiteChain: chain, dependencyChain: [] };
+}
+// ═══════════════════════════════════════════════════════════════════
+// CASE B — local variable receiver: resolve + classify (Phase 3–5)
+// ═══════════════════════════════════════════════════════════════════
+function traceVariableReceiver(idNode, chain, depth) {
+    if (depth > MAX_DEPTH) {
+        return abort("hard", "MAX_DEPTH", "alias chain exceeded max depth");
+    }
+    const name = idNode.getText();
+    const sourceFile = idNode.getSourceFile();
+    const useOffset = idNode.getStart();
+    // Phase 3: resolve the definition in lexical scope.
+    const decl = resolveValueDeclaration(idNode, name, useOffset);
+    if (!decl) {
+        // Imported / unresolved → cross-file (soft) vs truly missing.
+        if (isImported(sourceFile, name)) {
+            return abort("soft", "CROSS_FILE", `"${name}" is imported`, idNode);
+        }
+        if (findDestructuringBinding(sourceFile, name, useOffset)) {
+            return abort("hard", "DESTRUCTURED", `"${name}" comes from a destructuring binding`);
+        }
+        return abort("hard", "DEFINITION_NOT_FOUND", `"${name}" not resolved in scope`, idNode);
+    }
+    // Phase 4: classify the declaration kind.
+    if (ts_morph_1.Node.isParameterDeclaration(decl)) {
+        return abort("hard", "PARAMETER", `"${name}" is a function parameter`, decl);
+    }
+    if (ts_morph_1.Node.isFunctionDeclaration(decl)) {
+        return abort("hard", "FACTORY", `"${name}" is a function declaration`, decl);
+    }
+    if (!ts_morph_1.Node.isVariableDeclaration(decl)) {
+        return abort("hard", "UNSUPPORTED", `"${name}" resolves to ${decl.getKindName()}`, decl);
+    }
+    return classifyVariableDeclaration(decl, chain, depth);
+}
+function classifyVariableDeclaration(decl, chain, depth) {
+    const name = decl.getName();
+    const init = decl.getInitializer();
+    if (!init) {
+        // No initializer. The standard Playwright fixture pattern is
+        //   let submit;  test.beforeEach(() => { submit = page.locator('.btn'); });
+        // A SINGLE standalone assignment is the de-facto definition — resolve it.
+        // Multiple assignments = genuinely flow-sensitive → abort.
+        const assigns = findStandaloneAssignments(decl);
+        if (assigns.length === 0) {
+            return abort("hard", "UNSUPPORTED", `"${name}" has no initializer`, decl);
+        }
+        if (assigns.length > 1) {
+            return abort("hard", "REASSIGNED", `"${name}" is assigned in ${assigns.length} places`, decl);
+        }
+        return classifyInitializerExpr(assigns[0], decl, chain, depth, name, true);
+    }
+    // Has an initializer AND a later standalone assignment → reassigned.
+    if (isReassigned(decl)) {
+        return abort("hard", "REASSIGNED", `"${name}" is reassigned after init`, decl);
+    }
+    return classifyInitializerExpr(init, decl, chain, depth, name, false);
+}
+/**
+ * Classify the value expression bound to a variable (its initializer, or the
+ * RHS of its single hook-style assignment) and build the target / cascade.
+ */
+function classifyInitializerExpr(expr, decl, chain, depth, name, fromAssignment) {
+    // Factory: const f = (…) => … / function expression.
+    if (ts_morph_1.Node.isArrowFunction(expr) || ts_morph_1.Node.isFunctionExpression(expr)) {
+        return abort("hard", "FACTORY", `"${name}" is a factory function`, decl);
+    }
+    // Branchy init: cond ? a : b / a ?? b / a || b.
+    if (ts_morph_1.Node.isConditionalExpression(expr) ||
+        (ts_morph_1.Node.isBinaryExpression(expr) && isNullishOrLogical(expr))) {
+        return abort("hard", "DYNAMIC_SELECTOR", `"${name}" has a conditional / branchy initializer`, decl);
+    }
+    // Alias: const a = b → recurse on b.
+    if (ts_morph_1.Node.isIdentifier(expr)) {
+        return traceVariableReceiver(expr, chain, depth + 1);
+    }
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        if (containsDynamicSelectorArg(expr)) {
+            return abort("hard", "DYNAMIC_SELECTOR", `"${name}" selector uses a template literal with substitutions`, decl);
+        }
+        if (!isPlaywrightChain(expr)) {
+            return abort("hard", "UNSUPPORTED", `"${name}" initializer is not a Playwright locator chain`, decl);
+        }
+        const { rootReceiver, receiverVar } = analyzeChainRoot(expr);
+        // The mutation target is the value expression; the owning declaration is
+        // the `let`/`const` so the reference census keys off the variable name.
+        const target = makeTarget("VariableDeclaration", expr, decl, rootReceiver, fromAssignment ? name : undefined);
+        let dependencyChain = [target];
+        if (receiverVar) {
+            const upstream = traceVariableReceiver(receiverVar, [], depth + 1);
+            if (upstream.status === "target") {
+                dependencyChain = [...upstream.dependencyChain, target];
+                target.rootReceiver = upstream.target.rootReceiver;
+            }
+            // Upstream abort → keep THIS decl as a valid leaf target.
+        }
+        return { status: "target", target, callSiteChain: chain, dependencyChain };
+    }
+    return abort("hard", "UNSUPPORTED", `"${name}" initializer is ${expr.getKindName()}`, decl);
+}
+/** Standalone `name = …` assignments in the file (excludes the decl init). */
+function findStandaloneAssignments(decl) {
+    const name = decl.getName();
+    const sf = decl.getSourceFile();
+    const out = [];
+    for (const bin of sf.getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)) {
+        if (bin.getOperatorToken().getKind() !== ts_morph_1.SyntaxKind.EqualsToken)
+            continue;
+        const left = bin.getLeft();
+        if (ts_morph_1.Node.isIdentifier(left) && left.getText() === name) {
+            out.push(bin.getRight());
+        }
+    }
+    return out;
+}
+// ═══════════════════════════════════════════════════════════════════
+// CASE C/D — property-access receiver (POM)
+// ═══════════════════════════════════════════════════════════════════
+function tracePropertyReceiver(prop, chain, _topCall) {
+    const base = unwrap(prop.getExpression());
+    const propName = prop.getName();
+    // C: this.submitBtn → resolve same-file class member.
+    if (base.getKind() === ts_morph_1.SyntaxKind.ThisKeyword) {
+        const cls = prop.getFirstAncestorByKind(ts_morph_1.SyntaxKind.ClassDeclaration);
+        if (!cls) {
+            return abort("hard", "DEFINITION_NOT_FOUND", `this.${propName} has no enclosing class`);
+        }
+        // Property with an initializer: btn = page.locator('#go').
+        const propertyDecl = cls.getProperty(propName);
+        if (propertyDecl && ts_morph_1.Node.isPropertyDeclaration(propertyDecl)) {
+            const init = propertyDecl.getInitializer();
+            if (init && ts_morph_1.Node.isCallExpression(init)) {
+                if (containsDynamicSelectorArg(init)) {
+                    return abort("hard", "DYNAMIC_SELECTOR", `this.${propName} uses a dynamic selector`, propertyDecl);
+                }
+                if (isPlaywrightChain(init)) {
+                    const { rootReceiver } = analyzeChainRoot(init);
+                    const target = makeTarget("PropertyDeclaration", init, propertyDecl, rootReceiver);
+                    return {
+                        status: "target",
+                        target,
+                        callSiteChain: chain,
+                        dependencyChain: [target],
+                    };
+                }
+            }
+        }
+        // Constructor assignment: this.submitBtn = page.locator('#submit').
+        const assignRhs = findConstructorAssignment(cls, propName);
+        if (assignRhs && ts_morph_1.Node.isCallExpression(assignRhs)) {
+            if (containsDynamicSelectorArg(assignRhs)) {
+                return abort("hard", "DYNAMIC_SELECTOR", `this.${propName} uses a dynamic selector`, assignRhs);
+            }
+            if (isPlaywrightChain(assignRhs)) {
+                const { rootReceiver } = analyzeChainRoot(assignRhs);
+                const target = makeTarget("PropertyAssignment", assignRhs, assignRhs.getParent() ?? null, rootReceiver);
+                return {
+                    status: "target",
+                    target,
+                    callSiteChain: chain,
+                    dependencyChain: [target],
+                };
+            }
+        }
+        return abort("hard", "DEFINITION_NOT_FOUND", `this.${propName} not found as a locator on the class`);
+    }
+    // D: obj.submitBtn where obj is a local var (often `new SomeClass()`).
+    // Same-file class resolution is out of Stage-2 scope; if obj is imported
+    // or its class is imported, this is a cross-file POM (soft abort).
+    if (ts_morph_1.Node.isIdentifier(base)) {
+        return abort("soft", "CROSS_FILE", `"${base.getText()}.${propName}" is a page-object reference (cross-file resolution required)`, prop);
+    }
+    return abort("hard", "UNSUPPORTED", `property receiver base is ${base.getKindName()}`, prop);
+}
+// ═══════════════════════════════════════════════════════════════════
+// SCOPE-AWARE DEFINITION RESOLUTION
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Lexical-scope resolution of `name` as seen from `useOffset`. Walks
+ * enclosing scopes outward: parameters of enclosing functions, then
+ * variable/function declarations introduced in each enclosing block /
+ * source file. Pure compiler-API traversal — no language service.
+ */
+function resolveValueDeclaration(fromNode, name, useOffset) {
+    let cur = fromNode.getParent();
+    while (cur) {
+        if (isFunctionLike(cur)) {
+            const params = cur.getParameters?.();
+            const param = params?.find((p) => p.getName() === name);
+            if (param)
+                return param;
+        }
+        if (ts_morph_1.Node.isBlock(cur) || ts_morph_1.Node.isSourceFile(cur)) {
+            const found = scanScopeForDecl(cur, name, useOffset);
+            if (found)
+                return found;
+        }
+        cur = cur.getParent();
+    }
+    return null;
+}
+function scanScopeForDecl(scope, name, beforeOffset) {
+    // getStatements() returns the scope's direct statements (it descends the
+    // synthetic SyntaxList that getChildrenOfKind would stop at).
+    const stmts = scope.getStatements?.();
+    if (!stmts)
+        return null;
+    // Function declarations are hoisted — match regardless of position.
+    for (const stmt of stmts) {
+        if (ts_morph_1.Node.isFunctionDeclaration(stmt) && stmt.getName() === name) {
+            return stmt;
+        }
+    }
+    // Variable declarations: closest one declared before the use site.
+    let best = null;
+    let bestStart = -1;
+    for (const stmt of stmts) {
+        if (!ts_morph_1.Node.isVariableStatement(stmt))
+            continue;
+        for (const d of stmt.getDeclarations()) {
+            if (d.getName() !== name)
+                continue;
+            const s = d.getStart();
+            if (s < beforeOffset && s > bestStart) {
+                best = d;
+                bestStart = s;
+            }
+        }
+    }
+    return best;
+}
+function findDestructuringBinding(sourceFile, name, beforeOffset) {
+    for (const be of sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.BindingElement)) {
+        if (be.getName() === name && be.getStart() < beforeOffset)
+            return be;
+    }
+    return null;
+}
+function isImported(sourceFile, name) {
+    for (const imp of sourceFile.getImportDeclarations()) {
+        if (imp.getDefaultImport()?.getText() === name)
+            return true;
+        if (imp.getNamespaceImport()?.getText() === name)
+            return true;
+        for (const ni of imp.getNamedImports()) {
+            if ((ni.getAliasNode()?.getText() ?? ni.getName()) === name)
+                return true;
+        }
+    }
+    return false;
+}
+// ═══════════════════════════════════════════════════════════════════
+// CHAIN ANALYSIS HELPERS
+// ═══════════════════════════════════════════════════════════════════
+/** True when the call (or any call in its chain) is a Playwright selector/frame. */
+function isPlaywrightChain(call) {
+    let expr = call;
+    for (let i = 0; i < 256; i++) {
+        expr = unwrap(expr);
+        if (ts_morph_1.Node.isCallExpression(expr)) {
+            const callee = unwrap(expr.getExpression());
+            if (ts_morph_1.Node.isPropertyAccessExpression(callee)) {
+                const cat = categorizeMethod(callee.getName());
+                if (cat === "selector" || cat === "frame")
+                    return true;
+                expr = callee.getExpression();
+                continue;
+            }
+            expr = callee;
+            continue;
+        }
+        break;
+    }
+    return false;
+}
+/**
+ * Walk a chain to its leftmost receiver. Returns the root-name when the
+ * receiver is a page-root, and the receiver Identifier when the chain hangs
+ * off another VARIABLE (a cascade link).
+ */
+function analyzeChainRoot(call) {
+    const { leftmost } = getLeftmostReceiver(call);
+    if (ts_morph_1.Node.isIdentifier(leftmost)) {
+        const txt = leftmost.getText();
+        if (PAGE_ROOT_NAMES.has(txt))
+            return { rootReceiver: txt, receiverVar: null };
+        return { rootReceiver: txt, receiverVar: leftmost };
+    }
+    return { rootReceiver: "page", receiverVar: null };
+}
+/** True when any selector arg in the chain is a template literal w/ ${…}. */
+function containsDynamicSelectorArg(node) {
+    for (const call of [
+        ...(ts_morph_1.Node.isCallExpression(node) ? [node] : []),
+        ...node.getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression),
+    ]) {
+        const arg = call.getArguments()[0];
+        if (arg && ts_morph_1.Node.isTemplateExpression(arg))
+            return true; // has substitutions
+    }
+    return false;
+}
+/** Strip trailing action/query calls, returning the locator-chain node. */
+function stripTrailingActions(topCall) {
+    let expr = unwrap(topCall);
+    for (let i = 0; i < 256; i++) {
+        if (!ts_morph_1.Node.isCallExpression(expr))
+            break;
+        const callee = unwrap(expr.getExpression());
+        if (ts_morph_1.Node.isPropertyAccessExpression(callee) &&
+            categorizeMethod(callee.getName()) === "action") {
+            expr = unwrap(callee.getExpression());
+            continue;
+        }
+        break;
+    }
+    return expr;
+}
+// ═══════════════════════════════════════════════════════════════════
+// SMALL AST UTILITIES
+// ═══════════════════════════════════════════════════════════════════
+function unwrap(node) {
+    let n = node;
+    for (let i = 0; i < 64; i++) {
+        if (ts_morph_1.Node.isAwaitExpression(n) ||
+            ts_morph_1.Node.isParenthesizedExpression(n) ||
+            ts_morph_1.Node.isNonNullExpression(n) ||
+            ts_morph_1.Node.isAsExpression(n)) {
+            n = n.getExpression();
+            continue;
+        }
+        break;
+    }
+    return n;
+}
+function isFunctionLike(node) {
+    return (ts_morph_1.Node.isArrowFunction(node) ||
+        ts_morph_1.Node.isFunctionDeclaration(node) ||
+        ts_morph_1.Node.isFunctionExpression(node) ||
+        ts_morph_1.Node.isMethodDeclaration(node) ||
+        ts_morph_1.Node.isConstructorDeclaration(node) ||
+        ts_morph_1.Node.isGetAccessorDeclaration(node) ||
+        ts_morph_1.Node.isSetAccessorDeclaration(node));
+}
+function isNullishOrLogical(bin) {
+    if (!ts_morph_1.Node.isBinaryExpression(bin))
+        return false;
+    const op = bin.getOperatorToken().getKind();
+    return (op === ts_morph_1.SyntaxKind.QuestionQuestionToken ||
+        op === ts_morph_1.SyntaxKind.BarBarToken ||
+        op === ts_morph_1.SyntaxKind.AmpersandAmpersandToken);
+}
+function getEnclosingVariableDeclaration(node) {
+    let cur = node.getParent();
+    while (cur) {
+        if (ts_morph_1.Node.isVariableDeclaration(cur))
+            return cur;
+        if (ts_morph_1.Node.isBlock(cur) || ts_morph_1.Node.isSourceFile(cur) || isFunctionLike(cur)) {
+            return null;
+        }
+        cur = cur.getParent();
+    }
+    return null;
+}
+function isWithin(node, container) {
+    return (node.getStart() >= container.getStart() &&
+        node.getEnd() <= container.getEnd());
+}
+/** Detects a standalone reassignment of a let/var-declared name after init. */
+function isReassigned(decl) {
+    const kind = decl.getVariableStatement()?.getDeclarationKind();
+    // DeclarationKind: "const" is not reassignable.
+    if (!kind || kind === "const")
+        return false;
+    const name = decl.getName();
+    const sf = decl.getSourceFile();
+    for (const bin of sf.getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)) {
+        if (bin.getOperatorToken().getKind() !== ts_morph_1.SyntaxKind.EqualsToken)
+            continue;
+        const left = bin.getLeft();
+        if (ts_morph_1.Node.isIdentifier(left) && left.getText() === name)
+            return true;
+    }
+    return false;
+}
+function findConstructorAssignment(cls, propName) {
+    for (const bin of cls.getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)) {
+        if (bin.getOperatorToken().getKind() !== ts_morph_1.SyntaxKind.EqualsToken)
+            continue;
+        const left = bin.getLeft();
+        if (ts_morph_1.Node.isPropertyAccessExpression(left) &&
+            left.getExpression().getKind() === ts_morph_1.SyntaxKind.ThisKeyword &&
+            left.getName() === propName) {
+            return bin.getRight();
+        }
+    }
+    return null;
+}
+function makeTarget(declKind, targetNode, declaration, rootReceiver, symbolNameOverride) {
+    return {
+        declKind,
+        targetNode,
+        declaration,
+        symbolName: symbolNameOverride ?? (0, AnchorResolver_1.enclosingSymbolName)(targetNode),
+        rootReceiver,
+        anchor: (0, AnchorResolver_1.computeAnchor)(targetNode),
+    };
+}
+function abort(severity, code, reason, node) {
+    return { status: "abort", severity, code, reason, node };
+}