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

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/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/package.json

@@ -1,13 +1,15 @@
 {
   "name": "sela-core",
-  "version": "0.1.0-alpha.41",
+  "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",