sela-core 1.0.0

package/dist/engine/FixwrightEngine.js

@@ -0,0 +1,403 @@
+"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.FixwrightEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const LLMService_1 = require("../services/LLMService");
+const SnapshotService_1 = require("../services/SnapshotService");
+const DOMUtils_1 = require("../utils/DOMUtils");
+const SourceUpdater_1 = require("../services/SourceUpdater");
+const SafetyGuard_1 = require("../services/SafetyGuard");
+const ConfigLoader_1 = require("../config/ConfigLoader");
+class FixwrightEngine {
+    llmService;
+    snapshotService;
+    safetyGuard;
+    config;
+    dnaBuffer = new Map();
+    healMetaBuffer = new Map();
+    testTitleBuffer = new Map();
+    constructor() {
+        this.config = ConfigLoader_1.ConfigLoader.getInstance();
+        this.llmService = new LLMService_1.LLMService();
+        this.snapshotService = new SnapshotService_1.SnapshotService();
+        this.safetyGuard = new SafetyGuard_1.SafetyGuard(this.config.thresholds);
+    }
+    // ─────────────────────────────────────────────────────────────
+    // healArgument — repairs a wrong action argument (e.g. selectOption)
+    // ─────────────────────────────────────────────────────────────
+    async healArgument(page, selector, action, oldArgument, stableId, filePath, line) {
+        console.log(`[Fixwright] 🔧 HEALING ARGUMENT for action '${action}': "${oldArgument}"`);
+        try {
+            const { dom } = await DOMUtils_1.DOMUtils.getNeighborhoodDom(page, selector);
+            const neighborhoodDom = dom;
+            const targetIntent = action === "selectOption"
+                ? `ARGUMENT_HEALING: The selectOption argument "${oldArgument}" does not exist.
+Look at the <select> element in the DOM and find all <option> elements inside it.
+Return in 'new_selector' ONLY the TEXT CONTENT of the closest matching <option>.
+For example: if the options are "Male" and "Female" and the old argument was "Man", return "Male".
+CRITICAL: Do NOT return a CSS selector like "#my-select". Return plain text only, exactly as it appears in the option.`
+                : `Fix the broken argument "${oldArgument}" for action "${action}". Return the correct value.`;
+            const aiFix = await this.llmService.getFix({
+                targetIntent,
+                failedSelector: `${selector}::${action}("${oldArgument}")`,
+                previousState: {},
+                currentDom: neighborhoodDom,
+            });
+            if (aiFix?.status === "FIXED" && aiFix.new_selector) {
+                const newArgument = aiFix.new_selector;
+                console.log(`[Fixwright] 🔧 New argument: "${newArgument}"`);
+                SourceUpdater_1.SourceUpdater.updateArgument({ filePath, line }, action, oldArgument, newArgument);
+                return newArgument;
+            }
+        }
+        catch (error) {
+            console.error(`[Fixwright] ❌ Argument healing error:`, error.message);
+        }
+        return null;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // heal — repairs a broken selector
+    // ─────────────────────────────────────────────────────────────
+    async heal(page, fullSelector, elementSelectorOnly, stableId, filePath, line, healMode = "action") {
+        console.log(`\n[Fixwright] 🛠️  HEALING START for: ${stableId}`);
+        try {
+            // load() now always returns ElementSnapshotV2 (v1 snapshots are
+            // migrated transparently; v2 fields default to safe values).
+            const lastKnownState = await this.snapshotService.load(stableId);
+            // ── Extract v2 DNA context ────────────────────────────────
+            const dnaAncestry = lastKnownState?.ancestry ?? [];
+            const dnaAnchors = lastKnownState?.anchors;
+            console.log(`[Fixwright] 🔍 Step 2: Extracting neighborhood DOM...`);
+            const { dom: neighborhoodDom, successfulPath } = await DOMUtils_1.DOMUtils.getNeighborhoodDom(page, fullSelector);
+            if (!neighborhoodDom || neighborhoodDom.length === 0) {
+                throw new Error("Failed to extract any DOM context for AI");
+            }
+            console.log(`[Fixwright] 🔍 Step 2: DOM Extracted (${neighborhoodDom.length} chars) ✅`);
+            const contextHint = successfulPath.length > 0
+                ? `\n\n[CONTEXT HINT]: The provided DOM is extracted from INSIDE this frame path: "${successfulPath.join(" >> ")}". ` +
+                    `If you find the element, your suggested selector should be relative to THIS context.`
+                : "";
+            const oldText = lastKnownState?.text ?? null;
+            const dnaRole = lastKnownState?.role ?? undefined;
+            const intentDescription = lastKnownState
+                ? `The element that was a ${lastKnownState.tagName} with text "${lastKnownState.text}"`
+                : `Element identified by ${stableId}`;
+            const contentChangeInstructions = `
+
+[CONTENT CHANGE DETECTION]:
+If the element's VISIBLE TEXT has changed compared to its previous value${oldText ? ` ("${oldText}")` : ""}, you MUST include a "contentChange" field.
+NOTE: This change will NOT be applied automatically to the source code to prevent masking potential bugs.
+It will only be presented as a suggested fix in the terminal.
+{
+  "contentChange": {
+    "oldText": "<the previous visible text>",
+    "newText": "<the new visible text as it appears in the current DOM>"
+  }
+}
+This is required so that any expect(...).toHaveText("${oldText ?? "..."}") assertions in the test file can be automatically updated to match the new text.
+If the text has NOT changed, omit the "contentChange" field entirely.`;
+            // ── Semantic anchor context hint for the LLM ─────────────────────
+            // When DNA v2 anchor data exists, tell the AI which label and row
+            // key the element was associated with so it can use semantic landmarks
+            // to disambiguate identical controls (e.g. multiple "Edit" buttons).
+            const anchorContextHint = (() => {
+                const anchors = lastKnownState?.anchors;
+                if (!anchors)
+                    return "";
+                const lines = [];
+                if (anchors.closestLabel) {
+                    lines.push(`- Label: "${anchors.closestLabel}" — the UI label or heading associated with this element.`);
+                }
+                if (anchors.rowAnchor) {
+                    lines.push(`- Row key: "${anchors.rowAnchor}" — unique cell text identifying the table row this element belonged to.`);
+                }
+                if (lines.length === 0)
+                    return "";
+                return ("\n\n[ELEMENT SEMANTIC CONTEXT]:\n" +
+                    "The DNA snapshot recorded these semantic landmarks for the element you must find:\n" +
+                    lines.join("\n") +
+                    "\n" +
+                    "Prioritize selectors that preserve these relationships (e.g. filter by row key, then target by label).");
+            })();
+            console.log(`[Fixwright] 🔍 Step 3: Requesting AI fix from LLM...`);
+            const aiFix = await this.llmService.getFix({
+                targetIntent: intentDescription,
+                failedSelector: fullSelector,
+                previousState: lastKnownState || {},
+                currentDom: neighborhoodDom +
+                    contextHint +
+                    anchorContextHint +
+                    contentChangeInstructions,
+            });
+            if (aiFix && aiFix.status === "FIXED") {
+                console.log(`[Fixwright] 🔍 Step 3: AI responded ✅`);
+                // ── Build new selector ────────────────────────────────────
+                const aiSegments = aiFix.segments || [];
+                const newSegmentsFromAI = aiSegments.filter((aiSeg) => !successfulPath.includes(aiSeg.selector));
+                const newFullSelector = [
+                    ...successfulPath,
+                    ...newSegmentsFromAI.map((s) => s.selector),
+                ].join(" >> ");
+                const rawElementSelector = newSegmentsFromAI.map((s) => s.selector).join(" >> ") ||
+                    newFullSelector;
+                const framePrefix = successfulPath.join(" >> ");
+                const elementOnlySelector = framePrefix && rawElementSelector.startsWith(framePrefix + " >> ")
+                    ? rawElementSelector.slice(framePrefix.length + 4)
+                    : rawElementSelector;
+                // ── Step 3.5: Fetch live text (lightweight zero-trust probe) ─
+                const liveText = await this.fetchLiveText(page, elementOnlySelector, successfulPath);
+                const dnaBaselineText = oldText ?? undefined;
+                if (liveText !== null) {
+                    console.log(`[Fixwright] 🔍 Step 3.5: Live text fetched: "${liveText}"` +
+                        (dnaBaselineText ? ` (DNA baseline: "${dnaBaselineText}")` : ""));
+                }
+                else {
+                    console.log(`[Fixwright] 🔍 Step 3.5: Live text fetch skipped (element not yet rendered or non-text)`);
+                }
+                // ── Step 3.6: Atomic v2 capture of the candidate element ──
+                // Single page.evaluate() call — collects visibility, ancestry,
+                // and anchors of the healed element for SafetyGuard use.
+                // Returns null on any failure; never blocks the heal.
+                const liveSnapshot = await this.snapshotService.captureElement(page, elementOnlySelector, successfulPath);
+                const liveVisibility = liveSnapshot?.visibility;
+                const liveAncestry = liveSnapshot?.ancestry;
+                const liveAnchors = liveSnapshot?.anchors;
+                if (liveSnapshot) {
+                    const ghostFlag = liveVisibility?.isGhost
+                        ? ` 👻 GHOST(${liveVisibility.ghostReason})`
+                        : "";
+                    const occFlag = liveVisibility?.isOccluded ? " 🫥 OCCLUDED" : "";
+                    console.log(`[Fixwright] 🔍 Step 3.6: Live v2 capture complete` +
+                        `${ghostFlag}${occFlag} — ancestry depth: ${liveAncestry?.length ?? 0}`);
+                }
+                else {
+                    console.log(`[Fixwright] 🔍 Step 3.6: Live v2 capture skipped`);
+                }
+                // ── Safety: delegate all go/no-go decisions to SafetyGuard ─
+                const branch = ConfigLoader_1.ConfigLoader.getBranch() ?? undefined;
+                const safetyDecision = await this.safetyGuard.evaluate({ mode: healMode, branch }, {
+                    confidence: aiFix.confidence,
+                    contentChange: aiFix.contentChange,
+                    explanation: aiFix.explanation,
+                    liveText: liveText ?? undefined,
+                    dnaBaselineText,
+                    dnaRole,
+                    // v2 structural context
+                    liveVisibility,
+                    liveAncestry,
+                    liveAnchors,
+                    dnaAncestry,
+                    dnaAnchors,
+                });
+                console.log(`[SafetyGuard] ${safetyDecision.canProceed ? "✅" : "❌"} [${safetyDecision.level}] ${safetyDecision.reason}`);
+                if (!safetyDecision.canProceed) {
+                    if (safetyDecision.level === "BLOCKED" &&
+                        safetyDecision.meta?.auditorVerdict === "SUSPICIOUS") {
+                        const strictness = this.config.thresholds.auditorStrictness;
+                        const conf = safetyDecision.meta.auditorConfidence ?? "?";
+                        const suggestion = strictness === "strict" ? "Balanced" : "Loose";
+                        console.warn(`[Sela] ⚠️  Auditor status: SUSPICIOUS (Confidence: ${conf}%)`);
+                        console.warn(`[Sela] 🚫 Policy: '${strictness}' (Branch: ${branch ?? "unknown"}). Auto-fix blocked.`);
+                        console.warn(`[Sela] 💡 To allow this, change 'auditorStrictness' to '${suggestion}' in sela.config.ts.`);
+                    }
+                    throw new Error(`[SafetyGuard] ${safetyDecision.level}: ${safetyDecision.reason}`);
+                }
+                // ── Heal-completion score summary ─────────────────────────────────
+                // Emits a single consolidated line showing AI confidence plus the
+                // auditor's structural adjustments (ancestry drift / anchor bonus).
+                const breakdown = safetyDecision.meta?.auditScoreBreakdown;
+                if (breakdown && (breakdown.penalty !== 0 || breakdown.bonus !== 0)) {
+                    const parts = [];
+                    if (breakdown.penalty !== 0)
+                        parts.push(`${breakdown.penalty} ancestry drift`);
+                    if (breakdown.bonus !== 0)
+                        parts.push(`+${breakdown.bonus} anchor match`);
+                    console.log(`[Fixwright] 📊 Score — AI: ${aiFix.confidence}% | ` +
+                        `Auditor: ${breakdown.adjustedConfidence}% ` +
+                        `(raw ${breakdown.rawConfidence}%, ${parts.join(", ")})`);
+                }
+                console.log(`[Fixwright] 🚀 Rebuilt Full Runtime Selector (Clean): ${newFullSelector}`);
+                const updateResult = SourceUpdater_1.SourceUpdater.update({ filePath, line }, elementSelectorOnly, newFullSelector, neighborhoodDom, undefined, fullSelector, aiFix.segments, aiFix.contentChange, aiFix.chainSegments, aiFix.originalChainHint, this.config.updateStrategy, this.config.autoCommit);
+                const canonicalSelector = updateResult.healedLocatorString ?? newFullSelector;
+                console.log(`[Fixwright] ✅ Canonical selector (disk == runtime): "${canonicalSelector}"`);
+                // Buffer CLI-ready metadata — merged into DNA at commitUpdates() time.
+                // Sanitize filePath: strip any residual "at " stack-trace prefix + whitespace,
+                // then resolve to an absolute path before converting to project-relative form.
+                const match = filePath.match(/at\s+(.*)/i);
+                // 2. אם מצאנו התאמה ניקח אותה, אחרת ניקח את המחרוזת המקורית.
+                // בנוסף, ננקה רווחים וסוגריים (לפעמים נתיבים ב-Stack trace מוקפים בסוגריים).
+                const cleanFilePath = (match ? match[1] : filePath)
+                    .replace(/^\(|\)$/g, "") // מסיר סוגריים אם קיימים ( )
+                    .trim();
+                // 3. הפיכה לנתיב אבסולוטי ואז ליחסי (כמו שעשית, שזה מעולה)
+                const absFilePath = cleanFilePath && path.isAbsolute(cleanFilePath)
+                    ? cleanFilePath
+                    : cleanFilePath
+                        ? path.resolve(process.cwd(), cleanFilePath)
+                        : "";
+                const relativeSourceFile = absFilePath
+                    ? path.relative(process.cwd(), absFilePath)
+                    : "";
+                this.healMetaBuffer.set(stableId, {
+                    selector: canonicalSelector,
+                    sourceFile: relativeSourceFile,
+                    sourceLine: line,
+                    originalSelector: elementSelectorOnly,
+                    healedSelector: canonicalSelector,
+                    lastHealed: new Date().toISOString(),
+                    status: "healed",
+                    definitionSite: updateResult.definitionSite,
+                    blastRadius: updateResult.blastRadius,
+                });
+                return canonicalSelector;
+            }
+            throw new Error("AI could not provide a fix");
+        }
+        catch (error) {
+            console.error(`[Fixwright] ❌ Healing Failure:`, error.message);
+            throw error;
+        }
+    }
+    preloadTestTitle(stableId, testTitle) {
+        this.testTitleBuffer.set(stableId, testTitle);
+    }
+    async saveSnapshot(stableId, data) {
+        this.dnaBuffer.set(stableId, data);
+    }
+    async commitUpdates() {
+        if (this.dnaBuffer.size === 0)
+            return;
+        for (const [key, dna] of this.dnaBuffer.entries()) {
+            const meta = this.healMetaBuffer.get(key);
+            const toSave = meta ? { ...dna, ...meta } : dna;
+            await this.snapshotService.save(key, toSave);
+        }
+        this.dnaBuffer.clear();
+        this.healMetaBuffer.clear();
+        this.testTitleBuffer.clear();
+        SourceUpdater_1.SourceUpdater.flushAdvisories();
+    }
+    // ─────────────────────────────────────────────────────────────
+    // fetchLiveText — frame-aware innerText fetch (zero-trust probe)
+    //
+    // Navigates the frame chain encoded in successfulPath, then calls
+    // .first().innerText() on the element-only selector.  Uses a short
+    // 1.5 s timeout so it never adds meaningful latency.  Returns null
+    // on ANY failure — the caller must treat null as "no data" and skip
+    // live verification rather than blocking the heal.
+    // ─────────────────────────────────────────────────────────────
+    async fetchLiveText(page, elementOnlySelector, framePath) {
+        try {
+            let ctx = page;
+            for (const frameSel of framePath) {
+                ctx = ctx.frameLocator(frameSel);
+            }
+            const text = await ctx
+                .locator(elementOnlySelector)
+                .first()
+                .innerText({ timeout: 1500 });
+            return text.trim().length > 0 ? text.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    _rebuildSelectorWithFrames(fullSelector, elementSelectorOnly, aiNewSelector) {
+        const fullParts = fullSelector.split(" >> ").map((s) => s.trim());
+        const elementParts = elementSelectorOnly.split(" >> ").map((s) => s.trim());
+        const aiParts = aiNewSelector.split(" >> ").map((s) => s.trim());
+        const frameParts = fullParts.slice(0, fullParts.length - elementParts.length);
+        if (frameParts.length === 0)
+            return aiNewSelector;
+        const aiHasFrameSegments = aiParts.some((p) => p.includes("-frame") ||
+            p === "iframe" ||
+            p === "frame" ||
+            p.includes("frame-"));
+        if (aiHasFrameSegments) {
+            console.log(`[Fixwright] 🔗 AI returned full frame path — using directly: ${aiNewSelector}`);
+            return aiNewSelector;
+        }
+        return [...frameParts, ...aiParts].join(" >> ");
+    }
+    getAllFiles(dirPath, arrayOfFiles = []) {
+        const files = fs.readdirSync(dirPath);
+        const ignoreList = [
+            "node_modules",
+            ".git",
+            "fixwright-snapshots",
+            "dist",
+            "test-results",
+            "tests/reset-demo.ts",
+        ];
+        files.forEach((file) => {
+            const fullPath = path.join(dirPath, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+                if (!ignoreList.includes(file))
+                    this.getAllFiles(fullPath, arrayOfFiles);
+            }
+            else if (file.endsWith(".ts") || file.endsWith(".js")) {
+                arrayOfFiles.push(fullPath);
+            }
+        });
+        return arrayOfFiles;
+    }
+    // ─────────────────────────────────────────────────────────────
+    // captureSuccessfulElement — capture and buffer a v2 DNA snapshot.
+    //
+    // Replaces the previous DOMUtils.getElementDNA() path with a single
+    // captureElement() call that collects all v2 metrics atomically.
+    // ─────────────────────────────────────────────────────────────
+    async captureSuccessfulElement(page, selector, stableId) {
+        try {
+            const snapshot = await this.snapshotService.captureElement(page, selector);
+            if (snapshot) {
+                const testTitle = this.testTitleBuffer.get(stableId);
+                const enriched = {
+                    ...snapshot,
+                    selector,
+                    ...(testTitle ? { testTitle } : {}),
+                };
+                this.dnaBuffer.set(stableId, enriched);
+                console.log(`[Fixwright] 🧬 DNA v2 captured for: ${stableId}`);
+            }
+        }
+        catch (error) {
+            console.debug(`[Fixwright] 🧬 DNA capture skipped: ${error.message}`);
+        }
+    }
+}
+exports.FixwrightEngine = FixwrightEngine;

package/dist/engine/HealingRegistry.d.ts

@@ -0,0 +1,40 @@
+type HealListener = (fingerprint: string, oldSelector: string, newSelector: string) => void;
+export interface SelectorContext {
+    filePath: string;
+    line: number;
+    /** Ordered parent selectors above this call, e.g. ["#outer-frame", ".user-item"] */
+    parentChain?: string[];
+}
+export declare class HealingRegistry {
+    private static instance;
+    private readonly listeners;
+    /**
+     * Two-level store:
+     *   fingerprint → (oldSelector → newSelector)
+     *
+     * A fingerprint is deterministic per call-site, so heals from one test
+     * can NEVER overwrite a different call-site's mapping, even if the raw
+     * selector string is identical (e.g. "internal:role=button").
+     */
+    private readonly healMap;
+    private constructor();
+    static getInstance(): HealingRegistry;
+    static fingerprint(ctx: SelectorContext): string;
+    broadcast(ctx: SelectorContext, oldSelector: string, newSelector: string): void;
+    broadcastCascade(ctx: SelectorContext, pairs: Array<{
+        oldSelector: string;
+        newSelector: string;
+    }>): void;
+    subscribe(listener: HealListener): () => void;
+    /**
+     * Resolve a selector within a specific call-site context.
+     * Falls back to a context-free lookup ONLY when the fingerprint
+     * has no entry — prevents poisoning while still enabling same-file reuse.
+     */
+    resolveSelector(selector: string, ctx?: SelectorContext): string;
+    private walkChain;
+    clearForTest(): void;
+    clearAll(): void;
+}
+export {};
+//# sourceMappingURL=HealingRegistry.d.ts.map

package/dist/engine/HealingRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HealingRegistry.d.ts","sourceRoot":"","sources":["../../src/engine/HealingRegistry.ts"],"names":[],"mappings":"AAIA,KAAK,YAAY,GAAG,CAClB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,KAChB,IAAI,CAAC;AAEV,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,oFAAoF;IACpF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAkB;IAEzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IAErD;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAElE,OAAO;IAEP,MAAM,CAAC,WAAW,IAAI,eAAe;IASrC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM;IAUhD,SAAS,CACP,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,IAAI;IAqBP,gBAAgB,CACd,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,GACzD,IAAI;IAQP,SAAS,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,IAAI;IAK7C;;;;OAIG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,MAAM;IAYhE,OAAO,CAAC,SAAS;IAWjB,YAAY,IAAI,IAAI;IAMpB,QAAQ,IAAI,IAAI;CAIjB"}

package/dist/engine/HealingRegistry.js

@@ -0,0 +1,98 @@
+"use strict";
+// src/engine/HealingRegistry.ts — full replacement
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealingRegistry = void 0;
+const crypto_1 = require("crypto");
+class HealingRegistry {
+    static instance;
+    listeners = new Set();
+    /**
+     * Two-level store:
+     *   fingerprint → (oldSelector → newSelector)
+     *
+     * A fingerprint is deterministic per call-site, so heals from one test
+     * can NEVER overwrite a different call-site's mapping, even if the raw
+     * selector string is identical (e.g. "internal:role=button").
+     */
+    healMap = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!HealingRegistry.instance) {
+            HealingRegistry.instance = new HealingRegistry();
+        }
+        return HealingRegistry.instance;
+    }
+    // ── Fingerprint generation ───────────────────────────────────
+    static fingerprint(ctx) {
+        const chain = (ctx.parentChain ?? []).join("||");
+        return (0, crypto_1.createHash)("sha1")
+            .update(`${ctx.filePath}:${ctx.line}:${chain}`)
+            .digest("hex")
+            .slice(0, 16);
+    }
+    // ── Write side ───────────────────────────────────────────────
+    broadcast(ctx, oldSelector, newSelector) {
+        if (!oldSelector || !newSelector || oldSelector === newSelector)
+            return;
+        const fp = HealingRegistry.fingerprint(ctx);
+        if (!this.healMap.has(fp)) {
+            this.healMap.set(fp, new Map());
+        }
+        this.healMap.get(fp).set(oldSelector, newSelector);
+        console.log(`[HealingRegistry] 📡 [${fp}] "${oldSelector}" → "${newSelector}"`);
+        for (const listener of this.listeners) {
+            try {
+                listener(fp, oldSelector, newSelector);
+            }
+            catch { }
+        }
+    }
+    broadcastCascade(ctx, pairs) {
+        for (const { oldSelector, newSelector } of pairs) {
+            this.broadcast(ctx, oldSelector, newSelector);
+        }
+    }
+    // ── Read side ────────────────────────────────────────────────
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * Resolve a selector within a specific call-site context.
+     * Falls back to a context-free lookup ONLY when the fingerprint
+     * has no entry — prevents poisoning while still enabling same-file reuse.
+     */
+    resolveSelector(selector, ctx) {
+        if (ctx) {
+            const fp = HealingRegistry.fingerprint(ctx);
+            const fpMap = this.healMap.get(fp);
+            if (fpMap) {
+                const resolved = this.walkChain(selector, fpMap);
+                if (resolved !== selector)
+                    return resolved;
+            }
+        }
+        return selector; // No global fallback — intentional
+    }
+    walkChain(selector, store) {
+        let current = selector;
+        const visited = new Set();
+        while (store.has(current)) {
+            if (visited.has(current))
+                break;
+            visited.add(current);
+            current = store.get(current);
+        }
+        return current;
+    }
+    clearForTest() {
+        this.listeners.clear();
+        // Intentionally preserve healMap so intra-worker test N+1 can reuse heals
+        // from test N at the SAME call-site fingerprint (file + line match).
+    }
+    clearAll() {
+        this.listeners.clear();
+        this.healMap.clear();
+    }
+}
+exports.HealingRegistry = HealingRegistry;

package/dist/engine/singleton.d.ts

@@ -0,0 +1,3 @@
+import { FixwrightEngine } from './FixwrightEngine.js';
+export declare const sharedEngine: FixwrightEngine;
+//# sourceMappingURL=singleton.d.ts.map

package/dist/engine/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../../src/engine/singleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,eAAO,MAAM,YAAY,iBAAwB,CAAC"}

package/dist/engine/singleton.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sharedEngine = void 0;
+const FixwrightEngine_js_1 = require("./FixwrightEngine.js");
+exports.sharedEngine = new FixwrightEngine_js_1.FixwrightEngine();

package/dist/fixtures/expectProxy.d.ts

@@ -0,0 +1,12 @@
+import { Locator } from "@playwright/test";
+import { FixwrightEngine } from "../engine/FixwrightEngine";
+/**
+ * createHealingExpect — drop-in replacement for Playwright's expect().
+ *
+ * @param resolveProxy  Optional callback that unwraps a Fixwright proxy
+ * to its current live Locator. Supplied by
+ * fixtures/index.ts which owns proxyToActiveLocator.
+ */
+export declare function createHealingExpect(engine: FixwrightEngine, page: import("@playwright/test").Page, filePath: string, initialLine: number, // השורה מהפיקסצ'ר (לרוב תהיה לא מדויקת או 0)
+resolveProxy?: (value: unknown) => Locator | null): (locatorOrValue: unknown) => any;
+//# sourceMappingURL=expectProxy.d.ts.map

package/dist/fixtures/expectProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectProxy.d.ts","sourceRoot":"","sources":["../../src/fixtures/expectProxy.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,OAAO,EAER,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AA2N5D;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,OAAO,kBAAkB,EAAE,IAAI,EACrC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EAAE,6CAA6C;AAClE,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAChD,CAAC,cAAc,EAAE,OAAO,KAAK,GAAG,CA2DlC"}