sela-core 0.1.0-alpha.1

package/dist/fixtures/index.js

@@ -0,0 +1,765 @@
+"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.createHealingExpect = exports.test = void 0;
+exports.resolveSelaProxy = resolveSelaProxy;
+exports.createFrameLocatorProxy = createFrameLocatorProxy;
+exports.createLocatorProxy = createLocatorProxy;
+const test_1 = require("@playwright/test");
+const StackUtils_1 = require("../utils/StackUtils");
+const logger_1 = require("../utils/logger");
+const HealingRegistry_1 = require("../engine/HealingRegistry");
+const singleton_1 = require("../engine/singleton");
+const expectProxy_1 = require("./expectProxy");
+const proxyTag_1 = require("./proxyTag");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const registry = HealingRegistry_1.HealingRegistry.getInstance();
+const proxyToActiveLocator = new WeakMap();
+// Module-level resolver - moduleExpect.ts uses this to unwrap a Sela
+// locator proxy back to its live underlying Playwright Locator without
+// needing access to the WeakMap directly.
+function resolveSelaProxy(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const getActive = proxyToActiveLocator.get(value);
+    return getActive ? getActive() : null;
+}
+// ─── Action classification (identical to original) ────────────────
+const INTERCEPTED_ACTIONS = [
+    "click",
+    "fill",
+    "check",
+    "uncheck",
+    "hover",
+    "selectOption",
+    "innerText",
+    "innerHTML",
+    "textContent",
+    "getAttribute",
+    "dblclick",
+    "focus",
+    "isVisible",
+    "isEnabled",
+    "isChecked",
+    "waitFor",
+    "dragTo",
+    "pressSequentially",
+    "setInputFiles",
+    "type",
+    "press",
+    "clear",
+    "tap",
+    "count",
+    "isHidden",
+    "inputValue",
+    "dispatchEvent",
+    "getProperty",
+    "getByRole",
+    "getByLabel",
+    "getByPlaceholder",
+    "getByTestId",
+    "getByText",
+    "getByAltText",
+    "getByTitle",
+    "frameLocator",
+    "filter",
+    "locator",
+    "first",
+    "last",
+    "nth",
+];
+const DIRECT_VALUE_ACTIONS = new Set([
+    "fill",
+    "selectOption",
+    "setInputFiles",
+    "type",
+    "pressSequentially",
+    "dragTo",
+    "dispatchEvent",
+]);
+const OPTIONS_ONLY_ACTIONS = new Set([
+    "click",
+    "hover",
+    "dblclick",
+    "check",
+    "uncheck",
+    "tap",
+    "focus",
+    "press",
+    "dispatchEvent",
+    "waitFor",
+    "isVisible",
+    "isEnabled",
+    "isChecked",
+    "isHidden",
+    "dragTo",
+    "clear",
+    "scrollIntoViewIfNeeded",
+]);
+const NO_ARGS_ACTIONS = new Set([
+    "innerText",
+    "innerHTML",
+    "textContent",
+    "inputValue",
+    "getAttribute",
+    "getProperty",
+    "count",
+]);
+// ─── getBy* semantic selector map (identical to original) ─────────
+const GET_BY_METHODS = {
+    getByRole: (args) => {
+        const role = args[0];
+        const opts = args[1] ?? {};
+        const name = opts.name ? `[name="${opts.name}"i]` : "";
+        return `internal:role=${role}${name}`;
+    },
+    getByLabel: (args) => `internal:label=${JSON.stringify(args[0])}`,
+    getByPlaceholder: (args) => `internal:attr=[placeholder=${JSON.stringify(args[0])}]`,
+    getByTestId: (args) => `[data-testid="${args[0]}"]`,
+    getByText: (args) => {
+        const opts = args[1] ?? {};
+        const exact = opts.exact ? "" : "i";
+        return `internal:text=${JSON.stringify(args[0])}${exact}`;
+    },
+    getByAltText: (args) => `internal:attr=[alt=${JSON.stringify(args[0])}]`,
+    getByTitle: (args) => `internal:attr=[title=${JSON.stringify(args[0])}]`,
+};
+// ─────────────────────────────────────────────────────────────────
+// buildLiveLocator - registry-aware
+//
+// NEW: resolves the selector through the HealingRegistry before
+// constructing the Playwright Locator. Zero cost when no heal has
+// occurred for this selector.
+// ─────────────────────────────────────────────────────────────────
+function buildLiveLocator(rawPage, fullSelector) {
+    // 1. ניקוי אבסולוטי של שאריות Proxy
+    const cleanedSelector = sanitizeProxySelector(fullSelector);
+    const resolved = registry.resolveSelector(cleanedSelector);
+    // 2. פירוק הסלקטור ובנייה חכמה
+    const segments = resolved.split(" >> ").map((s) => s.trim());
+    let current = rawPage;
+    for (const segment of segments) {
+        if (!segment)
+            continue;
+        // טיפול ב-Frames (ללא שינוי)
+        if (segment.includes("frame") ||
+            segment.startsWith("#outer") ||
+            segment.startsWith("#inner")) {
+            current = current.frameLocator(segment);
+            continue;
+        }
+        // --- צומת החלטה: האם זה פילטר? (מטפל גם בהזיות AI) ---
+        // תבנית א': ה-AI המציא "filter=hasText:..."
+        const aiFilterMatch = segment.match(/^filter=hasText:(["']?)(.*?)\1$/);
+        // תבנית ב': Playwright Native ":has-text(...)"
+        const hasTextMatch = segment.match(/^:has-text\((["'])(.*?)\1\)$/);
+        // תבנית ג': ה-AI כתב "text=..." בתוך שרשרת שנועדה להיות פילטר
+        const textMatch = segment.match(/^text=(["']?)(.*?)\1$/);
+        if (aiFilterMatch || hasTextMatch || textMatch) {
+            const textToFilter = (aiFilterMatch?.[2] ||
+                hasTextMatch?.[2] ||
+                textMatch?.[2]);
+            current = current.filter({ hasText: textToFilter });
+            continue;
+        }
+        // אם הגענו לכאן, זה סלקטור רגיל
+        current = current.locator(segment);
+    }
+    return current;
+}
+/**
+ * מנקה בצורה אבסולוטית כל "שארית" של קריאת JS (כמו .filter, .or, .and)
+ * הוסף את זה מעל buildLiveLocator אם זה חסר לך.
+ */
+function sanitizeProxySelector(rawSelector) {
+    const segments = rawSelector.split(" >> ");
+    const cleanedSegments = segments.map((segment) => {
+        const jsMethodRegex = /\.[a-zA-Z_$]+\((?:[^"'\)\`]|"[^"]*"|'[^']*'|`[^`]*`)*\)/g;
+        return segment.replace(jsMethodRegex, "").trim();
+    });
+    return cleanedSegments.filter((s) => s.length > 0).join(" >> ");
+}
+// ─── Argument builder (identical to original) ─────────────────────
+function buildHealedArgs(prop, args, timeout = 8000) {
+    if (prop === "dragTo") {
+        const options = args[1] && typeof args[1] === "object" ? args[1] : {};
+        return [args[0], { ...options, timeout }];
+    }
+    if (DIRECT_VALUE_ACTIONS.has(prop)) {
+        const opts = args[1] && typeof args[1] === "object" ? args[1] : {};
+        return [args[0], { ...opts, timeout }];
+    }
+    if (OPTIONS_ONLY_ACTIONS.has(prop)) {
+        const opts = args[0] && typeof args[0] === "object" ? args[0] : {};
+        return [{ ...opts, timeout }];
+    }
+    if (NO_ARGS_ACTIONS.has(prop)) {
+        if (args.length > 0 && typeof args[0] === "string") {
+            const opts = args[1] && typeof args[1] === "object" ? args[1] : {};
+            return [args[0], { ...opts, timeout }];
+        }
+        const opts = args[0] && typeof args[0] === "object" ? args[0] : {};
+        return [{ ...opts, timeout }];
+    }
+    logger_1.logger.debug(`buildHealedArgs: unknown prop "${prop}", passing as-is`);
+    return args;
+}
+// ─────────────────────────────────────────────────────────────────
+// runWithHealArgument (unchanged from original)
+// ─────────────────────────────────────────────────────────────────
+async function runWithHealArgument(rawPage, prop, args, fullSelector, stableId, callerInfo, originalError) {
+    logger_1.logger.debug(`Element visible, action '${prop}' failed - healing argument…`);
+    const oldArgument = typeof args[0] === "string" ? args[0] : JSON.stringify(args[0]);
+    const newArgument = await singleton_1.sharedEngine.healArgument(rawPage, fullSelector, prop, oldArgument, stableId, callerInfo.filePath, callerInfo.line);
+    if (!newArgument)
+        throw originalError;
+    const locator = buildLiveLocator(rawPage, fullSelector);
+    const healedArgs = buildHealedArgs(prop, [newArgument, ...args.slice(1)], 8000);
+    return await locator[prop](...healedArgs);
+}
+// ─────────────────────────────────────────────────────────────────
+// runWithHeal - pre-flight registry check added
+//
+// NEW: Before the first Playwright attempt, resolve the selector
+// through the registry. If a previous heal already mapped it, the
+// first attempt uses the healed selector and succeeds immediately -
+// no timeout, no AI call, no file write.
+// ─────────────────────────────────────────────────────────────────
+async function runWithHeal(rawPage, prop, args, fullSelector, elementSelectorOnly, stableId, callerInfo) {
+    // ── Pre-flight: swap to healed selector if one already exists ──
+    const preResolved = registry.resolveSelector(fullSelector);
+    const effectiveSelector = preResolved !== fullSelector ? preResolved : fullSelector;
+    if (effectiveSelector !== fullSelector) {
+        logger_1.logger.debug(`Pre-flight swap: "${fullSelector}" → "${effectiveSelector}"`);
+    }
+    const initialLocator = buildLiveLocator(rawPage, effectiveSelector);
+    try {
+        const result = await initialLocator[prop](...buildHealedArgs(prop, args, 3000));
+        await singleton_1.sharedEngine.captureSuccessfulElement(rawPage, effectiveSelector, stableId);
+        return {
+            result,
+            finalSelector: effectiveSelector,
+            finalElementSelector: elementSelectorOnly,
+        };
+    }
+    catch (firstError) {
+        logger_1.logger.debug(`'${prop}' failed on: "${effectiveSelector}"`);
+        const isVisible = await initialLocator
+            .isVisible({ timeout: 1500 })
+            .catch(() => false);
+        if (isVisible && (prop === "selectOption" || prop === "fill")) {
+            const result = await runWithHealArgument(rawPage, prop, args, effectiveSelector, stableId, callerInfo, firstError);
+            return {
+                result,
+                finalSelector: effectiveSelector,
+                finalElementSelector: elementSelectorOnly,
+            };
+        }
+        if (prop === "dragTo") {
+            return await runWithHealDragTo(rawPage, args, effectiveSelector, elementSelectorOnly, stableId, callerInfo, firstError, (s) => buildLiveLocator(rawPage, s));
+        }
+        return await runWithHealSelector(rawPage, prop, args, effectiveSelector, elementSelectorOnly, stableId, callerInfo, firstError);
+    }
+}
+// ─────────────────────────────────────────────────────────────────
+// runWithHealSelector (unchanged from original)
+//
+// Note: broadcast is now handled inside ASTSourceUpdater.update()
+// via broadcastAndReturn(), so there is NO explicit registry call here.
+// The Proxy listener fires automatically before this function returns.
+// ─────────────────────────────────────────────────────────────────
+async function runWithHealSelector(rawPage, prop, args, fullSelector, elementSelectorOnly, stableId, callerInfo, originalError) {
+    logger_1.logger.debug(`Healing selector…`);
+    const newFullSelector = await singleton_1.sharedEngine.heal(rawPage, fullSelector, elementSelectorOnly, stableId, callerInfo.filePath, callerInfo.line);
+    if (!newFullSelector)
+        throw originalError;
+    // By the time engine.heal() returns, ASTSourceUpdater.update() has
+    // already called broadcastAndReturn() → registry.broadcast() →
+    // every live Proxy listener has already swapped its activeLocator.
+    // We just need to build the locator for THIS call-site's retry.
+    const healedLocator = buildLiveLocator(rawPage, newFullSelector);
+    try {
+        const result = await healedLocator[prop](...buildHealedArgs(prop, args, 8000));
+        await singleton_1.sharedEngine.captureSuccessfulElement(rawPage, newFullSelector, stableId);
+        return {
+            result,
+            finalSelector: newFullSelector,
+            finalElementSelector: newFullSelector.split(" >> ").pop() ?? newFullSelector,
+        };
+    }
+    catch (retryError) {
+        throw retryError;
+    }
+}
+// ─────────────────────────────────────────────────────────────────
+// runWithHealDragTo (identical to original)
+// ─────────────────────────────────────────────────────────────────
+function extractDragToTargetFromSource(rawFilePath, line) {
+    try {
+        let filePath = rawFilePath
+            .replace(/^.*?at\s+/, "")
+            .replace(/:\d+:\d+.*$/, "")
+            .trim();
+        if (!path.isAbsolute(filePath)) {
+            filePath = path.resolve(process.cwd(), filePath);
+        }
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split(/\r?\n/);
+        const block = lines
+            .slice(Math.max(0, line - 3), Math.min(lines.length - 1, line + 3) + 1)
+            .join("\n");
+        const patterns = [
+            /\.dragTo\s*\(\s*(?:page|rawPage)\.locator\s*\(\s*"([^"]+)"\s*\)/,
+            /\.dragTo\s*\(\s*(?:page|rawPage)\.locator\s*\(\s*'([^']+)'\s*\)/,
+            /\.dragTo\s*\(\s*(?:page|rawPage)\.locator\s*\(\s*`([^`]+)`\s*\)/,
+        ];
+        for (const p of patterns) {
+            const m = block.match(p);
+            if (m?.[1])
+                return m[1];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runWithHealDragTo(rawPage, args, fullSelector, elementSelectorOnly, stableId, callerInfo, originalError, buildFreshLocator) {
+    logger_1.logger.debug(`dragTo Double Healing initiated`);
+    const targetSelectorFromSource = extractDragToTargetFromSource(callerInfo.filePath, callerInfo.line);
+    const sourceLocator = buildFreshLocator(fullSelector);
+    const isSourceVisible = await sourceLocator
+        .isVisible({ timeout: 500 })
+        .catch(() => false);
+    let healedSourceSelector = fullSelector;
+    let healedTargetLocator = args[0];
+    if (!isSourceVisible) {
+        try {
+            healedSourceSelector = await singleton_1.sharedEngine.heal(rawPage, fullSelector, elementSelectorOnly, stableId, callerInfo.filePath, callerInfo.line);
+            // broadcast already fired inside engine.heal() via ASTSourceUpdater
+            logger_1.logger.debug(`Source healed: "${healedSourceSelector}"`);
+        }
+        catch (e) {
+            if (e instanceof Error && e.message.includes("[SafetyGuard]"))
+                throw e;
+            logger_1.logger.warn(`Source healing failed, using original`);
+        }
+    }
+    const healedSourceLocator = buildFreshLocator(healedSourceSelector);
+    if (targetSelectorFromSource) {
+        const tempTarget = buildFreshLocator(targetSelectorFromSource);
+        const isTargetVisible = await tempTarget
+            .isVisible({ timeout: 500 })
+            .catch(() => false);
+        if (!isTargetVisible) {
+            try {
+                const healedTargetSel = await singleton_1.sharedEngine.heal(rawPage, targetSelectorFromSource, targetSelectorFromSource, `${stableId}_target`, callerInfo.filePath, callerInfo.line);
+                if (healedTargetSel) {
+                    // broadcast already fired inside engine.heal() via ASTSourceUpdater
+                    healedTargetLocator = buildFreshLocator(healedTargetSel);
+                }
+            }
+            catch (e) {
+                logger_1.logger.warn(`Target healing failed: ${e.message}`);
+            }
+        }
+        else {
+            healedTargetLocator = tempTarget;
+        }
+    }
+    else {
+        const targetFromError = originalError.message?.match(/waiting for locator\('([^']+)'\)/)?.[1];
+        if (targetFromError && targetFromError !== fullSelector) {
+            const tempTarget = buildFreshLocator(targetFromError);
+            const isVisible = await tempTarget
+                .isVisible({ timeout: 500 })
+                .catch(() => false);
+            if (!isVisible) {
+                try {
+                    const healedSel = await singleton_1.sharedEngine.heal(rawPage, targetFromError, targetFromError, `${stableId}_target`, callerInfo.filePath, callerInfo.line);
+                    if (healedSel) {
+                        healedTargetLocator = buildFreshLocator(healedSel);
+                    }
+                }
+                catch (e) {
+                    if (e instanceof Error && e.message.includes("[SafetyGuard]"))
+                        throw e;
+                }
+            }
+            else {
+                healedTargetLocator = tempTarget;
+            }
+        }
+    }
+    const options = args[1] && typeof args[1] === "object" ? args[1] : {};
+    try {
+        const result = await healedSourceLocator.dragTo(healedTargetLocator, {
+            ...options,
+            timeout: 8000,
+        });
+        logger_1.logger.debug(`dragTo double heal successful`);
+        return {
+            result,
+            finalSelector: healedSourceSelector,
+            finalElementSelector: healedSourceSelector.split(" >> ").pop() ?? healedSourceSelector,
+        };
+    }
+    catch {
+        throw originalError;
+    }
+}
+// ─────────────────────────────────────────────────────────────────
+// createFrameLocatorProxy (identical to original)
+// ─────────────────────────────────────────────────────────────────
+function createFrameLocatorProxy(rawFrameLocator, frameSelector, rawPage, testTitle, actionCounter, parentChain) {
+    const fullFrameChain = parentChain
+        ? `${parentChain} >> ${frameSelector}`
+        : frameSelector;
+    return new Proxy(rawFrameLocator, {
+        get(fTarget, fProp) {
+            // Sela proxy identity - honor before the string-only fast path so
+            // symbol probes from tests / debuggers return the kind tag.
+            if (fProp === proxyTag_1.SELA_PROXY)
+                return "framelocator";
+            if (typeof fProp !== "string")
+                return Reflect.get(fTarget, fProp);
+            if (fProp === "frameLocator") {
+                return (innerFrameSel) => createFrameLocatorProxy(fTarget.frameLocator(innerFrameSel), innerFrameSel, rawPage, testTitle, actionCounter, fullFrameChain);
+            }
+            if (fProp === "locator") {
+                return (elementSel) => createLocatorProxy(fTarget.locator(elementSel), `${fullFrameChain} >> ${elementSel}`, rawPage, testTitle, actionCounter, elementSel);
+            }
+            return Reflect.get(fTarget, fProp);
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────
+// createLocatorProxy - Runtime Selector Injection added
+//
+// NEW additions vs original:
+//  1. Resolves selector through registry on creation (handles proxies
+//     born after a heal has already broadcast).
+//  2. Subscribes to registry so any future broadcast swaps
+//     activeLocator on the same tick - before the next await.
+//  3. Exposes _selaUnsubscribe so the fixture can clean up.
+// ─────────────────────────────────────────────────────────────────
+function createLocatorProxy(rawLocator, selector, rawPage, testTitle, actionCounter, elementSelectorOnly) {
+    // Defensive: Proxy ctor throws "Cannot create proxy with a non-object as target"
+    // when downstream callers (e.g. chained traps) pass a non-Locator return value.
+    // Returning the raw value lets the caller see it unchanged instead of crashing.
+    if (rawLocator === null ||
+        rawLocator === undefined ||
+        typeof rawLocator !== "object") {
+        return rawLocator;
+    }
+    // ── Resolve immediately (handles post-heal proxy creation) ────
+    const initialResolved = registry.resolveSelector(selector);
+    let currentFullSelector = initialResolved;
+    let currentElementSelector = elementSelectorOnly ?? initialResolved;
+    let activeLocator = initialResolved !== selector
+        ? buildLiveLocator(rawPage, initialResolved) // already healed
+        : rawLocator; // fresh, use as-is
+    // ── Subscribe: swap activeLocator when a heal fires ──────────
+    // Inside createLocatorProxy - full updated subscribe block
+    // בתוך createLocatorProxy - תחליף את הבלוק של ה-subscribe בזה:
+    const unsubscribe = registry.subscribe((fp, oldSel, newSel) => {
+        // בדיקה אם הסלקטור הנוכחי מכיל את הישן או שהוא הישן בעצמו
+        if (currentFullSelector !== oldSel &&
+            !currentFullSelector.includes(oldSel)) {
+            return;
+        }
+        let nextSelector;
+        // הגנה חדשה: אם התיקון החדש (newSel) הוא כבר סלקטור מלא ומשורשר (מכיל >>)
+        // ואנחנו נמצאים בתוך שרשרת Proxy, אנחנו לא רוצים לשרשר "זבל"
+        if (newSel.includes(" >> ") ||
+            newSel.startsWith(".") ||
+            newSel.startsWith("#")) {
+            // אם הישן היה חלק משרשרת מורכבת עם .filter, אנחנו מחליפים את כל השרשרת בתיקון הנקי
+            nextSelector = newSel;
+        }
+        else {
+            nextSelector = currentFullSelector.replace(oldSel, newSel);
+        }
+        if (nextSelector === currentFullSelector)
+            return;
+        logger_1.logger.debug(`proxy swap (Smart Clean): "${currentFullSelector}" → "${nextSelector}"`);
+        currentFullSelector = nextSelector;
+        currentElementSelector = nextSelector.split(" >> ").pop() ?? nextSelector;
+        // בנייה מחדש של הלוקטור האמיתי מהמחרוזת הנקייה
+        activeLocator = buildLiveLocator(rawPage, nextSelector);
+    });
+    const proxy = new Proxy(rawLocator, {
+        get(target, prop, receiver) {
+            // Sela proxy identity - must be honored before any string-only branch
+            // so callers can reliably detect a Sela proxy via Symbol.for("sela.proxy").
+            if (prop === proxyTag_1.SELA_PROXY)
+                return "locator";
+            if (typeof prop !== "string")
+                return Reflect.get(target, prop, receiver);
+            // ── Internal accessors ───────────────────────────────────
+            if (prop === "_selaSelector")
+                return currentFullSelector;
+            if (prop === "_selaPage")
+                return rawPage;
+            if (prop === "_selaTestTitle")
+                return testTitle;
+            if (prop === "_selaActionCounter")
+                return actionCounter;
+            if (prop === "_selaElementSelector")
+                return currentElementSelector;
+            if (prop === "_selaUnsubscribe")
+                return unsubscribe;
+            // ── getBy* ───────────────────────────────────────────────
+            if (prop in GET_BY_METHODS) {
+                return (...args) => {
+                    const nextLocator = activeLocator[prop](...args);
+                    if (nextLocator === null ||
+                        nextLocator === undefined ||
+                        typeof nextLocator !== "object") {
+                        return nextLocator;
+                    }
+                    const semanticSelector = GET_BY_METHODS[prop](args);
+                    const childFullSelector = `${currentFullSelector} >> ${semanticSelector}`;
+                    return createLocatorProxy(nextLocator, childFullSelector, rawPage, testTitle, actionCounter, semanticSelector);
+                };
+            }
+            // ── Chainable methods ────────────────────────────────────
+            const chainables = ["locator", "filter", "first", "last", "nth"];
+            if (chainables.includes(prop)) {
+                return (...args) => {
+                    const nextLocator = activeLocator[prop](...args);
+                    if (nextLocator === null ||
+                        nextLocator === undefined ||
+                        typeof nextLocator !== "object") {
+                        return nextLocator;
+                    }
+                    let nextFull = currentFullSelector;
+                    let nextElement = currentElementSelector;
+                    if (prop === "locator") {
+                        nextFull += ` >> ${args[0]}`;
+                        nextElement = args[0];
+                    }
+                    else if (prop === "filter") {
+                        const d = args[0]?.hasText
+                            ? `.filter(hasText:"${args[0].hasText}")`
+                            : `.filter(...)`;
+                        nextFull += d;
+                        nextElement += d;
+                    }
+                    else {
+                        const suffix = prop === "first"
+                            ? ":nth-match(1)"
+                            : prop === "last"
+                                ? ":last"
+                                : `:nth-match(${args[0] + 1})`;
+                        nextFull += suffix;
+                        nextElement += suffix;
+                    }
+                    return createLocatorProxy(nextLocator, nextFull, rawPage, testTitle, actionCounter, nextElement);
+                };
+            }
+            // ── Intercepted actions ──────────────────────────────────
+            if (INTERCEPTED_ACTIONS.includes(prop)) {
+                return async (...args) => {
+                    actionCounter.value++;
+                    const stableId = StackUtils_1.StackUtils.getActionKey(testTitle, prop, actionCounter.value);
+                    const callerInfo = StackUtils_1.StackUtils.getCallerInfo();
+                    singleton_1.sharedEngine.preloadTestTitle(stableId, testTitle);
+                    const { result, finalSelector, finalElementSelector } = await runWithHeal(rawPage, prop, args, currentFullSelector, currentElementSelector, stableId, callerInfo);
+                    // Post-action desync guard: if runWithHeal found a new selector
+                    // through engine.heal() and the registry listener fired during
+                    // that await, currentFullSelector is already updated. This
+                    // explicit assignment is a safety net for the rare race where
+                    // the listener callback and the return value disagree.
+                    if (finalSelector !== currentFullSelector) {
+                        currentFullSelector = finalSelector;
+                        currentElementSelector = finalElementSelector;
+                        activeLocator = buildLiveLocator(rawPage, finalSelector);
+                    }
+                    return result;
+                };
+            }
+            // ── Passive getters (silent heal on failure) ─────────────
+            const passiveGetters = [
+                "isVisible",
+                "isEnabled",
+                "isHidden",
+                "isChecked",
+                "innerText",
+                "innerHTML",
+                "textContent",
+                "inputValue",
+            ];
+            if (passiveGetters.includes(prop)) {
+                return async (...args) => {
+                    try {
+                        return await activeLocator[prop](...args);
+                    }
+                    catch {
+                        logger_1.logger.debug(`Silent heal for getter '${prop}'`);
+                        try {
+                            actionCounter.value++;
+                            const stableId = StackUtils_1.StackUtils.getActionKey(testTitle, prop, actionCounter.value);
+                            const callerInfo = StackUtils_1.StackUtils.getCallerInfo();
+                            singleton_1.sharedEngine.preloadTestTitle(stableId, testTitle);
+                            const { finalSelector } = await runWithHeal(rawPage, prop, args, currentFullSelector, currentElementSelector, stableId, callerInfo);
+                            if (finalSelector !== currentFullSelector) {
+                                currentFullSelector = finalSelector;
+                                activeLocator = buildLiveLocator(rawPage, finalSelector);
+                            }
+                            return await activeLocator[prop](...args);
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    }
+                };
+            }
+            // Reflect on activeLocator (not rawLocator) to stay current
+            return Reflect.get(activeLocator, prop, receiver);
+        },
+    });
+    proxyToActiveLocator.set(proxy, () => activeLocator);
+    return proxy;
+}
+// ─────────────────────────────────────────────────────────────────
+// test fixture - teardown added
+// ─────────────────────────────────────────────────────────────────
+// ─── expect - healing proxy replacing the plain baseExpect proxy ──────────────
+exports.test = test_1.test.extend({
+    // ── Worker-scoped flush anchor (auto) ───────────────────────────────
+    // Setup is a no-op; the teardown after `use()` is the suite-end flush.
+    // Aggregation spans the ENTIRE worker run because commitUpdates() is no
+    // longer called per test - the report buffer, registry heal-map, and
+    // workspace snapshot accumulate across all tests and flush once here.
+    _selaWorkerLifecycle: [
+        async ({}, use) => {
+            await use();
+            // Single suite-wide commit: saves DNA snapshots, flushes the Insights
+            // report + .sela-history.json ONCE, and writes the DX-review ledger
+            // with the full set of healed events from the whole worker run.
+            //
+            // SELA-10: the commit is a post-run side-effect (report/snapshot/ledger
+            // I/O), NEVER a correctness gate for the tests that already ran. A flush
+            // failure here must degrade gracefully - if it threw, Playwright would
+            // mark the entire worker errored and fail tests that genuinely passed.
+            // The reporter's onEnd() retries commitUpdates() as the crash safety net.
+            try {
+                await singleton_1.sharedEngine.commitUpdates();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger_1.logger.warn(`worker-teardown commitUpdates failed: ${msg}`);
+            }
+        },
+        { scope: "worker", auto: true },
+    ],
+    page: async ({ page }, use, testInfo) => {
+        page.on("console", (msg) => {
+            if (msg.text().includes("[DOM-EXTRACT]")) {
+                logger_1.logger.debug(`[Browser Console]: ${msg.text()}`);
+            }
+        });
+        const actionCounter = { value: 0 };
+        const rawPage = page;
+        const unsubscribers = [];
+        const pageProxy = new Proxy(page, {
+            get(target, prop) {
+                // Sela proxy identity - honored before any other branch so callers
+                // can reliably detect a Sela page proxy via Symbol.for("sela.proxy").
+                if (prop === proxyTag_1.SELA_PROXY)
+                    return "page";
+                if (prop === "_rawPage")
+                    return target;
+                if (typeof prop !== "string")
+                    return Reflect.get(target, prop, target);
+                if (prop === "locator") {
+                    return (selector) => {
+                        const p = createLocatorProxy(target.locator(selector), selector, rawPage, testInfo.title, actionCounter, selector);
+                        const u = p._selaUnsubscribe;
+                        if (u)
+                            unsubscribers.push(u);
+                        return p;
+                    };
+                }
+                if (prop === "frameLocator") {
+                    return (frameSel) => createFrameLocatorProxy(target.frameLocator(frameSel), frameSel, rawPage, testInfo.title, actionCounter, "");
+                }
+                if (prop in GET_BY_METHODS) {
+                    return (...args) => {
+                        const semanticSelector = GET_BY_METHODS[prop](args);
+                        const p = createLocatorProxy(target[prop](...args), semanticSelector, rawPage, testInfo.title, actionCounter, semanticSelector);
+                        const u = p._selaUnsubscribe;
+                        if (u)
+                            unsubscribers.push(u);
+                        return p;
+                    };
+                }
+                return Reflect.get(target, prop, target);
+            },
+        });
+        await use(pageProxy);
+        // ── Per-test teardown ─────────────────────────────────────────
+        // Release this test's proxy registry subscriptions and drop per-test
+        // listeners. We deliberately DO NOT call engine.commitUpdates() here -
+        // flushing per test is what produced the per-test report writes, the
+        // duplicated .sela-history.json entries (each "healed":1), and the
+        // last-test-only DX diff. The suite-wide flush lives in the
+        // worker-scoped `_selaWorkerLifecycle` teardown above.
+        for (const u of unsubscribers)
+            u();
+        registry.clearForTest();
+    },
+    expect: async ({ page }, use, testInfo) => {
+        const healingExpect = (0, expectProxy_1.createHealingExpect)(singleton_1.sharedEngine, page, testInfo.file, 0, 
+        // Inject proxy resolver - gives expectProxy.ts access to the live
+        // active Locator without exposing the WeakMap directly.
+        (value) => {
+            if (value && typeof value === "object") {
+                const getActive = proxyToActiveLocator.get(value);
+                if (getActive)
+                    return getActive();
+            }
+            return null;
+        });
+        await use(healingExpect);
+    },
+});
+// Re-export expect as a healing expect for bare import usage
+var expectProxy_2 = require("./expectProxy");
+Object.defineProperty(exports, "createHealingExpect", { enumerable: true, get: function () { return expectProxy_2.createHealingExpect; } });