sela-core 0.1.0-alpha.40 → 0.1.0-alpha.42

package/dist/boot/bootImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootImpl.d.ts","sourceRoot":"","sources":["../../src/boot/bootImpl.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,MAAM,CAAC;IAClD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;IAC9B,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB;AAKD,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAMlE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAUzD;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,CAKzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAkC7C"}
+{"version":3,"file":"bootImpl.d.ts","sourceRoot":"","sources":["../../src/boot/bootImpl.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,MAAM,CAAC;IAClD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;IAC9B,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;IACvB,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB;AAKD,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAMlE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAUzD;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,CAKzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAuC7C"}

package/dist/boot/bootImpl.js

@@ -39,6 +39,10 @@ function bootImpl(deps) {
     const manifestPath = deps.env['SELA_REGRESSION_MANIFEST']
         ? deps.env['SELA_REGRESSION_MANIFEST']
         : `${deps.cwd()}/.sela/sela-regression-manifest.json`;
+    // Expose the resolved path so worker processes (and the fixture's
+    // regressionInjector) can discover the manifest without requiring
+    // SELA_REGRESSION_MANIFEST to be set explicitly by the user.
+    deps.env['SELA_REGRESSION_MANIFEST'] = manifestPath;
     let manifest;
     try {
         manifest = JSON.parse(deps.readFileSync(manifestPath, 'utf-8'));

package/dist/config/ConfigLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigLoader.d.ts","sourceRoot":"","sources":["../../src/config/ConfigLoader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAiB,MAAM,cAAc,CAAC;AAiNzE,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA+B;IACtD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAuB;IAK5C,OAAO,CAAC,MAAM,CAAC,aAAa,CAA2B;IAEvD;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,IAAI,cAAc;IAqCpC;;;;OAIG;IACH,MAAM,CAAC,YAAY,IAAI,UAAU;IAKjC,OAAO,CAAC,MAAM,CAAC,aAAa;IAsB5B,yEAAyE;IACzE,MAAM,CAAC,SAAS,IAAI,MAAM,GAAG,IAAI;IAKjC,uDAAuD;IACvD,MAAM,CAAC,KAAK,IAAI,IAAI;CAKrB"}
+{"version":3,"file":"ConfigLoader.d.ts","sourceRoot":"","sources":["../../src/config/ConfigLoader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAiB,MAAM,cAAc,CAAC;AAqOzE,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA+B;IACtD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAuB;IAK5C,OAAO,CAAC,MAAM,CAAC,aAAa,CAA2B;IAEvD;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,IAAI,cAAc;IAqCpC;;;;OAIG;IACH,MAAM,CAAC,YAAY,IAAI,UAAU;IAKjC,OAAO,CAAC,MAAM,CAAC,aAAa;IAsB5B,yEAAyE;IACzE,MAAM,CAAC,SAAS,IAAI,MAAM,GAAG,IAAI;IAKjC,uDAAuD;IACvD,MAAM,CAAC,KAAK,IAAI,IAAI;CAKrB"}

package/dist/config/ConfigLoader.js

@@ -170,23 +170,43 @@ function loadRawConfig(configPath) {
     }
     // Every attempt failed. Two cases:
     //
-    // 1. The only candidate was a .ts file and the error looks like a missing
-    //    TypeScript loader (e.g. "Cannot find module" for a .ts import, or
-    //    "Unknown file extension .ts"). The CLI runs in plain Node.js — no tsx/
-    //    ts-node — so the config simply cannot be loaded here. Gracefully fall
-    //    back to defaults rather than crashing a CLI command that doesn't need
-    //    the config (e.g. `sela shadow-regression`).
+    // 1. The config cannot be loaded due to a missing or incompatible TypeScript
+    //    loader. This covers several scenarios that all stem from the same root
+    //    cause — the Node.js process has no way to execute .ts (or compiled ESM
+    //    .js) in the current environment:
+    //      • ERR_UNKNOWN_FILE_EXTENSION / "Unknown file extension .ts" — plain
+    //        Node.js sees the .ts extension with no registered loader.
+    //      • "Cannot use import statement outside a module" — the config (or its
+    //        compiled .js sibling) uses ESM `import` syntax but Node.js is
+    //        running in CJS mode and cannot load it with require(). Happens when
+    //        a compiled sela.config.js uses top-level `import`, or when Node 20
+    //        --experimental-strip-types strips .ts annotations but the project
+    //        is CJS.
+    //      • ERR_REQUIRE_ESM / "require() of ES Module" — Node.js detected the
+    //        file is an ES module and refused the synchronous require() call.
+    //    All of these are environment/loader mismatches, not config content bugs.
+    //    Gracefully fall back to defaults so the CLI command (e.g.
+    //    `sela shadow-regression`) still runs rather than crashing.
     //
     // 2. Genuine config error (syntax, key validation, etc.) → hard throw so CI
     //    surfaces the problem instead of silently running on stale defaults.
     const msg = lastError?.message ?? "";
-    const isNoTsLoader = configPath.endsWith(".ts") &&
-        (msg.includes("Cannot find module") ||
+    const code = lastError?.code ?? "";
+    const isLoaderEnvError = configPath.endsWith(".ts") &&
+        (code === "ERR_UNKNOWN_FILE_EXTENSION" ||
+            code === "ERR_REQUIRE_ESM" ||
+            msg.includes("Cannot find module") ||
             msg.includes("Unknown file extension") ||
-            msg.includes("ERR_UNKNOWN_FILE_EXTENSION"));
-    if (isNoTsLoader) {
-        logger_1.logger.warn(`[Sela] sela.config.ts found but no TypeScript loader is active — running on defaults. ` +
-            `If you need config values in the CLI, add a compiled sela.config.js alongside it.`);
+            msg.includes("ERR_UNKNOWN_FILE_EXTENSION") ||
+            msg.includes("Cannot use import statement outside a module") ||
+            msg.includes("require() of ES Module") ||
+            msg.includes("ERR_REQUIRE_ESM"));
+    if (isLoaderEnvError) {
+        logger_1.logger.warn(`[Sela] sela.config.ts found but cannot be loaded in this Node.js context ` +
+            `(no TypeScript loader active, or the compiled .js output uses ESM syntax ` +
+            `incompatible with require()). Running on defaults. ` +
+            `To use config values in the CLI, compile sela.config.ts to CJS ` +
+            `(e.g. tsc --module commonjs) or set SELA_CONFIG_PATH to the compiled file.`);
         return {};
     }
     throw new Error(`[Sela] Failed to load ${path.basename(configPath)}: ${msg || "unknown error"}. ` +

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

@@ -1 +1 @@
-{"version":3,"file":"SelaEngine.d.ts","sourceRoot":"","sources":["../../src/engine/SelaEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAcxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EAAe,QAAQ,EAAkB,MAAM,yBAAyB,CAAC;AA6GhF,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,eAAe,CAAkC;IAKzD,OAAO,CAAC,qBAAqB,CAAkC;IAK/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;;IAyCnD,YAAY,CAChB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqEnB,IAAI,CACR,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC;IAylClB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,aAAa;IAerB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,2BAA2B;IA4BnC,OAAO,CAAC,yBAAyB;IAgDjC,OAAO,CAAC,kBAAkB;IA8D1B,OAAO,CAAC,oBAAoB;IAyD5B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK/B,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;YAsJtB,aAAa;IAsB3B,OAAO,CAAC,0BAA0B;IA+BlC,OAAO,CAAC,WAAW;IA6Bb,wBAAwB,CAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM;IAkErB,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAWpC;AAED,OAAO,EAAE,CAAC"}
+{"version":3,"file":"SelaEngine.d.ts","sourceRoot":"","sources":["../../src/engine/SelaEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAcxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,OAAO,EAAe,QAAQ,EAAkB,MAAM,yBAAyB,CAAC;AA6GhF,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,oBAAoB,CAAuB;IACnD,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAA6C;IAC9D,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,eAAe,CAAkC;IAKzD,OAAO,CAAC,qBAAqB,CAAkC;IAK/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;;IAyCnD,YAAY,CAChB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAqEnB,IAAI,CACR,IAAI,EAAE,IAAI,EACV,YAAY,EAAE,MAAM,EACpB,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,MAAM,CAAC;IAkmClB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,aAAa;IAerB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,2BAA2B;IA4BnC,OAAO,CAAC,yBAAyB;IAgDjC,OAAO,CAAC,kBAAkB;IA8D1B,OAAO,CAAC,oBAAoB;IAyD5B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAIrD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAK/B,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;YAsJtB,aAAa;IAsB3B,OAAO,CAAC,0BAA0B;IA+BlC,OAAO,CAAC,WAAW;IA6Bb,wBAAwB,CAC5B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM;IAkErB,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAWpC;AAED,OAAO,EAAE,CAAC"}

package/dist/engine/SelaEngine.js

@@ -522,20 +522,30 @@ If the text has NOT changed, omit the "contentChange" field entirely.`;
                 // attached to the HealedEvent below and, on success, stored in the
                 // DNA record so subsequent heals can show the previous baseline.
                 const _vsKey = (0, VisualSnapshotService_1.snapshotKey)(filePath, stableId);
-                const _vsLiveDest = (0, VisualSnapshotService_1.liveSnapshotPath)(process.cwd(), _vsKey);
+                const _vsCandDest = (0, VisualSnapshotService_1.candidateSnapshotPath)(process.cwd(), _vsKey);
                 let _vsCapture = { elementFound: false, capturedAt: null };
                 let _vsLiveRelPath = null;
                 let _vsDnaRelPath = null;
                 let _vsDnaCapturedAt = null;
                 try {
-                    _vsCapture = await (0, VisualSnapshotService_1.captureElementScreenshot)(page, elementOnlySelector, successfulPath, _vsLiveDest);
+                    _vsCapture = await (0, VisualSnapshotService_1.captureElementScreenshot)(page, elementOnlySelector, successfulPath, _vsCandDest);
                     if (_vsCapture.elementFound) {
-                        _vsLiveRelPath = path.relative(process.cwd(), _vsLiveDest).replace(/\\/g, "/");
-                    }
-                    const _dnaAbsPath = (0, VisualSnapshotService_1.dnaSnapshotPath)(process.cwd(), _vsKey);
-                    if (fs.existsSync(_dnaAbsPath)) {
-                        _vsDnaRelPath = path.relative(process.cwd(), _dnaAbsPath).replace(/\\/g, "/");
-                        _vsDnaCapturedAt = lastKnownState?.visualSnapshot?.capturedAt ?? null;
+                        const _baselineAbsPath = (0, VisualSnapshotService_1.baselineSnapshotPath)(process.cwd(), _vsKey);
+                        if (isCiEnvironment()) {
+                            // CI: keep candidate alongside baseline so the report shows before/after.
+                            _vsLiveRelPath = path.relative(process.cwd(), _vsCandDest).replace(/\\/g, "/");
+                            if (fs.existsSync(_baselineAbsPath)) {
+                                _vsDnaRelPath = path.relative(process.cwd(), _baselineAbsPath).replace(/\\/g, "/");
+                                _vsDnaCapturedAt = lastKnownState?.visualSnapshot?.capturedAt ?? null;
+                            }
+                        }
+                        else {
+                            // Local: immediately overwrite baseline → only 1 file ever exists.
+                            (0, VisualSnapshotService_1.promoteCandidateToBaseline)(process.cwd(), _vsKey);
+                            _vsLiveRelPath = path.relative(process.cwd(), _baselineAbsPath).replace(/\\/g, "/");
+                            // Before-image is gone (overwritten); suppress the before slot.
+                            _vsDnaRelPath = null;
+                        }
                     }
                 }
                 catch {
@@ -961,7 +971,7 @@ If the text has NOT changed, omit the "contentChange" field entirely.`;
                     visualSnapshot: _vsCapture.elementFound && _vsCapture.capturedAt
                         ? {
                             path: path
-                                .relative(process.cwd(), (0, VisualSnapshotService_1.dnaSnapshotPath)(process.cwd(), _vsKey))
+                                .relative(process.cwd(), (0, VisualSnapshotService_1.baselineSnapshotPath)(process.cwd(), _vsKey))
                                 .replace(/\\/g, "/"),
                             capturedAt: _vsCapture.capturedAt,
                         }
@@ -1527,15 +1537,15 @@ If the text has NOT changed, omit the "contentChange" field entirely.`;
                 this.dnaBuffer.set(stableId, enriched);
                 logger_1.logger.debug(`DNA v2 captured for: ${stableId}`);
                 // ── Visual baseline capture (guarded) ─────────────────────
-                // Capture a PNG baseline ONLY if the file is missing (first run)
-                // or the DOM snapshot changed (manual edit / UI shift). Skipping
-                // on unchanged steady-state runs avoids screenshot overhead in CI.
-                if (sourceFile) {
+                // Local only: capture a PNG baseline when the file is missing or the
+                // DOM snapshot changed.  CI is read-only — baselines are committed
+                // from local dev and must not be regenerated during CI test runs.
+                if (sourceFile && !isCiEnvironment()) {
                     try {
                         const vsKey = (0, VisualSnapshotService_1.snapshotKey)(sourceFile, stableId);
-                        const dnaDest = (0, VisualSnapshotService_1.dnaSnapshotPath)(process.cwd(), vsKey);
-                        const dnaStat = fs.existsSync(dnaDest) ? fs.statSync(dnaDest) : null;
-                        const pngMissing = !dnaStat || dnaStat.size === 0;
+                        const baseDest = (0, VisualSnapshotService_1.baselineSnapshotPath)(process.cwd(), vsKey);
+                        const baseStat = fs.existsSync(baseDest) ? fs.statSync(baseDest) : null;
+                        const pngMissing = !baseStat || baseStat.size === 0;
                         let needsCapture = pngMissing;
                         if (!pngMissing) {
                             // load() reads from disk — commitUpdates() hasn't run yet,
@@ -1547,10 +1557,10 @@ If the text has NOT changed, omit the "contentChange" field entirely.`;
                                         SelaEngine._snapshotFingerprint(enriched);
                         }
                         if (needsCapture) {
-                            const liveDest = (0, VisualSnapshotService_1.liveSnapshotPath)(process.cwd(), vsKey);
-                            const result = await (0, VisualSnapshotService_1.captureElementScreenshot)(page, selector, [], liveDest);
+                            const candDest = (0, VisualSnapshotService_1.candidateSnapshotPath)(process.cwd(), vsKey);
+                            const result = await (0, VisualSnapshotService_1.captureElementScreenshot)(page, selector, [], candDest);
                             if (result.elementFound) {
-                                (0, VisualSnapshotService_1.promoteLiveToBaseline)(process.cwd(), vsKey);
+                                (0, VisualSnapshotService_1.promoteCandidateToBaseline)(process.cwd(), vsKey);
                                 logger_1.logger.debug(`Visual baseline ${pngMissing ? "created" : "refreshed"}: ${vsKey}`);
                             }
                         }

package/dist/fixtures/expectProxy.d.ts

@@ -1,12 +1,36 @@
-import { Locator } from "@playwright/test";
+import { expect as playwrightExpect, Locator } from "@playwright/test";
 import { SelaEngine } from "../engine/SelaEngine";
+import { SelectorContext } from "../engine/HealingRegistry";
+type PlaywrightExpect = typeof playwrightExpect;
 /**
- * createHealingExpect - drop-in replacement for Playwright's expect().
+ * Resolution returned for each `expect(value)` call: the page the value lives
+ * on (or null when there is none / it is not a locator), the heal context
+ * (file + line), and the unwrapped live Locator behind a Sela proxy (if any).
+ */
+export interface ExpectResolution {
+    page: import("@playwright/test").Page | null;
+    ctx: SelectorContext;
+    locator: Locator | null;
+}
+export type ExpectResolver = (value: unknown) => ExpectResolution;
+/**
+ * The unified healing-expect factory. Returns a Proxy whose target is the real
+ * Playwright `expect` (or a `configure()`-d variant), so it is structurally
+ * indistinguishable from Playwright's `Expect` — same call signature, same
+ * static surface — with healing layered on locator matchers.
+ */
+export declare function makeHealingExpect(engine: SelaEngine, resolve: ExpectResolver, baseExpect?: PlaywrightExpect): PlaywrightExpect;
+/**
+ * createHealingExpect - fixture-scoped healing expect.
+ *
+ * Page and file are fixed (from the test fixture); the source line is resolved
+ * per call from the stack. `resolveProxy` unwraps a Sela locator proxy to its
+ * current live Locator (supplied by fixtures/index.ts which owns
+ * proxyToActiveLocator).
  *
- * @param resolveProxy  Optional callback that unwraps a Sela proxy
- * to its current live Locator. Supplied by
- * fixtures/index.ts which owns proxyToActiveLocator.
+ * Signature preserved for backward compatibility; internally delegates to the
+ * unified makeHealingExpect so the export is full Playwright `Expect` parity.
  */
-export declare function createHealingExpect(engine: SelaEngine, page: import("@playwright/test").Page, filePath: string, initialLine: number, // השורה מהפיקסצ'ר (לרוב תהיה לא מדויקת או 0)
-resolveProxy?: (value: unknown) => Locator | null): (locatorOrValue: unknown) => any;
+export declare function createHealingExpect(engine: SelaEngine, page: import("@playwright/test").Page, filePath: string, initialLine: number, resolveProxy?: (value: unknown) => Locator | null): PlaywrightExpect;
+export {};
 //# sourceMappingURL=expectProxy.d.ts.map

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

@@ -1 +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,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAkOlD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,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,CAsElC"}
+{"version":3,"file":"expectProxy.d.ts","sourceRoot":"","sources":["../../src/fixtures/expectProxy.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEvE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAmB,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAI7E,KAAK,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AAmVhD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,kBAAkB,EAAE,IAAI,GAAG,IAAI,CAAC;IAC7C,GAAG,EAAE,eAAe,CAAC;IACrB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,gBAAgB,CAAC;AAElE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,cAAc,EACvB,UAAU,GAAE,gBAAmC,GAC9C,gBAAgB,CA+BlB;AA0DD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,OAAO,kBAAkB,EAAE,IAAI,EACrC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAChD,gBAAgB,CAOlB"}

package/dist/fixtures/expectProxy.js

@@ -1,8 +1,26 @@
 "use strict";
 // src/fixtures/expectProxy.ts - full replacement
+//
+// Drop-in parity with Playwright's `expect`.
+//
+// Instead of REBUILDING expect from scratch (which silently dropped every
+// static — soft/poll/extend/configure/asymmetric matchers — and ignored the
+// 2nd `messageOrOptions` argument), we now INTERCEPT the genuine
+// `playwrightExpect` via a Proxy:
+//
+//   • apply trap  → forwards `(actual, ...rest)` verbatim through
+//                   Reflect.apply, then layers healing on locator matchers.
+//   • get   trap  → forwards every static (poll/extend/getState/not/<asym>)
+//                   to the real object; only `soft`/`configure` are wrapped so
+//                   they keep healing + return Sela-tagged expects.
+//
+// Forwarding is the default; healing is the exception. Anything Playwright
+// adds in a future version is reachable for free.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHealingExpect = makeHealingExpect;
 exports.createHealingExpect = createHealingExpect;
 const test_1 = require("@playwright/test");
+const crypto_1 = require("crypto");
 const HealingRegistry_1 = require("../engine/HealingRegistry");
 const proxyTag_1 = require("./proxyTag");
 const logger_1 = require("../utils/logger");
@@ -42,16 +60,6 @@ function isRealLocator(value) {
         value._impl?._frameSelector !== undefined;
     return hasFrame && !isFrameLocator;
 }
-/**
- * Detect whether a locator is frame-scoped by checking its internal
- * selector string for frame-related segments.
- */
-function isFrameScopedLocator(locator) {
-    const sel = locator._selector ?? locator["_impl"]?._selector ?? "";
-    return (typeof sel === "string" &&
-        (sel.includes("internal:control=enter-frame") ||
-            sel.includes(">> internal:control=enter-frame")));
-}
 /**
  * Extracts the internal Playwright selector string from a real Locator.
  */
@@ -88,8 +96,7 @@ function extractSelectorFromLocator(locator) {
  *   → page.locator("#simple-element")
  */
 function rebuildLocator(page, healedSelector) {
-    // --- הוספת השורה הזו ---
-    // מוודא שאנחנו עובדים עם האובייקט האמיתי של פליירייט ולא עם הפרוקסי שלנו
+    // Always operate on the genuine Playwright page, never the Sela page proxy.
     const rawPage = page._rawPage || page;
     const segments = healedSelector
         .split(" >> ")
@@ -110,137 +117,263 @@ function rebuildLocator(page, healedSelector) {
             context = context.frameLocator(frameSel);
         }
     }
-    // כאן אנחנו מחזירים לוקטור שנוצר ישירות מה-rawPage
     return context.locator(elementSegment);
 }
 /**
- * Wrap a single matcher so that element-not-found errors trigger the
- * heal cycle and retry the assertion once on the correctly rebuilt locator.
+ * Resolve a healed selector for a failing locator, going through the
+ * HealingRegistry fast-path first and the engine + LLM slow-path second.
+ *
+ * Returns the canonical healed selector string, or `null` when no heal is
+ * available (selector unchanged / engine declined). A `[SafetyGuard]` block is
+ * re-thrown so the caller surfaces the protected-element message - Sela must
+ * never silently swallow a deliberate refusal-to-heal.
+ */
+async function healSelector(locator, ctx, engine, page) {
+    const rawSelector = extractSelectorFromLocator(locator);
+    if (!rawSelector)
+        return null;
+    logger_1.logger.debug(`Assertion failed for "${rawSelector}", attempting heal…`);
+    // Fast path - already healed in this test via the registry.
+    const resolved = HealingRegistry_1.HealingRegistry.getInstance().resolveSelector(rawSelector, ctx);
+    if (resolved !== rawSelector)
+        return resolved;
+    // Slow path - ask the engine + LLM. engine.heal() writes the fix to disk
+    // AND returns the canonical healedLocatorString from SourceUpdater - the
+    // exact string saved to the file. This handshake keeps disk and runtime in
+    // sync (no "ghost failures").
+    const stableId = (0, crypto_1.createHash)("md5").update(rawSelector).digest("hex");
+    const healed = await engine.heal(page, rawSelector, rawSelector, stableId, ctx.filePath, ctx.line, "assertion");
+    if (!healed || healed === rawSelector)
+        return null;
+    return healed;
+}
+const WRAPPED_MATCHERS = [
+    "toBeVisible",
+    "toBeHidden",
+    "toBeEnabled",
+    "toBeDisabled",
+    "toHaveText",
+    "toContainText",
+    "toHaveValue",
+    "toHaveAttribute",
+    "toHaveCount",
+    "toBeChecked",
+    "toBeFocused",
+];
+/** Build an expectation for the (possibly negated) matcher chain. */
+function expectationFor(base, locator, negated) {
+    const e = base(locator);
+    return negated ? e.not : e;
+}
+/**
+ * Wrap a HARD matcher so element-not-found errors trigger the heal cycle and
+ * retry the assertion once on the correctly rebuilt locator.
  */
-function wrapMatcher(matcher, locator, matcherName, engine, page, ctx) {
-    return (async (...args) => {
+function wrapHardMatcher(matcher, locator, matcherName, engine, page, ctx, opts) {
+    return async (...args) => {
         try {
             return await matcher(...args);
         }
         catch (err) {
             if (!isElementNotFoundError(err))
                 throw err;
-            const rawSelector = extractSelectorFromLocator(locator);
-            if (!rawSelector)
+            let healed;
+            try {
+                healed = await healSelector(locator, ctx, engine, page);
+            }
+            catch (healErr) {
+                // [SafetyGuard] blocks are deliberate refusals — surface them.
+                if (healErr instanceof Error &&
+                    healErr.message.includes("[SafetyGuard]")) {
+                    throw healErr;
+                }
+                throw err;
+            }
+            if (!healed)
+                throw err;
+            const newLocator = rebuildLocator(page, healed);
+            const retry = expectationFor(opts.baseExpect, newLocator, opts.negated);
+            const retryMatcher = retry[matcherName];
+            if (typeof retryMatcher !== "function")
                 throw err;
-            logger_1.logger.debug(`Assertion failed for "${rawSelector}", attempting heal…`);
-            // Fast path - already healed in this test via registry
-            const resolved = HealingRegistry_1.HealingRegistry.getInstance().resolveSelector(rawSelector, ctx);
-            let healedSelector = resolved;
-            if (resolved === rawSelector) {
-                // Slow path - ask the engine + LLM.
-                // engine.heal() writes the fix to disk AND returns the canonical
-                // healedLocatorString from SourceUpdater - the exact same string
-                // that was saved to the file.  This is the handshake that guarantees
-                // disk and runtime are in sync (no "ghost failures").
-                const stableId = require("crypto")
-                    .createHash("md5")
-                    .update(rawSelector)
-                    .digest("hex");
+            logger_1.logger.debug(`Retrying assertion with healed selector: "${healed}"`);
+            return await retryMatcher.apply(retry, args);
+        }
+    };
+}
+/**
+ * Wrap a SOFT matcher.
+ *
+ * Soft assertions never throw — Playwright records the failure on testInfo and
+ * resolves — so the heal-on-throw path used for hard matchers cannot observe a
+ * failure. We therefore probe HARD first to surface element-not-found, heal if
+ * needed, then run the authoritative SOFT assertion on the (possibly healed)
+ * locator so the result is recorded with correct soft semantics.
+ *
+ * Trade-off: a soft assertion that fails for a NON-stale reason (element
+ * present, condition false) waits the matcher timeout twice (hard probe + soft
+ * record). This only affects the already-slow genuine-failure path; the pass
+ * path and the stale-selector path each run the matcher effectively once.
+ */
+function wrapSoftMatcher(locator, matcherName, engine, page, ctx, opts) {
+    return async (...args) => {
+        let target = locator;
+        try {
+            const hard = expectationFor(opts.baseExpect, target, opts.negated);
+            await hard[matcherName](...args);
+            return; // passed hard ⇒ passes soft, nothing to record
+        }
+        catch (err) {
+            if (isElementNotFoundError(err)) {
+                let healed = null;
                 try {
-                    healedSelector = await engine.heal(page, rawSelector, rawSelector, stableId, ctx.filePath, ctx.line, "assertion");
+                    healed = await healSelector(locator, ctx, engine, page);
                 }
                 catch (healErr) {
                     if (healErr instanceof Error &&
                         healErr.message.includes("[SafetyGuard]")) {
                         throw healErr;
                     }
-                    throw err;
+                }
+                if (healed) {
+                    target = rebuildLocator(page, healed);
+                    logger_1.logger.debug(`Soft assertion healed to selector: "${healed}"`);
                 }
             }
-            if (!healedSelector || healedSelector === rawSelector)
-                throw err;
-            // Rebuild the locator from the canonical selector returned by the
-            // updater.  rebuildLocator() correctly chains frameLocator() calls
-            // for each frame segment, then .locator() for the final element,
-            // ensuring page/frame/locator variables are scoped correctly at runtime.
-            const newLocator = rebuildLocator(page, healedSelector);
-            const newExpectation = (0, test_1.expect)(newLocator);
-            const retryMatcher = newExpectation[matcherName];
-            if (typeof retryMatcher !== "function")
-                throw err;
-            logger_1.logger.debug(`Retrying assertion with healed selector: "${healedSelector}"`);
-            return await retryMatcher.apply(newExpectation, args);
+            // Record softly on the (possibly healed) target.
+            const softExp = opts.baseExpect.soft(target);
+            const chain = opts.negated ? softExp.not : softExp;
+            return await chain[matcherName](...args);
         }
-    });
+    };
 }
-const WRAPPED_MATCHERS = [
-    "toBeVisible",
-    "toBeHidden",
-    "toBeEnabled",
-    "toBeDisabled",
-    "toHaveText",
-    "toContainText",
-    "toHaveValue",
-    "toHaveAttribute",
-    "toHaveCount",
-    "toBeChecked",
-    "toBeFocused",
-];
 /**
- * createHealingExpect - drop-in replacement for Playwright's expect().
- *
- * @param resolveProxy  Optional callback that unwraps a Sela proxy
- * to its current live Locator. Supplied by
- * fixtures/index.ts which owns proxyToActiveLocator.
+ * Wrap a Playwright expectation object so its locator matchers heal, and so the
+ * `.not` chain stays wrapped (otherwise `expect(loc).not.toBeVisible()` would
+ * lose healing). `.resolves` / `.rejects` are promise chains (non-locator) and
+ * pass through untouched.
  */
-function createHealingExpect(engine, page, filePath, initialLine, // השורה מהפיקסצ'ר (לרוב תהיה לא מדויקת או 0)
-resolveProxy) {
-    return function expect(locatorOrValue) {
-        // 1. חילוץ דינמי של שורת הקוד האמיתית בזמן קריאת ה-expect
-        const getCallerLine = () => {
-            const err = new Error();
-            const stack = err.stack?.split("\n") || [];
-            // מחפשים את הקריאה הראשונה בשרשרת שמגיעה מקובץ הטסט ולא מקובץ הפרוקסי
-            const specLine = stack.find((l) => l.includes(filePath) && !l.includes("expectProxy"));
-            if (specLine) {
-                const match = specLine.match(/:(\d+):(\d+)/);
-                return match ? parseInt(match[1], 10) : initialLine;
+function wrapExpectation(base, locator, ctx, engine, page, opts) {
+    return new Proxy(base, {
+        get(target, prop) {
+            // Sela proxy identity — honored before any string-only branch.
+            if (prop === proxyTag_1.SELA_PROXY)
+                return "expect";
+            if (typeof prop !== "string")
+                return target[prop];
+            const val = target[prop];
+            // Re-wrap the negated chain so heals propagate through `.not`.
+            if (prop === "not" && val && typeof val === "object") {
+                return wrapExpectation(val, locator, ctx, engine, page, {
+                    ...opts,
+                    negated: !opts.negated,
+                });
             }
-            return initialLine;
-        };
-        const actualLine = getCallerLine(); // כאן אנחנו מקבלים את השורה הנכונה!
-        // Step 1 - unwrap Sela proxy to real active Locator
-        let resolved = locatorOrValue;
-        if (resolveProxy) {
-            const unwrapped = resolveProxy(locatorOrValue);
-            if (unwrapped)
-                resolved = unwrapped;
-        }
-        const base = (0, test_1.expect)(resolved);
-        // Defensive: if for any reason `base` is not an object, return it as-is
-        // rather than crashing inside `new Proxy(...)`.
-        if (base === null || typeof base !== "object") {
+            if (typeof val === "function" &&
+                WRAPPED_MATCHERS.includes(prop)) {
+                return opts.soft
+                    ? wrapSoftMatcher(locator, prop, engine, page, ctx, opts)
+                    : wrapHardMatcher(val.bind(target), locator, prop, engine, page, ctx, opts);
+            }
+            return val;
+        },
+    });
+}
+/**
+ * The unified healing-expect factory. Returns a Proxy whose target is the real
+ * Playwright `expect` (or a `configure()`-d variant), so it is structurally
+ * indistinguishable from Playwright's `Expect` — same call signature, same
+ * static surface — with healing layered on locator matchers.
+ */
+function makeHealingExpect(engine, resolve, baseExpect = test_1.expect) {
+    const handler = {
+        // expect(actual, messageOrOptions?) — rest args forwarded verbatim.
+        apply(target, thisArg, args) {
+            const [value, ...rest] = args;
+            const { page, ctx, locator } = resolve(value);
+            const subject = locator ?? value;
+            const base = Reflect.apply(target, thisArg, [subject, ...rest]);
+            if (!page)
+                return base;
+            if (base === null || typeof base !== "object")
+                return base;
+            if (!isRealLocator(subject))
+                return base;
+            return wrapExpectation(base, subject, ctx, engine, page, {
+                negated: false,
+                soft: false,
+                baseExpect,
+            });
+        },
+        // Statics: forward everything; wrap only soft + configure.
+        get(target, prop, receiver) {
+            if (prop === proxyTag_1.SELA_PROXY)
+                return "expect";
+            if (prop === "soft")
+                return makeSoft(engine, resolve, baseExpect);
+            if (prop === "configure")
+                return makeConfigure(engine, resolve, baseExpect);
+            return Reflect.get(target, prop, receiver);
+        },
+    };
+    return new Proxy(baseExpect, handler);
+}
+/** Heal-aware `expect.soft`. Non-locator values fall through to native soft. */
+function makeSoft(engine, resolve, baseExpect) {
+    return (value, ...rest) => {
+        const { page, ctx, locator } = resolve(value);
+        const subject = locator ?? value;
+        const base = baseExpect.soft(subject, ...rest);
+        if (!page)
             return base;
-        }
-        // Step 2 - only wrap matchers for genuine page-level Locator objects.
-        if (!isRealLocator(resolved)) {
+        if (base === null || typeof base !== "object")
             return base;
-        }
-        const locator = resolved;
-        // משתמשים בשורה האמיתית שחילצנו עבור ה-Context שמועבר ל-Engine
-        const ctx = { filePath, line: actualLine };
-        const proxy = new Proxy(base, {
-            get(target, prop) {
-                // Sela proxy identity - honored before any string-only branch so
-                // callers can detect a Sela expect proxy via Symbol.for("sela.proxy").
-                if (prop === proxyTag_1.SELA_PROXY)
-                    return "expect";
-                if (typeof prop !== "string")
-                    return target[prop];
-                const val = target[prop];
-                if (typeof val === "function" &&
-                    WRAPPED_MATCHERS.includes(prop)) {
-                    return wrapMatcher(val.bind(target), locator, prop, engine, page, ctx);
-                }
-                return val;
-            },
+        if (!isRealLocator(subject))
+            return base;
+        return wrapExpectation(base, subject, ctx, engine, page, {
+            negated: false,
+            soft: true,
+            baseExpect,
         });
-        return proxy;
     };
 }
+/**
+ * Heal-aware `expect.configure`. Returns a NEW healing expect whose base is the
+ * configured Playwright expect, so configured timeouts/soft defaults apply on
+ * both the first attempt and the heal retry.
+ */
+function makeConfigure(engine, resolve, baseExpect) {
+    return (configuration) => {
+        const configured = baseExpect.configure(configuration);
+        return makeHealingExpect(engine, resolve, configured);
+    };
+}
+/** Resolve the caller's source line within `filePath` from the live stack. */
+function getCallerLine(filePath, fallback) {
+    const stack = new Error().stack?.split("\n") ?? [];
+    const specLine = stack.find((l) => filePath !== "" && l.includes(filePath) && !l.includes("expectProxy"));
+    if (specLine) {
+        const match = specLine.match(/:(\d+):(\d+)/);
+        return match ? parseInt(match[1], 10) : fallback;
+    }
+    return fallback;
+}
+/**
+ * createHealingExpect - fixture-scoped healing expect.
+ *
+ * Page and file are fixed (from the test fixture); the source line is resolved
+ * per call from the stack. `resolveProxy` unwraps a Sela locator proxy to its
+ * current live Locator (supplied by fixtures/index.ts which owns
+ * proxyToActiveLocator).
+ *
+ * Signature preserved for backward compatibility; internally delegates to the
+ * unified makeHealingExpect so the export is full Playwright `Expect` parity.
+ */
+function createHealingExpect(engine, page, filePath, initialLine, resolveProxy) {
+    const resolve = (value) => ({
+        page,
+        locator: resolveProxy ? resolveProxy(value) : null,
+        ctx: { filePath, line: getCallerLine(filePath, initialLine) },
+    });
+    return makeHealingExpect(engine, resolve);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAK/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAqCpD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAI/D;AAgoBD,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,GAAG,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,IAAI,EACb,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAChC,WAAW,EAAE,MAAM,GAClB,GAAG,CAuCL;AAaD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,EACb,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAChC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,GAAG,CAiPL;AAQD,eAAO,MAAM,IAAI;YAEL,UAAU,CAAC,OAAO,mBAAmB,CAAC;;IAG9C;;;;;;;;;;;;;OAaG;0BACmB,IAAI;EAmI5B,CAAC;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fixtures/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAK/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAuCpD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAI/D;AAgoBD,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,GAAG,EACpB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,IAAI,EACb,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAChC,WAAW,EAAE,MAAM,GAClB,GAAG,CAuCL;AAaD,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,EACb,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAChC,mBAAmB,CAAC,EAAE,MAAM,GAC3B,GAAG,CAiPL;AAQD,eAAO,MAAM,IAAI;YAEL,UAAU,CAAC,OAAO,mBAAmB,CAAC;;IAG9C;;;;;;;;;;;;;OAaG;0BACmB,IAAI;EAmI5B,CAAC;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/fixtures/index.js

@@ -58,11 +58,12 @@ function regressionInjector() {
     if (_regressionInjector !== undefined)
         return _regressionInjector;
     const active = process.env["SELA_REGRESSION_ACTIVE"];
-    const manifestPath = process.env["SELA_REGRESSION_MANIFEST"];
-    if (active?.trim().toLowerCase() !== "true" || !manifestPath) {
+    if (active?.trim().toLowerCase() !== "true") {
         _regressionInjector = null;
         return null;
     }
+    const manifestPath = process.env["SELA_REGRESSION_MANIFEST"] ??
+        path.join(process.cwd(), ".sela", RegressionManifestService_1.REGRESSION_MANIFEST_FILE);
     try {
         _regressionInjector = RegressionManifestService_1.RegressionInjector.fromFile(manifestPath);
         logger_1.logger.debug(`Shadow-regression injector loaded from ${manifestPath}`);

package/dist/fixtures/moduleExpect.d.ts

@@ -1,2 +1,3 @@
-export declare function expect(value: unknown): any;
+import { type Expect } from "@playwright/test";
+export declare const expect: Expect<{}>;
 //# sourceMappingURL=moduleExpect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"moduleExpect.d.ts","sourceRoot":"","sources":["../../src/fixtures/moduleExpect.ts"],"names":[],"mappings":"AA8CA,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAa1C"}
+{"version":3,"file":"moduleExpect.d.ts","sourceRoot":"","sources":["../../src/fixtures/moduleExpect.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,kBAAkB,CAAC;AA0D1B,eAAO,MAAM,MAAM,EAGH,MAAM,CAAC,EAAE,CAAC,CAAC"}

package/dist/fixtures/moduleExpect.js

@@ -1,10 +1,15 @@
 "use strict";
-// Standalone module-level expect for `import { expect } from 'sela'` usage.
-// Creates a per-call healing expect using the shared engine singleton.
-// Falls back to raw Playwright expect for non-Locator values.
+// Standalone module-level expect for `import { expect } from 'sela-core'` usage.
+//
+// Full Playwright `Expect` parity: this is the genuine `playwrightExpect`
+// behind a Proxy (see makeHealingExpect), so every static — soft / poll /
+// extend / configure / getState / not / asymmetric matchers — and the 2-arg
+// `(actual, messageOrOptions?)` signature are preserved. Healing is layered on
+// locator matchers using the shared engine singleton; the page is detected
+// per-call from the asserted value, falling back to native Playwright behavior
+// for non-locator values.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expect = expect;
-const test_1 = require("@playwright/test");
+exports.expect = void 0;
 const singleton_js_1 = require("../engine/singleton.js");
 const expectProxy_js_1 = require("./expectProxy.js");
 const index_js_1 = require("./index.js");
@@ -26,29 +31,33 @@ function extractPage(value) {
     }
     return null;
 }
-function getCallerFile() {
+/**
+ * Resolve the caller's spec file + line from the live stack. Matches BOTH frame
+ * shapes V8 emits, including Windows drive-letter paths:
+ *   "    at fnName (D:\\path\\file.spec.ts:17:20)"
+ *   "    at D:\\path\\file.spec.ts:17:20"
+ */
+function getCallerSite() {
     const lines = new Error().stack?.split("\n") ?? [];
-    // Match BOTH frame shapes V8 emits:
-    //   "    at fnName (D:\\path\\file.spec.ts:17:20)"
-    //   "    at D:\\path\\file.spec.ts:17:20"
-    // The path may include Windows drive letters (colon after C/D/...).
-    const FRAME_WITH_PARENS = /\(([^()]+?):\d+:\d+\)\s*$/;
-    const FRAME_BARE = /\s+at\s+(.+?):\d+:\d+\s*$/;
+    const FRAME_WITH_PARENS = /\(([^()]+?):(\d+):\d+\)\s*$/;
+    const FRAME_BARE = /\s+at\s+(.+?):(\d+):\d+\s*$/;
     for (let i = 1; i < lines.length; i++) {
         const line = lines[i];
         if (!/\.(spec|test)\.[jt]sx?/.test(line))
             continue;
         const m = line.match(FRAME_WITH_PARENS) ?? line.match(FRAME_BARE);
-        if (m && m[1])
-            return m[1].trim();
-    }
-    return "";
-}
-function expect(value) {
-    const page = extractPage(value);
-    if (page) {
-        const filePath = getCallerFile();
-        return (0, expectProxy_js_1.createHealingExpect)(singleton_js_1.sharedEngine, page, filePath, 0, index_js_1.resolveSelaProxy)(value);
+        if (m && m[1]) {
+            return { filePath: m[1].trim(), line: parseInt(m[2], 10) };
+        }
     }
-    return (0, test_1.expect)(value);
+    return { filePath: "", line: 0 };
 }
+const resolve = (value) => {
+    const { filePath, line } = getCallerSite();
+    return {
+        page: extractPage(value),
+        locator: (0, index_js_1.resolveSelaProxy)(value),
+        ctx: { filePath, line },
+    };
+};
+exports.expect = (0, expectProxy_js_1.makeHealingExpect)(singleton_js_1.sharedEngine, resolve);

package/dist/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+// Playwright-identical callable module root.
+//
+// Mirrors `node_modules/playwright/test.js`:
+//   module.exports = Object.assign(test, combinedExports)
+//
+// The module IS the `test` function, with every other export hung off it, so
+// ALL of the following resolve to the same object/contract:
+//   require('sela-core')            → callable `test`
+//   require('sela-core').expect     → expect
+//   require('sela-core').default    → test
+//   import test from 'sela-core'    → test (via .default interop)
+//   import { test, expect } ...     → named
+//
+// `package.json` maps "require" → this file (dist/index.cjs) and "import" →
+// the tsc-emitted ESM-facing module (dist/index.js, static named exports).
+// Types for both come from dist/index.d.ts.
+// `./index.js` is the compiled src/index.ts (CommonJS): carries `test`,
+// `expect`, value re-exports, `defineConfig`, `SelaReporter`, `__esModule`,
+// and `default` (= test).
+const api = require("./index.js");
+const root = Object.assign(api.test, api);
+// Self-consistent default: api.default is already `test`; pin it explicitly so
+// the callable root and its `.default` are the same function.
+root.default = api.test;
+module.exports = root;

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+declare const root: any;
+export = root;
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.cts"],"names":[],"mappings":"AAsBA,QAAA,MAAM,IAAI,EAAE,GAAkC,CAAC;AAK/C,SAAS,IAAI,CAAC"}

package/dist/index.d.ts

@@ -2,7 +2,9 @@ export { defineConfig } from "./config/defineConfig.js";
 export type { SelaConfig, ResolvedConfig } from "./config/SelaConfig.js";
 export type * from "@playwright/test";
 export { chromium, firefox, webkit, devices, selectors, } from "@playwright/test";
-export { test } from "./fixtures/index.js";
+import { test } from "./fixtures/index.js";
+export { test };
+export default test;
 export { expect } from "./fixtures/moduleExpect.js";
 export { SelaReporter } from "./reporter/SelaReporter.js";
 export type { SelaReporterOpts, ReporterEngine, ReporterLogger, } from "./reporter/SelaReporter.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAGzE,mBAAmB,kBAAkB,CAAC;AAGtC,OAAO,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,OAAO,EACP,SAAS,GACV,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAI3C,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAKpD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,cAAc,GACf,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAGzE,mBAAmB,kBAAkB,CAAC;AAGtC,OAAO,EACL,QAAQ,EACR,OAAO,EACP,MAAM,EACN,OAAO,EACP,SAAS,GACV,MAAM,kBAAkB,CAAC;AAU1B,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,CAAC;AAChB,eAAe,IAAI,CAAC;AAIpB,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAKpD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,cAAc,GACf,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -17,9 +17,16 @@ Object.defineProperty(exports, "webkit", { enumerable: true, get: function () {
 Object.defineProperty(exports, "devices", { enumerable: true, get: function () { return test_1.devices; } });
 Object.defineProperty(exports, "selectors", { enumerable: true, get: function () { return test_1.selectors; } });
 // Sela's extended test - includes DNA capture, trace collection,
-// locator proxy, and fixture-scoped healing expect
-var index_js_1 = require("./fixtures/index.js");
+// locator proxy, and fixture-scoped healing expect.
+//
+// Exported as BOTH named and default to mirror Playwright's contract
+// (`export const test; export default test;`). The callable Object.assign
+// root that also makes `require('sela-core')` return `test` lives in
+// `index.cts`; this module is the ESM-facing surface (static named exports
+// the cjs-module-lexer can detect for `import { test, expect }`).
+const index_js_1 = require("./fixtures/index.js");
 Object.defineProperty(exports, "test", { enumerable: true, get: function () { return index_js_1.test; } });
+exports.default = index_js_1.test;
 // Sela's healing expect - works standalone (import { expect } from 'sela-core')
 // Detects page from locator, falls back to raw PW expect for non-locators
 var moduleExpect_js_1 = require("./fixtures/moduleExpect.js");

package/dist/services/HealReportService.js

@@ -1266,6 +1266,7 @@ const REPORT_JS = [
     "}",
     // ── Shared-locator runtime bypass (blast-radius protection)
     "var WARN_TRIANGLE='<svg class=\"warn-tri\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M8 1.5L15 14H1L8 1.5z\"/><line x1=\"8\" y1=\"6\" x2=\"8\" y2=\"9.5\"/><circle cx=\"8\" cy=\"11.6\" r=\"0.7\" fill=\"currentColor\" stroke=\"none\"/></svg>';",
+    "var LIGHTBULB='<svg class=\"lightbulb-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"><path d=\"M8 1a3.5 3.5 0 0 0-3.5 3.5c0 1.5.5 2.5 1 3.5v1.5h5v-1.5c.5-1 1-2 1-3.5A3.5 3.5 0 0 0 8 1z\"/><line x1=\"5\" y1=\"10.5\" x2=\"11\" y2=\"10.5\"/><path d=\"M6 12.5h4\"/><path d=\"M6.5 14h3\"/></svg>';",
     "function renderBypassBody(ev){",
     "  var link=vscodeLink(ev.sourceFile,ev.sourceLine);",
     "  var files=(ev.affectedFiles&&ev.affectedFiles.length)?'<div class=\"bb-files\">Affected: '+ev.affectedFiles.map(esc).join(', ')+'</div>':'';",
@@ -1285,7 +1286,7 @@ const REPORT_JS = [
     "  var bypassBrainInner=''",
     "    +'<div><div class=\"brain-section-title\">Chain of Thought</div>'+renderCoT(steps)+'</div>'",
     "    +'<div><div class=\"brain-section-title\">Intent Audit</div>'+renderAuditor(ev.auditor||null)+'</div>';",
-    "  var bypassBrain='<details class=\"brain-details\"><summary class=\"brain-summary\"><span class=\"brain-arrow\">▶</span>🧠 AI Reasoning \xb7 Audit</summary><div class=\"brain-body\">'+bypassBrainInner+'</div></details>';",
+    "  var bypassBrain='<details class=\"brain-details\"><summary class=\"brain-summary\"><span class=\"brain-arrow\">▶</span>'+LIGHTBULB+' AI Reasoning \xb7 Audit</summary><div class=\"brain-body\">'+bypassBrainInner+'</div></details>';",
     "  var actions='<div class=\"actions\">'",
     "    +'<a class=\"btn btn-primary\" href=\"'+link+'\">→ Open shared declaration in VS Code</a>'",
     "    +'</div>';",
@@ -1344,7 +1345,7 @@ const REPORT_JS = [
     "    var _snip=(_d.tagName||'element')+(_d.role?' role=\"'+_d.role+'\"':'')+(_d.text?' \\''+String(_d.text).slice(0,60)+'\\'':'');",
     "    brainInner+='<div><div class=\"brain-section-title\">Target DOM Snapshot</div><div class=\"muted-block\" style=\"font-family:var(--mono);font-size:12px\">'+esc(_snip)+'</div></div>';",
     "  }",
-    "  var brain='<details class=\"brain-details\"><summary class=\"brain-summary\"><span class=\"brain-arrow\">▶</span>🧠 AI Reasoning & Audit</summary><div class=\"brain-body\">'+brainInner+'</div></details>';",
+    "  var brain='<details class=\"brain-details\"><summary class=\"brain-summary\"><span class=\"brain-arrow\">▶</span>'+LIGHTBULB+' AI Reasoning & Audit</summary><div class=\"brain-body\">'+brainInner+'</div></details>';",
     '  return\'<div class="body-section"><div class="bs-title"><span class="bst-dot"></span>Source Code Diff</div>\'+renderDiff(ev)+\'</div>\'',
     "    +brain",
     "    +renderFixRegression(ev)",

package/dist/services/PRAutomationService.js

@@ -310,7 +310,7 @@ function buildDefaultBody(heals, branchInfo, reportLink, decision) {
         }
         lines.push("```");
         if (h.aiExplanation) {
-            lines.push(`> 🧠 ${h.aiExplanation}`);
+            lines.push(`> 💡 ${h.aiExplanation}`);
         }
         lines.push(`> AI Confidence: **${fmtPct(h.aiConfidence)}** · Auditor: **${fmtPct(h.auditor?.confidence)}**`);
         lines.push("");
@@ -483,12 +483,12 @@ async function runCleanRoom(args) {
                     continue;
                 const key = (0, VisualSnapshotService_1.snapshotKey)(heal.sourceFile, heal.stableId);
                 _vsActiveKeys.add(key);
-                const promoted = (0, VisualSnapshotService_1.promoteLiveToBaseline)(ctx.cwd, key);
+                const promoted = (0, VisualSnapshotService_1.promoteCandidateToBaseline)(ctx.cwd, key);
                 if (promoted.ok) {
-                    const relDna = path
-                        .join(".sela", "dna-snapshots", `${key}-dna.png`)
+                    const relBase = path
+                        .join(".sela", "dna-snapshots", `${key}-baseline.png`)
                         .replace(/\\/g, "/");
-                    (0, shell_1.sh)(`git add ${(0, shell_1.shellQuote)(relDna)}`, ctx.cwd);
+                    (0, shell_1.sh)(`git add ${(0, shell_1.shellQuote)(relBase)}`, ctx.cwd);
                 }
             }
             const gcCount = (0, VisualSnapshotService_1.gcOrphanSnapshots)(ctx.cwd, _vsActiveKeys);
@@ -496,14 +496,14 @@ async function runCleanRoom(args) {
                 (0, shell_1.sh)(`git add -u ${(0, shell_1.shellQuote)(path.join(".sela", "dna-snapshots"))}`, ctx.cwd);
             }
             // Stage first-run pass baselines and freshened post-edit baselines.
-            // These are *-dna.png files written by captureSuccessfulElement()
+            // These are *-baseline.png files written by captureSuccessfulElement()
             // that are not part of the heal loop above (no heal event = no loop
             // entry). git add on already-staged files is a no-op, so double-
             // staging healed PNGs here is harmless.
             const dnaDir = path.join(ctx.cwd, ".sela", "dna-snapshots");
             if (fs.existsSync(dnaDir)) {
                 for (const f of fs.readdirSync(dnaDir)) {
-                    if (!f.endsWith("-dna.png"))
+                    if (!f.endsWith("-baseline.png"))
                         continue;
                     (0, shell_1.sh)(`git add ${(0, shell_1.shellQuote)(path.join(".sela", "dna-snapshots", f))}`, ctx.cwd);
                 }

package/dist/services/VisualSnapshotService.d.ts

@@ -2,10 +2,15 @@ import type { Page } from "@playwright/test";
 /** Deterministic 16-hex key — same truncation as HealingRegistry.fingerprint(). */
 export declare function snapshotKey(sourceFile: string, stableId: string): string;
 export declare function dnaSnapshotDir(cwd: string): string;
-/** Canonical on-disk baseline promoted from the previous heal cycle. */
-export declare function dnaSnapshotPath(cwd: string, key: string): string;
-/** Temporary live capture from the current heal cycle (not committed to git). */
-export declare function liveSnapshotPath(cwd: string, key: string): string;
+/** Canonical on-disk baseline — committed to git; one file per element, ever. */
+export declare function baselineSnapshotPath(cwd: string, key: string): string;
+/**
+ * Candidate screenshot captured during a heal cycle.
+ * - Local: promoted immediately to baseline then deleted (0 surplus files).
+ * - CI: kept alongside the untouched baseline so the report shows before/after.
+ *   PRAutomationService promotes and deletes it when the heal PR is committed.
+ */
+export declare function candidateSnapshotPath(cwd: string, key: string): string;
 export interface CaptureResult {
     elementFound: boolean;
     capturedAt: string | null;
@@ -19,28 +24,29 @@ export interface CaptureResult {
  */
 export declare function captureElementScreenshot(page: Page, selector: string, framePath: string[], destPath: string): Promise<CaptureResult>;
 /**
- * Atomic promotion of the live capture to the canonical DNA baseline path.
+ * Atomic promotion of the candidate capture to the canonical baseline path.
  *
  * Steps:
- *   1. Backup existing dna to dna.bak (so rollback can restore it).
- *   2. Copy live → dna.
+ *   1. Backup existing baseline to baseline.bak (so rollback can restore it).
+ *   2. Copy candidate → baseline.
+ *   3. Delete candidate — baseline is now the single source of truth.
  *
- * Returns {ok:false} when the live file is absent (capture failed or
+ * Returns {ok:false} when the candidate file is absent (capture failed or
  * elementFound was false).
  */
-export declare function promoteLiveToBaseline(cwd: string, key: string): {
+export declare function promoteCandidateToBaseline(cwd: string, key: string): {
     ok: boolean;
 };
 /**
  * Undo a promotion by restoring the .bak file (if present) or deleting the
- * newly promoted dna file.  Called from runCleanRoom()'s catch block.
+ * newly promoted baseline file.  Called from runCleanRoom()'s catch block.
  */
 export declare function rollbackPromotion(cwd: string, key: string): void;
 /** Clean up the .bak sidecar after a successful git commit. */
 export declare function cleanupBackup(cwd: string, key: string): void;
 /**
- * Delete *-dna.png files not referenced by any key in activeKeys.
- * Leaves *-live.png files and .bak files untouched — those are transient.
+ * Delete *-baseline.png and *-candidate.png files not referenced by any key
+ * in activeKeys.  Leaves .bak files untouched.
  *
  * Returns the number of files deleted (0 when the dir doesn't exist yet).
  */

package/dist/services/VisualSnapshotService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VisualSnapshotService.d.ts","sourceRoot":"","sources":["../../src/services/VisualSnapshotService.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAS7C,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKxE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjE;AAwCD,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EAAE,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,CAAC,CAoCxB;AAMD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,CAgCjB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAahE;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAO5D;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,MAAM,CAyBR"}
+{"version":3,"file":"VisualSnapshotService.d.ts","sourceRoot":"","sources":["../../src/services/VisualSnapshotService.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAS7C,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKxE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtE;AAwCD,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EAAE,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,aAAa,CAAC,CAoCxB;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,CAkCjB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAahE;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAO5D;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,MAAM,CA4BR"}

package/dist/services/VisualSnapshotService.js

@@ -52,10 +52,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.snapshotKey = snapshotKey;
 exports.dnaSnapshotDir = dnaSnapshotDir;
-exports.dnaSnapshotPath = dnaSnapshotPath;
-exports.liveSnapshotPath = liveSnapshotPath;
+exports.baselineSnapshotPath = baselineSnapshotPath;
+exports.candidateSnapshotPath = candidateSnapshotPath;
 exports.captureElementScreenshot = captureElementScreenshot;
-exports.promoteLiveToBaseline = promoteLiveToBaseline;
+exports.promoteCandidateToBaseline = promoteCandidateToBaseline;
 exports.rollbackPromotion = rollbackPromotion;
 exports.cleanupBackup = cleanupBackup;
 exports.gcOrphanSnapshots = gcOrphanSnapshots;
@@ -77,13 +77,18 @@ function snapshotKey(sourceFile, stableId) {
 function dnaSnapshotDir(cwd) {
     return path.join(cwd, SNAPSHOT_SUBDIR);
 }
-/** Canonical on-disk baseline promoted from the previous heal cycle. */
-function dnaSnapshotPath(cwd, key) {
-    return path.join(dnaSnapshotDir(cwd), `${key}-dna.png`);
+/** Canonical on-disk baseline — committed to git; one file per element, ever. */
+function baselineSnapshotPath(cwd, key) {
+    return path.join(dnaSnapshotDir(cwd), `${key}-baseline.png`);
 }
-/** Temporary live capture from the current heal cycle (not committed to git). */
-function liveSnapshotPath(cwd, key) {
-    return path.join(dnaSnapshotDir(cwd), `${key}-live.png`);
+/**
+ * Candidate screenshot captured during a heal cycle.
+ * - Local: promoted immediately to baseline then deleted (0 surplus files).
+ * - CI: kept alongside the untouched baseline so the report shows before/after.
+ *   PRAutomationService promotes and deletes it when the heal PR is committed.
+ */
+function candidateSnapshotPath(cwd, key) {
+    return path.join(dnaSnapshotDir(cwd), `${key}-candidate.png`);
 }
 function ensureSnapshotDir(cwd) {
     const dir = dnaSnapshotDir(cwd);
@@ -159,56 +164,62 @@ async function captureElementScreenshot(page, selector, framePath, destPath) {
 // PROMOTION  (live → dna baseline)
 // ─────────────────────────────────────────────────────────────────────────────
 /**
- * Atomic promotion of the live capture to the canonical DNA baseline path.
+ * Atomic promotion of the candidate capture to the canonical baseline path.
  *
  * Steps:
- *   1. Backup existing dna to dna.bak (so rollback can restore it).
- *   2. Copy live → dna.
+ *   1. Backup existing baseline to baseline.bak (so rollback can restore it).
+ *   2. Copy candidate → baseline.
+ *   3. Delete candidate — baseline is now the single source of truth.
  *
- * Returns {ok:false} when the live file is absent (capture failed or
+ * Returns {ok:false} when the candidate file is absent (capture failed or
  * elementFound was false).
  */
-function promoteLiveToBaseline(cwd, key) {
-    const livePath = liveSnapshotPath(cwd, key);
-    const dnaPath = dnaSnapshotPath(cwd, key);
-    const bakPath = `${dnaPath}.bak`;
+function promoteCandidateToBaseline(cwd, key) {
+    const candPath = candidateSnapshotPath(cwd, key);
+    const basePath = baselineSnapshotPath(cwd, key);
+    const bakPath = `${basePath}.bak`;
     try {
-        if (!fs.existsSync(livePath)) {
-            logger_1.logger.debug(`VisualSnapshot: promote skipped — live not found: ${path.basename(livePath)}`);
+        if (!fs.existsSync(candPath)) {
+            logger_1.logger.debug(`VisualSnapshot: promote skipped — candidate not found: ${path.basename(candPath)}`);
             return { ok: false };
         }
         ensureSnapshotDir(cwd);
         // Backup existing baseline for rollback.
-        if (fs.existsSync(dnaPath)) {
+        if (fs.existsSync(basePath)) {
             try {
-                fs.copyFileSync(dnaPath, bakPath);
+                fs.copyFileSync(basePath, bakPath);
             }
             catch {
                 // Backup failure is non-fatal; rollback may not be possible.
             }
         }
-        fs.copyFileSync(livePath, dnaPath);
+        fs.copyFileSync(candPath, basePath);
+        // Remove candidate — baseline is now the single source of truth.
+        try {
+            fs.unlinkSync(candPath);
+        }
+        catch { /* non-fatal */ }
         return { ok: true };
     }
     catch (err) {
-        logger_1.logger.warn(`VisualSnapshot: promoteLiveToBaseline failed: ${err?.message ?? err}`);
+        logger_1.logger.warn(`VisualSnapshot: promoteCandidateToBaseline failed: ${err?.message ?? err}`);
         return { ok: false };
     }
 }
 /**
  * Undo a promotion by restoring the .bak file (if present) or deleting the
- * newly promoted dna file.  Called from runCleanRoom()'s catch block.
+ * newly promoted baseline file.  Called from runCleanRoom()'s catch block.
  */
 function rollbackPromotion(cwd, key) {
-    const dnaPath = dnaSnapshotPath(cwd, key);
-    const bakPath = `${dnaPath}.bak`;
+    const basePath = baselineSnapshotPath(cwd, key);
+    const bakPath = `${basePath}.bak`;
     try {
         if (fs.existsSync(bakPath)) {
-            fs.copyFileSync(bakPath, dnaPath);
+            fs.copyFileSync(bakPath, basePath);
             fs.unlinkSync(bakPath);
         }
-        else if (fs.existsSync(dnaPath)) {
-            fs.unlinkSync(dnaPath);
+        else if (fs.existsSync(basePath)) {
+            fs.unlinkSync(basePath);
         }
     }
     catch {
@@ -217,7 +228,7 @@ function rollbackPromotion(cwd, key) {
 }
 /** Clean up the .bak sidecar after a successful git commit. */
 function cleanupBackup(cwd, key) {
-    const bakPath = `${dnaSnapshotPath(cwd, key)}.bak`;
+    const bakPath = `${baselineSnapshotPath(cwd, key)}.bak`;
     try {
         if (fs.existsSync(bakPath))
             fs.unlinkSync(bakPath);
@@ -230,8 +241,8 @@ function cleanupBackup(cwd, key) {
 // GC  (orphan dna file cleanup)
 // ─────────────────────────────────────────────────────────────────────────────
 /**
- * Delete *-dna.png files not referenced by any key in activeKeys.
- * Leaves *-live.png files and .bak files untouched — those are transient.
+ * Delete *-baseline.png and *-candidate.png files not referenced by any key
+ * in activeKeys.  Leaves .bak files untouched.
  *
  * Returns the number of files deleted (0 when the dir doesn't exist yet).
  */
@@ -242,18 +253,22 @@ function gcOrphanSnapshots(cwd, activeKeys) {
     let deleted = 0;
     try {
         for (const file of fs.readdirSync(dir)) {
-            if (!file.endsWith("-dna.png"))
+            let key;
+            if (file.endsWith("-baseline.png")) {
+                key = file.slice(0, -"-baseline.png".length);
+            }
+            else if (file.endsWith("-candidate.png")) {
+                key = file.slice(0, -"-candidate.png".length);
+            }
+            if (!key || activeKeys.has(key))
                 continue;
-            const key = file.slice(0, -"-dna.png".length);
-            if (!activeKeys.has(key)) {
-                try {
-                    fs.unlinkSync(path.join(dir, file));
-                    deleted++;
-                    logger_1.logger.debug(`VisualSnapshot: GC deleted orphan ${file}`);
-                }
-                catch {
-                    // Best effort.
-                }
+            try {
+                fs.unlinkSync(path.join(dir, file));
+                deleted++;
+                logger_1.logger.debug(`VisualSnapshot: GC deleted orphan ${file}`);
+            }
+            catch {
+                // Best effort.
             }
         }
     }

package/dist/types/index.d.ts

@@ -50,7 +50,7 @@ export interface ElementSnapshot {
     isInShadowDom?: boolean;
     /** Visual element snapshot captured during a heal event. Path is cwd-relative. */
     visualSnapshot?: {
-        /** cwd-relative path to the committed DNA baseline PNG (e.g. .sela/dna-snapshots/<key>-dna.png). */
+        /** cwd-relative path to the committed baseline PNG (e.g. .sela/dna-snapshots/<key>-baseline.png). */
         path: string;
         /** ISO timestamp of when the live element screenshot was captured. */
         capturedAt: string;

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "sela-core",
-  "version": "0.1.0-alpha.40",
+  "version": "0.1.0-alpha.42",
   "description": "AI self-healing Playwright wrapper - drop-in replacement for @playwright/test",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
     },
     "./reporter": {
       "types": "./dist/reporter/SelaReporter.d.ts",