sela-core 1.0.0

package/dist/services/SourceUpdater.js

@@ -0,0 +1,1021 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceUpdater = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ASTSourceUpdater_1 = require("./ASTSourceUpdater");
+// ─────────────────────────────────────────────────────────────────
+// QUOTE MANAGEMENT
+// ─────────────────────────────────────────────────────────────────
+const astUpdater = new ASTSourceUpdater_1.ASTSourceUpdater();
+function detectOuterQuote(line, target) {
+    const escaped = target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    for (const q of [`"`, `'`, "`"]) {
+        if (new RegExp(`${q}${escaped}${q}`).test(line))
+            return q;
+    }
+    return null;
+}
+function sanitizeForInjection(selector, outerQuote) {
+    switch (outerQuote) {
+        case `"`:
+            return selector.replace(/"/g, `'`);
+        case `'`:
+            return selector.replace(/'/g, `"`);
+        case "`":
+            return selector.replace(/`/g, "\\`");
+        default:
+            return selector.replace(/"/g, `'`);
+    }
+}
+function replaceStringLiteralInLine(line, target, replacement) {
+    const escaped = target.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    for (const q of [`"`, `'`, "`"]) {
+        const regex = new RegExp(`${q}${escaped}${q}`);
+        if (regex.test(line)) {
+            const safeReplacement = sanitizeForInjection(replacement, q);
+            return line.replace(regex, `${q}${safeReplacement}${q}`);
+        }
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────────
+// DEDUPLICATION
+// ─────────────────────────────────────────────────────────────────
+function deduplicateSelector(aiSelector, surroundingChain) {
+    const aiParts = aiSelector.split(">>").map((s) => s.trim());
+    const chainLower = surroundingChain.toLowerCase();
+    let startIdx = 0;
+    for (let i = 0; i < aiParts.length - 1; i++) {
+        const part = aiParts[i].replace(/['"]/g, "").toLowerCase();
+        if (chainLower.includes(part)) {
+            startIdx = i + 1;
+        }
+        else {
+            break;
+        }
+    }
+    return aiParts.slice(startIdx).join(" >> ").trim();
+}
+// ─────────────────────────────────────────────────────────────────
+// RUNTIME SELECTOR DEDUPLICATION  (FIX 2B)
+//
+// Removes duplicate consecutive `>>` segments from a runtime selector.
+// Uses normalised comparison so minor whitespace / quote differences
+// do not prevent deduplication.
+//
+// Example:
+//   "#modern-frame-container >> #modern-frame-container >> internal:control=enter-frame >> ..."
+//   → "#modern-frame-container >> internal:control=enter-frame >> ..."
+// ─────────────────────────────────────────────────────────────────
+function deduplicateRuntimeSelector(selector) {
+    const parts = selector.split(">>").map((s) => s.trim());
+    const deduped = [];
+    for (const part of parts) {
+        const norm = part
+            .replace(/['"]/g, "")
+            .toLowerCase()
+            .replace(/\s+/g, " ")
+            .trim();
+        const prevNorm = deduped.length > 0
+            ? deduped[deduped.length - 1]
+                .replace(/['"]/g, "")
+                .toLowerCase()
+                .replace(/\s+/g, " ")
+                .trim()
+            : null;
+        if (prevNorm !== null && norm === prevNorm) {
+            console.log(`[SelectorDedup] ✂️  Removed duplicate segment: "${part}"`);
+            continue;
+        }
+        deduped.push(part);
+    }
+    return deduped.join(" >> ");
+}
+function detectChain(lines, callerLine, oldLeafSelector) {
+    const escaped = oldLeafSelector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const leafRegex = new RegExp(`\\.locator\\(["'\`]${escaped}["'\`]\\)`);
+    let leafLine = -1;
+    const scanStart = Math.max(0, callerLine - 15);
+    for (let i = callerLine; i >= scanStart; i--) {
+        if (leafRegex.test(lines[i])) {
+            leafLine = i;
+            break;
+        }
+    }
+    if (leafLine === -1)
+        return null;
+    let chainEnd = leafLine;
+    for (let i = leafLine + 1; i <= callerLine; i++) {
+        if (/^\s*\.filter\s*\(/.test(lines[i])) {
+            chainEnd = i;
+        }
+        else {
+            break;
+        }
+    }
+    let anchorSelector = "";
+    for (let i = leafLine - 1; i >= scanStart; i--) {
+        const anchorMatch = lines[i].match(/\.locator\(["'`]([^"'`]+)["'`]\)/);
+        if (anchorMatch) {
+            anchorSelector = anchorMatch[1];
+            break;
+        }
+    }
+    return { startLine: leafLine, endLine: chainEnd, anchorSelector };
+}
+function detectChainRoot(lines, callerLine, oldLeafSelector) {
+    const escaped = oldLeafSelector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const leafPattern = new RegExp(`(?:locator|getByRole|getByLabel|getByText|getByTestId|getByPlaceholder)\\s*\\(\\s*["'\`]${escaped}["'\`]`);
+    let leafLine = -1;
+    const scanStart = Math.max(0, callerLine - 20);
+    for (let i = callerLine; i >= scanStart; i--) {
+        if (leafPattern.test(lines[i])) {
+            leafLine = i;
+            break;
+        }
+    }
+    if (leafLine === -1)
+        return null;
+    let chainEndLine = leafLine;
+    for (let i = leafLine + 1; i <= Math.min(lines.length - 1, leafLine + 10); i++) {
+        const trimmed = lines[i].trim();
+        if (/^\.(?:filter|first|last|nth)\s*\(/.test(trimmed)) {
+            chainEndLine = i;
+        }
+        else if (trimmed.startsWith(".")) {
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    let rootLine = leafLine;
+    let rootReceiver = "page";
+    for (let i = leafLine - 1; i >= scanStart; i--) {
+        const trimmed = lines[i].trim();
+        const combined = lines[i];
+        const isChainContinuation = trimmed.startsWith(".") ||
+            combined.trimEnd().endsWith("(") ||
+            combined.trimEnd().endsWith(",");
+        if (isChainContinuation) {
+            rootLine = i;
+            continue;
+        }
+        const assignMatch = combined.match(/(?:const|let|var)\s+[a-zA-Z_$][a-zA-Z0-9_$]*\s*=\s*(page|[a-zA-Z_$][a-zA-Z0-9_$]*)/);
+        if (assignMatch) {
+            rootReceiver = assignMatch[1];
+            rootLine = i;
+            break;
+        }
+        const pageMatch = combined.match(/^\s*((?:await\s+)?(?:page|[a-zA-Z_$][a-zA-Z0-9_$]*))\s*\.(?:locator|frameLocator|getBy)/);
+        if (pageMatch) {
+            rootReceiver = pageMatch[1].replace(/^await\s+/, "").trim();
+            rootLine = i;
+            break;
+        }
+        if (!isChainContinuation && i < leafLine - 1)
+            break;
+    }
+    return { rootLine, rootReceiver, leafLine, chainEndLine };
+}
+// ─────────────────────────────────────────────────────────────────
+// TEMPLATE VARIABLE PRESERVATION
+// ─────────────────────────────────────────────────────────────────
+function updateTemplateLiteralPreservingVars(line, oldSelector, newSelector, domAttributeHint) {
+    if (!line.includes("`") || !line.includes("${"))
+        return null;
+    const newLeaf = newSelector.split(">>").pop().trim();
+    const varMatches = [...line.matchAll(/\$\{([^}]+)\}/g)];
+    if (varMatches.length === 0)
+        return null;
+    const varExpression = varMatches[0][1];
+    const oldAttrInTemplateMatch = line.match(/\[([a-zA-Z-]+)=["']?\$\{[^}]+\}([^"'\]`]*)["']?\]/);
+    const oldAttrName = oldAttrInTemplateMatch?.[1] ?? null;
+    const oldStaticSuffix = oldAttrInTemplateMatch?.[2] ?? null;
+    const newAttrMatch = newLeaf.match(/\[([a-zA-Z-]+)="([^"]*)"\]/);
+    const newAttrName = newAttrMatch?.[1] ?? null;
+    const newAttrValue = newAttrMatch?.[2] ?? null;
+    const oldAttrRuntimeMatch = oldSelector.match(/\[([a-zA-Z-]+)="([^"]*)"\]/);
+    const oldAttrRuntimeValue = oldAttrRuntimeMatch?.[2] ?? null;
+    let varRuntimeValue = null;
+    if (oldAttrRuntimeValue !== null && oldStaticSuffix !== null) {
+        if (oldStaticSuffix.length > 0) {
+            varRuntimeValue = oldAttrRuntimeValue.endsWith(oldStaticSuffix)
+                ? oldAttrRuntimeValue.slice(0, -oldStaticSuffix.length)
+                : oldAttrRuntimeValue.split("_")[0];
+        }
+        else {
+            const underscoreIdx = oldAttrRuntimeValue.indexOf("_");
+            varRuntimeValue =
+                underscoreIdx >= 0
+                    ? oldAttrRuntimeValue.slice(0, underscoreIdx)
+                    : oldAttrRuntimeValue;
+        }
+    }
+    if (oldAttrName &&
+        newAttrName &&
+        oldAttrName === newAttrName &&
+        newAttrValue) {
+        let newSuffix = "";
+        if (varRuntimeValue && newAttrValue.startsWith(varRuntimeValue)) {
+            newSuffix = newAttrValue.slice(varRuntimeValue.length);
+        }
+        else {
+            const lastUnderscoreIdx = newAttrValue.lastIndexOf("_");
+            newSuffix =
+                lastUnderscoreIdx >= 0 ? newAttrValue.slice(lastUnderscoreIdx) : "";
+        }
+        if (newSuffix === oldStaticSuffix)
+            return null;
+        const escapedOldSuffix = (oldStaticSuffix ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const suffixPattern = new RegExp(`(\\$\\{[^}]+\\})${escapedOldSuffix}(["']?\\])`);
+        const updated = line.replace(suffixPattern, `$1${newSuffix}$2`);
+        return updated !== line ? updated : null;
+    }
+    if (oldAttrName && !newAttrName) {
+        let newSuffix = "";
+        if (domAttributeHint &&
+            varRuntimeValue &&
+            domAttributeHint.startsWith(varRuntimeValue)) {
+            newSuffix = domAttributeHint.slice(varRuntimeValue.length);
+        }
+        const reconstructedAttr = newSuffix.length > 0
+            ? `[${oldAttrName}="\${${varExpression}}${newSuffix}"]`
+            : `[${oldAttrName}="\${${varExpression}}"]`;
+        const oldAttrPattern = new RegExp(`\\[${oldAttrName.replace(/-/g, "\\-")}=["']?\\$\\{[^}]+\\}[^"'\\]\`]*["']?\\]`);
+        if (oldAttrPattern.test(line)) {
+            const updated = line.replace(oldAttrPattern, reconstructedAttr);
+            return updated !== line ? updated : null;
+        }
+        return null;
+    }
+    return null;
+}
+// ─────────────────────────────────────────────────────────────────
+// MAIN CLASS
+// ─────────────────────────────────────────────────────────────────
+// ─────────────────────────────────────────────────────────────────
+// GIT HELPER  (used by branch strategy and autoCommit)
+//
+// Design goals:
+//   • Lean — no stash, no branch-switching, no complex state management.
+//   • Commit-based — write first (inPlace), then commit.  If git fails,
+//     the fix is still on disk (silent inPlace fallback).
+//   • Detached HEAD aware — skips silently in CI environments that check
+//     out a specific SHA without a branch ref.
+// ─────────────────────────────────────────────────────────────────
+function runGitOperations(absoluteFilePath, createBranch, relativeFilePath) {
+    const filename = path.basename(relativeFilePath);
+    try {
+        // Bail out if HEAD is detached (CI SHA checkout, rebase mid-flight, etc.)
+        try {
+            (0, child_process_1.execSync)("git symbolic-ref HEAD", { stdio: "pipe" });
+        }
+        catch {
+            console.warn(`[SourceUpdater] ⚠️  Detached HEAD — git operations skipped (fix is saved to disk)`);
+            return;
+        }
+        if (createBranch) {
+            const branchName = `sela/heal-${Date.now()}`;
+            (0, child_process_1.execSync)(`git checkout -b ${branchName}`, { stdio: "pipe" });
+            console.log(`[SourceUpdater] 🌿 Created branch: ${branchName}`);
+        }
+        (0, child_process_1.execSync)(`git add "${absoluteFilePath}"`, { stdio: "pipe" });
+        (0, child_process_1.execSync)(`git commit -m "fix(sela): heal selector in ${filename}"`, {
+            stdio: "pipe",
+        });
+        console.log(`[SourceUpdater] ✅ Auto-committed fix in: ${filename}`);
+    }
+    catch (err) {
+        console.warn(`[SourceUpdater] ⚠️  Git operation failed: ${err.message} — fix written to disk (inPlace fallback)`);
+    }
+}
+class SourceUpdater {
+    // ─────────────────────────────────────────────────────────────
+    // PUBLIC ENTRY POINT
+    // Handles commentOnly short-circuit and post-write git operations,
+    // then delegates all selector-rewriting work to _coreUpdate().
+    // ─────────────────────────────────────────────────────────────
+    static update(caller, oldSelector, newSelector, domContext, dnaAttrHint, fullSelectorContext, aiSegments, contentChange, smartChainSegments, originalChainHint, updateStrategy, autoCommit) {
+        const resolvedPath = SourceUpdater.resolveFilePath(caller.filePath);
+        // ── commentOnly: write a TODO comment, skip all AST/regex work ──
+        if (updateStrategy === "commentOnly") {
+            if (!resolvedPath) {
+                return { success: false, reason: `File not found: ${caller.filePath}` };
+            }
+            const effective = deduplicateRuntimeSelector(newSelector);
+            return SourceUpdater.applyCommentOnly(caller, oldSelector, effective, resolvedPath);
+        }
+        // ── inPlace / branch: run the full rewriting pipeline ──────────
+        const result = SourceUpdater._coreUpdate(caller, oldSelector, newSelector, domContext, dnaAttrHint, fullSelectorContext, aiSegments, contentChange, smartChainSegments, originalChainHint);
+        // ── Post-write git operations (branch or autoCommit) ───────────
+        if (result.success &&
+            resolvedPath &&
+            (updateStrategy === "branch" || autoCommit)) {
+            runGitOperations(resolvedPath, updateStrategy === "branch", caller.filePath);
+        }
+        return result;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // commentOnly helper — inserts a TODO comment above the failing
+    // call site and returns success:false so the engine knows the
+    // source was NOT rewritten (no retry suppression needed).
+    // ─────────────────────────────────────────────────────────────
+    static applyCommentOnly(caller, oldSelector, newSelector, filePath) {
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            const lines = raw.split(/\r?\n/);
+            const lineIdx = caller.line - 1; // 0-based
+            if (lineIdx < 0 || lineIdx >= lines.length) {
+                return { success: false, reason: "COMMENT_ONLY: line out of range" };
+            }
+            const indent = lines[lineIdx].match(/^(\s*)/)?.[1] ?? "";
+            const comment = `${indent}// TODO [Sela]: replace "${oldSelector}" with "${newSelector}"`;
+            lines.splice(lineIdx, 0, comment);
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] 💬 Comment-only: inserted TODO at line ${caller.line} in ${path.basename(filePath)}`);
+            return {
+                success: false,
+                reason: "COMMENT_ONLY: TODO inserted, source selector not modified",
+                healedLocatorString: newSelector,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                reason: `COMMENT_ONLY: write failed — ${err.message}`,
+            };
+        }
+    }
+    // ─────────────────────────────────────────────────────────────
+    // CORE UPDATE — Layered Healing (AST primary, Regex fallback)
+    // Called by update(); never call directly from outside the class.
+    // ─────────────────────────────────────────────────────────────
+    static _coreUpdate(caller, oldSelector, newSelector, domContext, dnaAttrHint, fullSelectorContext, aiSegments, contentChange, smartChainSegments, originalChainHint) {
+        const filePath = SourceUpdater.resolveFilePath(caller.filePath);
+        // ── FIX 2B: Deduplicate the runtime selector BEFORE passing it down ──
+        // This prevents the engine from writing double-frame selectors like
+        // "#modern-frame-container >> #modern-frame-container >> ..."
+        const deduplicatedNewSelector = deduplicateRuntimeSelector(newSelector);
+        if (deduplicatedNewSelector !== newSelector) {
+            console.log(`[SourceUpdater] ✂️  Runtime selector deduplicated:\n` +
+                `  before: "${newSelector}"\n` +
+                `  after:  "${deduplicatedNewSelector}"`);
+        }
+        // Use the deduplicated selector for all subsequent operations
+        const effectiveNewSelector = deduplicatedNewSelector;
+        console.log(`[SourceUpdater] 📂 Attempting update in file: ${filePath}`);
+        console.log(`[SourceUpdater] 🔄 Request: "${oldSelector}" -> "${effectiveNewSelector}" (Line: ${caller.line})`);
+        if (smartChainSegments?.length) {
+            console.log(`[SourceUpdater] 🔗 smartChain: ${smartChainSegments.length} segments, ` +
+                `hint: ${originalChainHint?.length ?? 0} segments`);
+        }
+        if (contentChange) {
+            console.log(`[SourceUpdater] 📝 contentChange: "${contentChange.oldText}" → "${contentChange.newText}"`);
+        }
+        if (!filePath) {
+            console.error(`[SourceUpdater] ❌ File not found: ${caller.filePath}`);
+            return { success: false, reason: `File not found: ${caller.filePath}` };
+        }
+        // ── 1. AST Engine (Primary) ─────────────────────────────────────
+        try {
+            const astResult = astUpdater.update(caller, oldSelector, effectiveNewSelector, aiSegments, fullSelectorContext, contentChange, smartChainSegments, originalChainHint);
+            if (astResult.success) {
+                console.log(`[SourceUpdater] ✅ AST Strategy ${astResult.strategy} SUCCESS` +
+                    (astResult.lineUpdated !== undefined
+                        ? ` — line ${astResult.lineUpdated + 1}`
+                        : ""));
+                return {
+                    success: true,
+                    reason: `AST[${astResult.strategy}]: ${astResult.reason}`,
+                    lineUpdated: astResult.lineUpdated,
+                    // Prefer the AST's own healedLocatorString; fall back to the deduplicated input.
+                    healedLocatorString: astResult.healedLocatorString ?? effectiveNewSelector,
+                    definitionSite: astResult.definitionSite,
+                    blastRadius: astResult.blastRadius,
+                };
+            }
+            // Semantic guard means we identified a definition-site shape (IDENTIFIER /
+            // PROPERTY_ACCESS / TEMPLATE_LITERAL) but could not safely resolve the new
+            // value.  Regex cannot do better and will corrupt the definition site.
+            if (astResult.strategy === "semantic-guard") {
+                console.warn(`[SourceUpdater] 🛑 Regex blocked — semantic guard fired. ` +
+                    `Source unchanged. Reason: ${astResult.reason}`);
+                return { success: false, reason: astResult.reason };
+            }
+            console.log(`[SourceUpdater] ⚠️ AST engine exhausted (${astResult.reason}), falling back to Regex`);
+        }
+        catch (astError) {
+            console.warn(`[SourceUpdater] ⚠️ AST engine error: ${astError.message}. Falling back to Regex`);
+        }
+        // ── 2. Regex Fallback ──────────────────────────────────────────
+        console.log(`[SourceUpdater] 🔄 Using Regex fallback strategies...`);
+        const raw = fs.readFileSync(filePath, "utf8");
+        const lines = raw.split(/\r?\n/);
+        if (caller.line <= 0) {
+            console.log(`[SourceUpdater] ⚠️  line ${caller.line} invalid — running Regex Strategy G only`);
+            if (contentChange) {
+                const assertResult = SourceUpdater.strategyAssertionHealing(lines, 1, contentChange, true);
+                if (assertResult.success) {
+                    fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+                    console.log(`[SourceUpdater] ✅ Regex Strategy G (Assertion Healing) SUCCESS`);
+                    return assertResult;
+                }
+            }
+            console.warn(`[SourceUpdater] ❌ ALL STRATEGIES FAILED for line-0 heal`);
+            return { success: false, reason: "invalid line number (≤0)" };
+        }
+        const callerLine = caller.line - 1; // 0-based
+        if (!lines[callerLine]) {
+            console.warn(`[SourceUpdater] 📍 Target line ${caller.line} is empty or out of bounds.`);
+        }
+        else {
+            console.log(`[SourceUpdater] 📍 Analyzing line ${caller.line}: "${lines[callerLine].trim()}"`);
+        }
+        const tryAssertionHealing = () => {
+            if (!contentChange)
+                return;
+            console.log(`[SourceUpdater] 🔍 Checking for assertion mismatches...`);
+            console.warn(`\n[Fixwright-Advice] 💡 To fix the assertion at line ${caller.line}, ` +
+                `change to: .toHaveText("${contentChange.newText}")\n`);
+        };
+        // ── Strategy 0: Layered Frame Healing ──────────────────────
+        if (aiSegments && aiSegments.length > 0 && fullSelectorContext) {
+            const layeredResult = SourceUpdater.strategyLayeredHealing(lines, callerLine, oldSelector, aiSegments, fullSelectorContext);
+            if (layeredResult.success) {
+                tryAssertionHealing();
+                fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+                console.log(`[SourceUpdater] ✅ Strategy 0 (Layered Healing) SUCCESS — line ${layeredResult.lineUpdated + 1}`);
+                return layeredResult;
+            }
+        }
+        // ── Strategy F: Chain Collapsing (Regex) ───────────────────
+        const chainCollapseResult = SourceUpdater.strategyChainCollapse_Regex(lines, callerLine, oldSelector, effectiveNewSelector);
+        if (chainCollapseResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy F (Chain Collapse) SUCCESS`);
+            return chainCollapseResult;
+        }
+        // ── Strategy 1: Chain Collapse (original leaf-only) ────────
+        const chainResult = SourceUpdater.strategyChainCollapse(lines, callerLine, oldSelector, effectiveNewSelector);
+        if (chainResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 1 (Chain Collapse) SUCCESS`);
+            return chainResult;
+        }
+        // ── Strategy 2: Direct Literal ─────────────────────────────
+        const directResult = SourceUpdater.strategyDirectLiteral(lines, callerLine, oldSelector, effectiveNewSelector);
+        if (directResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 2 (Direct Literal) SUCCESS`);
+            return directResult;
+        }
+        // ── Strategy 3: Upstream Variable ──────────────────────────
+        const varResult = SourceUpdater.strategyUpstreamVariable(lines, callerLine, oldSelector, effectiveNewSelector);
+        if (varResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 3 (Upstream Variable) SUCCESS`);
+            return varResult;
+        }
+        // ── Strategy 4: Chained Dedup ──────────────────────────────
+        const chainDedupResult = SourceUpdater.strategyChainedLocator(lines, callerLine, oldSelector, effectiveNewSelector);
+        if (chainDedupResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 4 (Chained Dedup) SUCCESS`);
+            return chainDedupResult;
+        }
+        // ── Strategy 5: Function Return ────────────────────────────
+        const fnResult = SourceUpdater.strategyFunctionReturn(lines, callerLine, oldSelector, effectiveNewSelector, domContext, dnaAttrHint);
+        if (fnResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 5 (Function Return) SUCCESS`);
+            return fnResult;
+        }
+        // ── Strategy 6: Global Scan ────────────────────────────────
+        const scanResult = SourceUpdater.strategyGlobalScan(lines, oldSelector, effectiveNewSelector);
+        if (scanResult.success) {
+            tryAssertionHealing();
+            fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+            console.log(`[SourceUpdater] ✅ Strategy 6 (Global Scan) SUCCESS`);
+            return scanResult;
+        }
+        // ── Strategy G: Assertion Healing standalone ───────────────
+        if (contentChange) {
+            const assertResult = SourceUpdater.strategyAssertionHealing(lines, callerLine, contentChange);
+            if (assertResult.success) {
+                fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+                console.log(`[SourceUpdater] ✅ Strategy G (Assertion Healing) SUCCESS`);
+                return assertResult;
+            }
+        }
+        console.warn(`[SourceUpdater] ❌ ALL STRATEGIES FAILED for: "${oldSelector}"`);
+        return {
+            success: false,
+            reason: "No strategy matched (including AST and Regex Fallbacks)",
+        };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY F (Regex) — Full Chain Collapsing
+    // ─────────────────────────────────────────────────────────────
+    static strategyChainCollapse_Regex(lines, callerLine, oldSelector, newSelector) {
+        console.log(`[Strategy-F] ⛓️  Starting Regex Chain Collapse...`);
+        const oldLeaf = oldSelector.split(">>").pop().trim();
+        const chainRootInfo = detectChainRoot(lines, callerLine, oldLeaf);
+        if (!chainRootInfo) {
+            return { success: false, reason: "no chain root detected" };
+        }
+        const { rootLine, rootReceiver, leafLine, chainEndLine } = chainRootInfo;
+        if (rootLine === leafLine && chainEndLine === leafLine) {
+            return { success: false, reason: "single-line call, not a chain" };
+        }
+        console.log(`[Strategy-F] 🔗 Chain detected: root=${rootLine + 1}, leaf=${leafLine + 1}, ` +
+            `end=${chainEndLine + 1}, receiver="${rootReceiver}"`);
+        const newLeaf = newSelector.split(">>").pop().trim();
+        const safeNewLeaf = newLeaf.replace(/"/g, "'");
+        const newCallText = `.locator("${safeNewLeaf}")`;
+        const indentMatch = lines[rootLine].match(/^(\s*)/);
+        const indent = indentMatch ? indentMatch[1] : "";
+        const newLine = `${indent}${rootReceiver}${newCallText}`;
+        if (rootLine !== chainEndLine) {
+            const linesToReplace = chainEndLine - rootLine + 1;
+            lines.splice(rootLine, linesToReplace, newLine);
+            console.log(`[Strategy-F] ✅ Multi-line chain collapsed (${linesToReplace} lines → 1): "${newLine.trim()}"`);
+            return {
+                success: true,
+                reason: `chain collapsed (${linesToReplace} lines → 1)`,
+                lineUpdated: rootLine,
+            };
+        }
+        else {
+            const originalLine = lines[rootLine];
+            const receiverPattern = new RegExp(`(${rootReceiver.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})` +
+                `(?:\\s*\\.\\s*(?:locator|getBy\\w+|frameLocator|filter|first|last|nth)\\s*\\([^)]*\\))+`);
+            if (receiverPattern.test(originalLine)) {
+                const replaced = originalLine.replace(receiverPattern, `${rootReceiver}${newCallText}`);
+                if (replaced !== originalLine) {
+                    lines[rootLine] = replaced;
+                    console.log(`[Strategy-F] ✅ Single-line chain collapsed: "${replaced.trim()}"`);
+                    return {
+                        success: true,
+                        reason: "single-line chain collapsed",
+                        lineUpdated: rootLine,
+                    };
+                }
+            }
+        }
+        return { success: false, reason: "chain detected but could not replace" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY G (Regex) — Assertion Healing
+    // ─────────────────────────────────────────────────────────────
+    static strategyAssertionHealing(lines, callerLine, contentChange, wholeFile = false) {
+        const { oldText, newText } = contentChange;
+        console.log(`[Strategy-G] 🩹 Assertion Healing: "${oldText}" → "${newText}"`);
+        const TEXT_MATCHERS = [
+            "toHaveText",
+            "toContainText",
+            "toHaveValue",
+            "toHaveAttribute",
+            "toHaveLabel",
+            "toHaveTitle",
+        ];
+        const matcherPattern = new RegExp(`\\.(?:${TEXT_MATCHERS.join("|")})\\s*\\(`);
+        const searchStart = wholeFile ? 0 : Math.max(0, callerLine - 2);
+        const searchEnd = wholeFile
+            ? lines.length - 1
+            : Math.min(lines.length - 1, callerLine + 40);
+        let healedCount = 0;
+        let lastHealed;
+        for (let i = searchStart; i <= searchEnd; i++) {
+            const line = lines[i];
+            if (!matcherPattern.test(line))
+                continue;
+            for (const q of [`"`, `'`, "`"]) {
+                const escapedOld = oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const valuePattern = new RegExp(`${q}([^${q}]*${escapedOld}[^${q}]*)${q}`);
+                const match = valuePattern.exec(line);
+                if (match) {
+                    const oldValue = match[1];
+                    const newValue = oldValue.replace(oldText, newText);
+                    const safeNew = sanitizeForInjection(newValue, q);
+                    const escaped = oldValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                    const replaceRx = new RegExp(`${q}${escaped}${q}`);
+                    const newLine = line.replace(replaceRx, `${q}${safeNew}${q}`);
+                    if (newLine !== line) {
+                        lines[i] = newLine;
+                        healedCount++;
+                        lastHealed = i;
+                        console.log(`[Strategy-G] ✅ Healed assertion at line ${i + 1}: "${oldValue}" → "${newValue}"`);
+                        break;
+                    }
+                }
+            }
+        }
+        if (healedCount > 0) {
+            return {
+                success: true,
+                reason: `assertion healing: ${healedCount} assertion(s) updated`,
+                lineUpdated: lastHealed,
+            };
+        }
+        return { success: false, reason: "no assertions to heal" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 0 — Layered Healing (Upstream Variable Tracing)
+    // ─────────────────────────────────────────────────────────────
+    static strategyLayeredHealing(lines, callerLine, oldElementSelector, aiSegments, fullSelectorContext) {
+        console.log(`[SourceUpdater] 🧠 Strategy 0: Starting Layered Healing...`);
+        const failureLine = lines[callerLine] ?? "";
+        const varUsageMatch = failureLine.match(/^\s*(?:await\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*locator\s*\(/);
+        const usedVarName = varUsageMatch?.[1];
+        if (usedVarName && usedVarName !== "page") {
+            const origin = SourceUpdater.findVariableOrigin(lines, usedVarName, callerLine);
+            if (origin) {
+                const frameSegments = aiSegments.filter((s) => s.type === "frame");
+                if (frameSegments.length === 0) {
+                    lines[callerLine] = failureLine.replace(`${usedVarName}.locator`, `page.locator`);
+                    return {
+                        success: true,
+                        reason: `Collapsed variable '${usedVarName}' to 'page'`,
+                        lineUpdated: callerLine,
+                    };
+                }
+                let newDeclaration = `    const ${usedVarName} = page`;
+                frameSegments.forEach((seg) => {
+                    newDeclaration += `.frameLocator("${seg.selector}")`;
+                });
+                newDeclaration += ";";
+                const scanEnd = Math.min(lines.length - 1, origin.declarationLine + 5);
+                let endOfDeclaration = origin.declarationLine;
+                for (let i = origin.declarationLine; i <= scanEnd; i++) {
+                    if (lines[i].includes(";")) {
+                        endOfDeclaration = i;
+                        break;
+                    }
+                }
+                lines.splice(origin.declarationLine, endOfDeclaration - origin.declarationLine + 1, newDeclaration);
+                return {
+                    success: true,
+                    reason: `Reconstructed variable '${usedVarName}' with AI frame path`,
+                    lineUpdated: origin.declarationLine,
+                };
+            }
+        }
+        return { success: false, reason: "no matches found in chain" };
+    }
+    static findVariableOrigin(lines, varName, startLine) {
+        const scanStart = Math.max(0, startLine - 30);
+        const declarationPattern = new RegExp(`^\\s*(?:const|let|var)\\s+${varName}\\s*=`);
+        for (let i = startLine - 1; i >= scanStart; i--) {
+            if (declarationPattern.test(lines[i])) {
+                return { varName, declarationLine: i, lineContent: lines[i] };
+            }
+        }
+        return null;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 1 — Chain Collapse (leaf-only precision replacement)
+    // ─────────────────────────────────────────────────────────────
+    static strategyChainCollapse(lines, callerLine, oldSelector, newSelector) {
+        const oldLeaf = oldSelector
+            .split(">>")
+            .pop()
+            .replace(/\.filter\([^)]*\)/g, "")
+            .trim();
+        const newLeaf = newSelector.split(">>").pop().trim();
+        const chain = detectChain(lines, callerLine, oldLeaf);
+        if (!chain)
+            return { success: false, reason: "no chain detected" };
+        const deduped = chain.anchorSelector
+            ? deduplicateSelector(newSelector, chain.anchorSelector)
+            : newLeaf;
+        const outerQuote = detectOuterQuote(lines[chain.startLine], oldLeaf) ?? `"`;
+        const safeDeduped = sanitizeForInjection(deduped, outerQuote);
+        const escapedOldLeaf = oldLeaf.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const escapedQ = outerQuote.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const leafLiteralRegex = new RegExp(`(\\.locator\\(${escapedQ})${escapedOldLeaf}(${escapedQ}\\))`);
+        if (leafLiteralRegex.test(lines[chain.startLine])) {
+            lines[chain.startLine] = lines[chain.startLine].replace(leafLiteralRegex, `$1${safeDeduped}$2`);
+        }
+        else {
+            const replaced = replaceStringLiteralInLine(lines[chain.startLine], oldLeaf, safeDeduped);
+            if (replaced === null)
+                return { success: false, reason: "chain leaf literal not found" };
+            lines[chain.startLine] = replaced;
+        }
+        if (chain.endLine > chain.startLine) {
+            for (let i = chain.endLine; i > chain.startLine; i--) {
+                if (/^\s*\.filter\s*\(/.test(lines[i]))
+                    lines.splice(i, 1);
+            }
+        }
+        return {
+            success: true,
+            reason: `chain collapsed: '${oldLeaf}' → '${deduped}'`,
+            lineUpdated: chain.startLine,
+        };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 2 — Direct Literal
+    // ─────────────────────────────────────────────────────────────
+    static strategyDirectLiteral(lines, callerLine, oldSelector, newSelector) {
+        const windowSize = 10;
+        const start = Math.max(0, callerLine - windowSize);
+        const end = Math.min(lines.length - 1, callerLine + windowSize);
+        const lastOldPart = oldSelector.split(">>").pop().trim();
+        const lastNewPart = newSelector.split(">>").pop().trim();
+        for (let i = callerLine; i >= start; i--) {
+            const outerQ = detectOuterQuote(lines[i], lastOldPart);
+            if (!outerQ)
+                continue;
+            const safe = sanitizeForInjection(lastNewPart, outerQ);
+            const replaced = replaceStringLiteralInLine(lines[i], lastOldPart, safe);
+            if (replaced !== null) {
+                lines[i] = replaced;
+                return { success: true, reason: "direct literal", lineUpdated: i };
+            }
+        }
+        for (let i = callerLine + 1; i <= end; i++) {
+            const outerQ = detectOuterQuote(lines[i], lastOldPart);
+            if (!outerQ)
+                continue;
+            const safe = sanitizeForInjection(lastNewPart, outerQ);
+            const replaced = replaceStringLiteralInLine(lines[i], lastOldPart, safe);
+            if (replaced !== null) {
+                lines[i] = replaced;
+                return { success: true, reason: "direct literal", lineUpdated: i };
+            }
+        }
+        return { success: false, reason: "no direct literal" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 3 — Upstream Variable/Const
+    // ─────────────────────────────────────────────────────────────
+    static strategyUpstreamVariable(lines, callerLine, oldSelector, newSelector) {
+        const callBlock = lines
+            .slice(Math.max(0, callerLine - 5), callerLine + 1)
+            .join("\n");
+        const identifierPattern = /\b([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)\b/g;
+        const candidates = new Set();
+        let m;
+        while ((m = identifierPattern.exec(callBlock)) !== null)
+            candidates.add(m[1]);
+        const lastOldPart = oldSelector.split(">>").pop().trim();
+        const lastNewPart = newSelector.split(">>").pop().trim();
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const outerQ = detectOuterQuote(line, lastOldPart);
+            if (!outerQ)
+                continue;
+            const safe = sanitizeForInjection(lastNewPart, outerQ);
+            const replaced = replaceStringLiteralInLine(line, lastOldPart, safe);
+            if (replaced === null)
+                continue;
+            for (const ident of candidates) {
+                const baseName = ident.split(".")[0];
+                if (line.includes(baseName)) {
+                    lines[i] = replaced;
+                    return {
+                        success: true,
+                        reason: `upstream variable '${ident}'`,
+                        lineUpdated: i,
+                    };
+                }
+            }
+        }
+        return { success: false, reason: "no upstream variable" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 4 — Chained Locator Dedup
+    // ─────────────────────────────────────────────────────────────
+    static strategyChainedLocator(lines, callerLine, oldSelector, newSelector) {
+        const blockStart = Math.max(0, callerLine - 10);
+        const chainBlock = lines.slice(blockStart, callerLine + 1).join("\n");
+        const deduped = deduplicateSelector(newSelector, oldSelector + "\n" + chainBlock);
+        if (deduped === newSelector)
+            return { success: false, reason: "no duplication detected" };
+        const lastOldPart = oldSelector.split(">>").pop().trim();
+        for (let i = callerLine; i >= blockStart; i--) {
+            const outerQ = detectOuterQuote(lines[i], lastOldPart);
+            if (!outerQ)
+                continue;
+            const safe = sanitizeForInjection(deduped, outerQ);
+            const replaced = replaceStringLiteralInLine(lines[i], lastOldPart, safe);
+            if (replaced !== null) {
+                lines[i] = replaced;
+                return {
+                    success: true,
+                    reason: `chained dedup: '${newSelector}' → '${deduped}'`,
+                    lineUpdated: i,
+                };
+            }
+        }
+        return { success: false, reason: "dedup found but literal not replaced" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 5 — Function/Template with Variable Preservation
+    // ─────────────────────────────────────────────────────────────
+    static strategyFunctionReturn(lines, callerLine, oldSelector, newSelector, domContext, dnaAttrHint) {
+        const callBlock = lines
+            .slice(Math.max(0, callerLine - 8), callerLine + 1)
+            .join("\n");
+        const fnCallPattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+        const fnNames = new Set();
+        let m;
+        const playwrightBuiltins = new Set([
+            "locator",
+            "fill",
+            "click",
+            "check",
+            "uncheck",
+            "hover",
+            "dblclick",
+            "focus",
+            "waitFor",
+            "isVisible",
+            "getAttribute",
+            "innerText",
+            "innerHTML",
+            "textContent",
+            "page",
+            "filter",
+            "expect",
+            "selectOption",
+            "frameLocator",
+        ]);
+        while ((m = fnCallPattern.exec(callBlock)) !== null) {
+            if (!playwrightBuiltins.has(m[1]))
+                fnNames.add(m[1]);
+        }
+        if (fnNames.size === 0)
+            return { success: false, reason: "no function calls found near site" };
+        const newLeaf = newSelector.split(">>").pop().trim();
+        const oldSelectorAttrMatch = oldSelector.match(/\[([a-zA-Z][a-zA-Z0-9-]*)=/);
+        const expectedAttrName = oldSelectorAttrMatch?.[1] ?? null;
+        const resolvedAttrHint = dnaAttrHint ??
+            SourceUpdater.extractAttrValueFromDom(domContext ?? "", oldSelector) ??
+            undefined;
+        for (const fnName of fnNames) {
+            const defPattern = new RegExp(`(?:const|let|var|function)\\s+${fnName}\\b`);
+            for (let i = 0; i < lines.length; i++) {
+                if (!defPattern.test(lines[i]))
+                    continue;
+                for (let j = i; j < Math.min(lines.length, i + 8); j++) {
+                    const line = lines[j];
+                    if (line.includes("`") && line.includes("${")) {
+                        if (expectedAttrName && !line.includes(expectedAttrName))
+                            continue;
+                        if (!expectedAttrName)
+                            continue;
+                        const preserved = updateTemplateLiteralPreservingVars(line, oldSelector, newSelector, resolvedAttrHint);
+                        if (preserved !== null && preserved !== line) {
+                            lines[j] = preserved;
+                            return {
+                                success: true,
+                                reason: `function template updated (vars preserved)`,
+                                lineUpdated: j,
+                            };
+                        }
+                        continue;
+                    }
+                    const lastOldPart = oldSelector.split(">>").pop().trim();
+                    const outerQ = detectOuterQuote(line, lastOldPart);
+                    if (!outerQ)
+                        continue;
+                    const safe = sanitizeForInjection(newLeaf, outerQ);
+                    const replaced = replaceStringLiteralInLine(line, lastOldPart, safe);
+                    if (replaced !== null) {
+                        lines[j] = replaced;
+                        return {
+                            success: true,
+                            reason: `function literal replaced`,
+                            lineUpdated: j,
+                        };
+                    }
+                }
+            }
+        }
+        return { success: false, reason: "function strategy exhausted" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // STRATEGY 6 — Global Scan
+    // ─────────────────────────────────────────────────────────────
+    static strategyGlobalScan(lines, oldSelector, newSelector) {
+        const lastOldPart = oldSelector.split(">>").pop().trim();
+        const lastNewPart = newSelector.split(">>").pop().trim();
+        for (let i = 0; i < lines.length; i++) {
+            const deduped = deduplicateSelector(newSelector, lines[i]);
+            const effectiveNew = deduped !== newSelector ? deduped : lastNewPart;
+            const outerQ = detectOuterQuote(lines[i], lastOldPart);
+            if (!outerQ)
+                continue;
+            const safe = sanitizeForInjection(effectiveNew, outerQ);
+            const replaced = replaceStringLiteralInLine(lines[i], lastOldPart, safe);
+            if (replaced !== null) {
+                lines[i] = replaced;
+                return { success: true, reason: "global scan", lineUpdated: i };
+            }
+        }
+        return { success: false, reason: "not found anywhere in file" };
+    }
+    // ─────────────────────────────────────────────────────────────
+    // UTILITIES
+    // ─────────────────────────────────────────────────────────────
+    static extractAttrValueFromDom(domContext, oldSelector) {
+        const attrMatch = oldSelector.match(/\[([a-zA-Z-]+)=/);
+        if (!attrMatch)
+            return null;
+        const attrName = attrMatch[1];
+        const domValueMatch = domContext.match(new RegExp(`${attrName.replace(/-/g, "\\-")}=["']([^"']*)["']`));
+        return domValueMatch?.[1] ?? null;
+    }
+    static resolveFilePath(raw) {
+        let clean = raw
+            .replace(/^.*?at\s+/, "")
+            .replace(/:\d+:\d+.*$/, "")
+            .trim();
+        if (!path.isAbsolute(clean))
+            clean = path.resolve(process.cwd(), clean);
+        return fs.existsSync(clean) ? clean : null;
+    }
+    static updateArgument(caller, action, oldArgument, newArgument) {
+        const filePath = SourceUpdater.resolveFilePath(caller.filePath);
+        if (!filePath)
+            return { success: false, reason: `File not found: ${caller.filePath}` };
+        const raw = fs.readFileSync(filePath, "utf8");
+        const lines = raw.split(/\r?\n/);
+        const callerLine = caller.line - 1;
+        const windowSize = 5;
+        const start = Math.max(0, callerLine - windowSize);
+        const end = Math.min(lines.length - 1, callerLine + windowSize);
+        const escapedAction = action.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const escapedOldArg = oldArgument.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        for (const q of [`"`, `'`]) {
+            const pattern = new RegExp(`(\\.${escapedAction}\\(${q})${escapedOldArg}(${q})`);
+            for (let i = callerLine; i >= start; i--) {
+                if (pattern.test(lines[i])) {
+                    const safeNew = sanitizeForInjection(newArgument, q);
+                    lines[i] = lines[i].replace(pattern, `$1${safeNew}$2`);
+                    fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+                    return { success: true, reason: "argument updated", lineUpdated: i };
+                }
+            }
+            for (let i = callerLine + 1; i <= end; i++) {
+                if (pattern.test(lines[i])) {
+                    const safeNew = sanitizeForInjection(newArgument, q);
+                    lines[i] = lines[i].replace(pattern, `$1${safeNew}$2`);
+                    fs.writeFileSync(filePath, lines.join("\n"), "utf8");
+                    return { success: true, reason: "argument updated", lineUpdated: i };
+                }
+            }
+        }
+        console.warn(`[SourceUpdater] ❌ Argument "${oldArgument}" not found near line ${caller.line}`);
+        return { success: false, reason: "argument not found" };
+    }
+    /** Flush buffered advisories to console. Call after Playwright prints its test result. */
+    static flushAdvisories() {
+        astUpdater.flushAdvisories();
+    }
+}
+exports.SourceUpdater = SourceUpdater;