@ricsam/isolate-playwright 0.1.2 → 0.1.5

package/dist/cjs/index.cjs

@@ -44,418 +44,393 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   setupPlaywright: () => setupPlaywright,
-  runPlaywrightTests: () => runPlaywrightTests,
-  resetPlaywrightTests: () => resetPlaywrightTests
+  createPlaywrightHandler: () => createPlaywrightHandler
 });
 module.exports = __toCommonJS(exports_src);
 var import_isolated_vm = __toESM(require("isolated-vm"));
-var KNOWN_ERROR_TYPES = [
-  "TypeError",
-  "RangeError",
-  "SyntaxError",
-  "ReferenceError",
-  "URIError",
-  "EvalError",
-  "TimeoutError"
-];
-function getErrorConstructorName(errorType) {
-  return KNOWN_ERROR_TYPES.includes(errorType) ? errorType : "Error";
-}
-function encodeErrorForTransfer(err) {
-  const errorType = getErrorConstructorName(err.name);
-  return new Error(`[${errorType}]${err.message}`);
-}
-var DECODE_ERROR_JS = `
-function __decodeError(err) {
-  if (!(err instanceof Error)) return err;
-  const match = err.message.match(/^\\[(TypeError|RangeError|SyntaxError|ReferenceError|URIError|EvalError|TimeoutError|Error)\\](.*)$/);
-  if (match) {
-    const ErrorType = globalThis[match[1]] || Error;
-    return new ErrorType(match[2]);
+function getLocator(page, selectorType, selectorValue, optionsJson) {
+  const options = optionsJson ? JSON.parse(optionsJson) : undefined;
+  const nthIndex = options?.nth;
+  const roleOptions = options ? { ...options } : undefined;
+  if (roleOptions) {
+    delete roleOptions.nth;
   }
-  return err;
-}
-`.trim();
-function getLocator(page, selectorType, selectorValue, roleOptionsJson) {
+  let locator;
   switch (selectorType) {
     case "css":
-      return page.locator(selectorValue);
-    case "role": {
-      const roleOptions = roleOptionsJson ? JSON.parse(roleOptionsJson) : undefined;
-      return page.getByRole(selectorValue, roleOptions);
-    }
+      locator = page.locator(selectorValue);
+      break;
+    case "role":
+      locator = page.getByRole(selectorValue, roleOptions && Object.keys(roleOptions).length > 0 ? roleOptions : undefined);
+      break;
     case "text":
-      return page.getByText(selectorValue);
+      locator = page.getByText(selectorValue);
+      break;
     case "label":
-      return page.getByLabel(selectorValue);
+      locator = page.getByLabel(selectorValue);
+      break;
     case "placeholder":
-      return page.getByPlaceholder(selectorValue);
+      locator = page.getByPlaceholder(selectorValue);
+      break;
     case "testId":
-      return page.getByTestId(selectorValue);
+      locator = page.getByTestId(selectorValue);
+      break;
     default:
-      return page.locator(selectorValue);
+      locator = page.locator(selectorValue);
+  }
+  if (nthIndex !== undefined) {
+    locator = locator.nth(nthIndex);
   }
+  return locator;
 }
-async function setupPlaywright(context, options) {
-  const { page, timeout = 30000, baseUrl } = options;
-  const consoleLogs = [];
-  const networkRequests = [];
-  const networkResponses = [];
-  const global = context.global;
-  const requestHandler = (request) => {
-    const info = {
-      url: request.url(),
-      method: request.method(),
-      headers: request.headers(),
-      postData: request.postData() ?? undefined,
-      resourceType: request.resourceType(),
-      timestamp: Date.now()
-    };
-    networkRequests.push(info);
-    options.onNetworkRequest?.(info);
-  };
-  const responseHandler = (response) => {
-    const info = {
-      url: response.url(),
-      status: response.status(),
-      statusText: response.statusText(),
-      headers: response.headers(),
-      timestamp: Date.now()
-    };
-    networkResponses.push(info);
-    options.onNetworkResponse?.(info);
-  };
-  const consoleHandler = (msg) => {
-    const entry = {
-      level: msg.type(),
-      args: msg.args().map((arg) => String(arg)),
-      timestamp: Date.now()
-    };
-    consoleLogs.push(entry);
-    options.onConsoleLog?.(entry.level, ...entry.args);
-  };
-  page.on("request", requestHandler);
-  page.on("response", responseHandler);
-  page.on("console", consoleHandler);
-  global.setSync("__Playwright_goto_ref", new import_isolated_vm.default.Reference(async (url, waitUntil) => {
-    try {
-      const targetUrl = baseUrl && !url.startsWith("http") ? `${baseUrl}${url}` : url;
-      await page.goto(targetUrl, {
-        timeout,
-        waitUntil: waitUntil ?? "load"
-      });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_reload_ref", new import_isolated_vm.default.Reference(async () => {
-    try {
-      await page.reload({ timeout });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_url", new import_isolated_vm.default.Callback(() => {
-    return page.url();
-  }));
-  global.setSync("__Playwright_title_ref", new import_isolated_vm.default.Reference(async () => {
-    try {
-      return await page.title();
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_content_ref", new import_isolated_vm.default.Reference(async () => {
-    try {
-      return await page.content();
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_waitForSelector_ref", new import_isolated_vm.default.Reference(async (selector, optionsJson) => {
-    try {
-      const opts = optionsJson ? JSON.parse(optionsJson) : {};
-      await page.waitForSelector(selector, { timeout, ...opts });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_waitForTimeout_ref", new import_isolated_vm.default.Reference(async (ms) => {
-    try {
-      await page.waitForTimeout(ms);
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_waitForLoadState_ref", new import_isolated_vm.default.Reference(async (state) => {
-    try {
-      await page.waitForLoadState(state ?? "load", { timeout });
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_evaluate_ref", new import_isolated_vm.default.Reference(async (script) => {
-    try {
-      const result = await page.evaluate(script);
-      return JSON.stringify(result);
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_locatorAction_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, action, actionArg) => {
-    try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
-      switch (action) {
-        case "click":
-          await locator.click({ timeout });
-          return null;
-        case "dblclick":
-          await locator.dblclick({ timeout });
-          return null;
-        case "fill":
-          await locator.fill(actionArg ?? "", { timeout });
-          return null;
-        case "type":
-          await locator.pressSequentially(actionArg ?? "", { timeout });
-          return null;
-        case "check":
-          await locator.check({ timeout });
-          return null;
-        case "uncheck":
-          await locator.uncheck({ timeout });
-          return null;
-        case "selectOption":
-          await locator.selectOption(actionArg ?? "", { timeout });
-          return null;
-        case "clear":
-          await locator.clear({ timeout });
-          return null;
-        case "press":
-          await locator.press(actionArg ?? "", { timeout });
-          return null;
-        case "hover":
-          await locator.hover({ timeout });
-          return null;
-        case "focus":
-          await locator.focus({ timeout });
-          return null;
-        case "getText":
-          return await locator.textContent({ timeout });
-        case "getValue":
-          return await locator.inputValue({ timeout });
-        case "isVisible":
-          return await locator.isVisible();
-        case "isEnabled":
-          return await locator.isEnabled();
-        case "isChecked":
-          return await locator.isChecked();
-        case "count":
-          return await locator.count();
-        default:
-          throw new Error(`Unknown action: ${action}`);
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
-    }
-  }));
-  global.setSync("__Playwright_expectVisible_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, not) => {
-    try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
+async function executeLocatorAction(locator, action, actionArg, timeout) {
+  switch (action) {
+    case "click":
+      await locator.click({ timeout });
+      return null;
+    case "dblclick":
+      await locator.dblclick({ timeout });
+      return null;
+    case "fill":
+      await locator.fill(String(actionArg ?? ""), { timeout });
+      return null;
+    case "type":
+      await locator.pressSequentially(String(actionArg ?? ""), { timeout });
+      return null;
+    case "check":
+      await locator.check({ timeout });
+      return null;
+    case "uncheck":
+      await locator.uncheck({ timeout });
+      return null;
+    case "selectOption":
+      await locator.selectOption(String(actionArg ?? ""), { timeout });
+      return null;
+    case "clear":
+      await locator.clear({ timeout });
+      return null;
+    case "press":
+      await locator.press(String(actionArg ?? ""), { timeout });
+      return null;
+    case "hover":
+      await locator.hover({ timeout });
+      return null;
+    case "focus":
+      await locator.focus({ timeout });
+      return null;
+    case "getText":
+      return await locator.textContent({ timeout });
+    case "getValue":
+      return await locator.inputValue({ timeout });
+    case "isVisible":
+      return await locator.isVisible();
+    case "isEnabled":
+      return await locator.isEnabled();
+    case "isChecked":
+      return await locator.isChecked();
+    case "count":
+      return await locator.count();
+    default:
+      throw new Error(`Unknown action: ${action}`);
+  }
+}
+async function executeExpectAssertion(locator, matcher, expected, negated, timeout) {
+  switch (matcher) {
+    case "toBeVisible": {
       const isVisible = await locator.isVisible();
-      if (not) {
-        if (isVisible) {
-          throw new Error(`Expected element to not be visible, but it was visible`);
-        }
+      if (negated) {
+        if (isVisible)
+          throw new Error("Expected element to not be visible, but it was visible");
       } else {
-        if (!isVisible) {
-          throw new Error(`Expected element to be visible, but it was not`);
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
+        if (!isVisible)
+          throw new Error("Expected element to be visible, but it was not");
       }
-      throw err;
+      break;
     }
-  }));
-  global.setSync("__Playwright_expectText_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, expected, not) => {
-    try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
+    case "toContainText": {
       const text = await locator.textContent({ timeout });
-      const matches = text?.includes(expected) ?? false;
-      if (not) {
-        if (matches) {
+      const matches = text?.includes(String(expected)) ?? false;
+      if (negated) {
+        if (matches)
           throw new Error(`Expected text to not contain "${expected}", but got "${text}"`);
-        }
       } else {
-        if (!matches) {
+        if (!matches)
           throw new Error(`Expected text to contain "${expected}", but got "${text}"`);
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
       }
-      throw err;
+      break;
     }
-  }));
-  global.setSync("__Playwright_expectValue_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, expected, not) => {
-    try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
+    case "toHaveValue": {
       const value = await locator.inputValue({ timeout });
-      const matches = value === expected;
-      if (not) {
-        if (matches) {
+      const matches = value === String(expected);
+      if (negated) {
+        if (matches)
           throw new Error(`Expected value to not be "${expected}", but it was`);
-        }
       } else {
-        if (!matches) {
+        if (!matches)
           throw new Error(`Expected value to be "${expected}", but got "${value}"`);
-        }
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
       }
-      throw err;
+      break;
     }
-  }));
-  global.setSync("__Playwright_expectEnabled_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, not) => {
-    try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
+    case "toBeEnabled": {
       const isEnabled = await locator.isEnabled();
-      if (not) {
-        if (isEnabled) {
-          throw new Error(`Expected element to be disabled, but it was enabled`);
-        }
+      if (negated) {
+        if (isEnabled)
+          throw new Error("Expected element to be disabled, but it was enabled");
       } else {
-        if (!isEnabled) {
-          throw new Error(`Expected element to be enabled, but it was disabled`);
-        }
+        if (!isEnabled)
+          throw new Error("Expected element to be enabled, but it was disabled");
       }
-    } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
+      break;
+    }
+    case "toBeChecked": {
+      const isChecked = await locator.isChecked();
+      if (negated) {
+        if (isChecked)
+          throw new Error("Expected element to not be checked, but it was checked");
+      } else {
+        if (!isChecked)
+          throw new Error("Expected element to be checked, but it was not");
       }
-      throw err;
+      break;
     }
-  }));
-  global.setSync("__Playwright_expectChecked_ref", new import_isolated_vm.default.Reference(async (selectorType, selectorValue, roleOptionsJson, not) => {
+    default:
+      throw new Error(`Unknown matcher: ${matcher}`);
+  }
+}
+function createPlaywrightHandler(page, options) {
+  const timeout = options?.timeout ?? 30000;
+  const baseUrl = options?.baseUrl;
+  return async (op) => {
     try {
-      const locator = getLocator(page, selectorType, selectorValue, roleOptionsJson);
-      const isChecked = await locator.isChecked();
-      if (not) {
-        if (isChecked) {
-          throw new Error(`Expected element to not be checked, but it was checked`);
+      switch (op.type) {
+        case "goto": {
+          const [url, waitUntil] = op.args;
+          const targetUrl = baseUrl && !url.startsWith("http") ? `${baseUrl}${url}` : url;
+          await page.goto(targetUrl, {
+            timeout,
+            waitUntil: waitUntil ?? "load"
+          });
+          return { ok: true };
         }
-      } else {
-        if (!isChecked) {
-          throw new Error(`Expected element to be checked, but it was not`);
+        case "reload":
+          await page.reload({ timeout });
+          return { ok: true };
+        case "url":
+          return { ok: true, value: page.url() };
+        case "title":
+          return { ok: true, value: await page.title() };
+        case "content":
+          return { ok: true, value: await page.content() };
+        case "waitForSelector": {
+          const [selector, optionsJson] = op.args;
+          const opts = optionsJson ? JSON.parse(optionsJson) : {};
+          await page.waitForSelector(selector, { timeout, ...opts });
+          return { ok: true };
+        }
+        case "waitForTimeout": {
+          const [ms] = op.args;
+          await page.waitForTimeout(ms);
+          return { ok: true };
+        }
+        case "waitForLoadState": {
+          const [state] = op.args;
+          await page.waitForLoadState(state ?? "load", { timeout });
+          return { ok: true };
+        }
+        case "evaluate": {
+          const [script] = op.args;
+          const result = await page.evaluate(script);
+          return { ok: true, value: result };
+        }
+        case "locatorAction": {
+          const [selectorType, selectorValue, roleOptions, action, actionArg] = op.args;
+          const locator = getLocator(page, selectorType, selectorValue, roleOptions);
+          const result = await executeLocatorAction(locator, action, actionArg, timeout);
+          return { ok: true, value: result };
+        }
+        case "expectLocator": {
+          const [selectorType, selectorValue, roleOptions, matcher, expected, negated, customTimeout] = op.args;
+          const locator = getLocator(page, selectorType, selectorValue, roleOptions);
+          const effectiveTimeout = customTimeout ?? timeout;
+          await executeExpectAssertion(locator, matcher, expected, negated ?? false, effectiveTimeout);
+          return { ok: true };
+        }
+        case "request": {
+          const [url, method, data, headers] = op.args;
+          const targetUrl = baseUrl && !url.startsWith("http") ? `${baseUrl}${url}` : url;
+          const requestOptions = {
+            timeout
+          };
+          if (headers) {
+            requestOptions.headers = headers;
+          }
+          if (data !== undefined && data !== null) {
+            requestOptions.data = data;
+          }
+          const response = await page.request.fetch(targetUrl, {
+            method,
+            ...requestOptions
+          });
+          const text = await response.text();
+          let json = null;
+          try {
+            json = JSON.parse(text);
+          } catch {}
+          return {
+            ok: true,
+            value: {
+              status: response.status(),
+              ok: response.ok(),
+              headers: response.headers(),
+              text,
+              json,
+              body: null
+            }
+          };
         }
+        default:
+          return { ok: false, error: { name: "Error", message: `Unknown operation: ${op.type}` } };
       }
     } catch (err) {
-      if (err instanceof Error) {
-        throw encodeErrorForTransfer(err);
-      }
-      throw err;
+      const error = err;
+      return { ok: false, error: { name: error.name, message: error.message } };
     }
+  };
+}
+async function setupPlaywright(context, options) {
+  const timeout = options.timeout ?? 30000;
+  const baseUrl = options.baseUrl;
+  const page = "page" in options ? options.page : undefined;
+  const handler = "handler" in options ? options.handler : undefined;
+  const effectiveHandler = handler ?? (page ? createPlaywrightHandler(page, { timeout, baseUrl }) : undefined);
+  if (!effectiveHandler) {
+    throw new Error("Either page or handler must be provided to setupPlaywright");
+  }
+  const browserConsoleLogs = [];
+  const networkRequests = [];
+  const networkResponses = [];
+  const global = context.global;
+  let requestHandler;
+  let responseHandler;
+  let consoleHandler;
+  if (page) {
+    const onEvent = "onEvent" in options ? options.onEvent : undefined;
+    requestHandler = (request) => {
+      const info = {
+        url: request.url(),
+        method: request.method(),
+        headers: request.headers(),
+        postData: request.postData() ?? undefined,
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      networkRequests.push(info);
+      if (onEvent) {
+        onEvent({
+          type: "networkRequest",
+          url: info.url,
+          method: info.method,
+          headers: info.headers,
+          postData: info.postData,
+          resourceType: info.resourceType,
+          timestamp: info.timestamp
+        });
+      }
+    };
+    responseHandler = (response) => {
+      const info = {
+        url: response.url(),
+        status: response.status(),
+        statusText: response.statusText(),
+        headers: response.headers(),
+        timestamp: Date.now()
+      };
+      networkResponses.push(info);
+      if (onEvent) {
+        onEvent({
+          type: "networkResponse",
+          url: info.url,
+          status: info.status,
+          statusText: info.statusText,
+          headers: info.headers,
+          timestamp: info.timestamp
+        });
+      }
+    };
+    consoleHandler = (msg) => {
+      const entry = {
+        level: msg.type(),
+        args: msg.args().map((arg) => String(arg)),
+        timestamp: Date.now()
+      };
+      browserConsoleLogs.push(entry);
+      if (onEvent) {
+        onEvent({
+          type: "browserConsoleLog",
+          level: entry.level,
+          args: entry.args,
+          timestamp: entry.timestamp
+        });
+      }
+      if ("console" in options && options.console) {
+        const prefix = `[browser:${entry.level}]`;
+        console.log(prefix, ...entry.args);
+      }
+    };
+    page.on("request", requestHandler);
+    page.on("response", responseHandler);
+    page.on("console", consoleHandler);
+  }
+  global.setSync("__Playwright_handler_ref", new import_isolated_vm.default.Reference(async (opJson) => {
+    const op = JSON.parse(opJson);
+    const result = await effectiveHandler(op);
+    return JSON.stringify(result);
   }));
-  context.evalSync(DECODE_ERROR_JS);
   context.evalSync(`
 (function() {
-  const tests = [];
-  globalThis.test = (name, fn) => tests.push({ name, fn });
-
-  globalThis.__runPlaywrightTests = async () => {
-    const results = [];
-    for (const t of tests) {
-      const start = Date.now();
-      try {
-        await t.fn();
-        results.push({ name: t.name, passed: true, duration: Date.now() - start });
-      } catch (err) {
-        results.push({ name: t.name, passed: false, error: err.message, duration: Date.now() - start });
-      }
+  globalThis.__pw_invoke = async function(type, args) {
+    const op = JSON.stringify({ type, args });
+    const resultJson = __Playwright_handler_ref.applySyncPromise(undefined, [op]);
+    const result = JSON.parse(resultJson);
+    if (result.ok) {
+      return result.value;
+    } else {
+      const error = new Error(result.error.message);
+      error.name = result.error.name;
+      throw error;
     }
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-    return JSON.stringify({ passed, failed, total: results.length, results });
   };
-
-  globalThis.__resetPlaywrightTests = () => { tests.length = 0; };
 })();
 `);
   context.evalSync(`
 (function() {
   globalThis.page = {
     async goto(url, options) {
-      try {
-        return __Playwright_goto_ref.applySyncPromise(undefined, [url, options?.waitUntil || null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("goto", [url, options?.waitUntil || null]);
     },
     async reload() {
-      try {
-        return __Playwright_reload_ref.applySyncPromise(undefined, []);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("reload", []);
+    },
+    async url() {
+      return __pw_invoke("url", []);
     },
-    url() { return __Playwright_url(); },
     async title() {
-      try {
-        return __Playwright_title_ref.applySyncPromise(undefined, []);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("title", []);
     },
     async content() {
-      try {
-        return __Playwright_content_ref.applySyncPromise(undefined, []);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("content", []);
     },
     async waitForSelector(selector, options) {
-      try {
-        return __Playwright_waitForSelector_ref.applySyncPromise(undefined, [selector, options ? JSON.stringify(options) : null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("waitForSelector", [selector, options ? JSON.stringify(options) : null]);
     },
     async waitForTimeout(ms) {
-      try {
-        return __Playwright_waitForTimeout_ref.applySyncPromise(undefined, [ms]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("waitForTimeout", [ms]);
     },
     async waitForLoadState(state) {
-      try {
-        return __Playwright_waitForLoadState_ref.applySyncPromise(undefined, [state]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("waitForLoadState", [state || null]);
     },
     async evaluate(script) {
-      try {
-        const resultJson = __Playwright_evaluate_ref.applySyncPromise(undefined, [script]);
-        return resultJson ? JSON.parse(resultJson) : undefined;
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("evaluate", [script]);
     },
     locator(selector) { return new Locator("css", selector, null); },
     getByRole(role, options) { return new Locator("role", role, options ? JSON.stringify(options) : null); },
@@ -463,6 +438,33 @@ async function setupPlaywright(context, options) {
     getByLabel(label) { return new Locator("label", label, null); },
     getByPlaceholder(p) { return new Locator("placeholder", p, null); },
     getByTestId(id) { return new Locator("testId", id, null); },
+    async click(selector) { return this.locator(selector).click(); },
+    async fill(selector, value) { return this.locator(selector).fill(value); },
+    request: {
+      async fetch(url, options) {
+        const result = await __pw_invoke("request", [url, options?.method || "GET", options?.data, options?.headers]);
+        return {
+          status: () => result.status,
+          ok: () => result.ok,
+          headers: () => result.headers,
+          json: async () => result.json,
+          text: async () => result.text,
+          body: async () => result.body,
+        };
+      },
+      async get(url, options) {
+        return this.fetch(url, { ...options, method: "GET" });
+      },
+      async post(url, options) {
+        return this.fetch(url, { ...options, method: "POST" });
+      },
+      async put(url, options) {
+        return this.fetch(url, { ...options, method: "PUT" });
+      },
+      async delete(url, options) {
+        return this.fetch(url, { ...options, method: "DELETE" });
+      },
+    },
   };
 })();
 `);
@@ -479,105 +481,59 @@ async function setupPlaywright(context, options) {
     _getInfo() { return [this.#type, this.#value, this.#options]; }
 
     async click() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "click", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "click", null]);
     }
-
     async dblclick() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "dblclick", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null]);
     }
-
     async fill(text) {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "fill", text]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text]);
     }
-
     async type(text) {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "type", text]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text]);
     }
-
     async check() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "check", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null]);
     }
-
     async uncheck() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "uncheck", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null]);
     }
-
     async selectOption(value) {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "selectOption", value]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value]);
     }
-
     async clear() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "clear", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null]);
     }
-
     async press(key) {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "press", key]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key]);
     }
-
     async hover() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "hover", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null]);
     }
-
     async focus() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "focus", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null]);
     }
-
     async textContent() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "getText", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null]);
     }
-
     async inputValue() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "getValue", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null]);
     }
-
     async isVisible() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "isVisible", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null]);
     }
-
     async isEnabled() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "isEnabled", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null]);
     }
-
     async isChecked() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "isChecked", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null]);
     }
-
     async count() {
-      try {
-        return __Playwright_locatorAction_ref.applySyncPromise(undefined, [...this._getInfo(), "count", null]);
-      } catch (err) { throw __decodeError(err); }
+      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null]);
+    }
+    nth(index) {
+      const existingOpts = this.#options ? JSON.parse(this.#options) : {};
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }));
     }
   }
   globalThis.Locator = Locator;
@@ -585,127 +541,84 @@ async function setupPlaywright(context, options) {
 `);
   context.evalSync(`
 (function() {
-  globalThis.expect = (actual) => {
-    if (actual instanceof Locator) {
-      const info = actual._getInfo();
-      return {
-        async toBeVisible() {
-          try {
-            await __Playwright_expectVisible_ref.applySyncPromise(undefined, [...info, false]);
-          } catch (err) { throw __decodeError(err); }
-        },
-        async toContainText(expected) {
-          try {
-            await __Playwright_expectText_ref.applySyncPromise(undefined, [...info, expected, false]);
-          } catch (err) { throw __decodeError(err); }
-        },
-        async toHaveValue(expected) {
-          try {
-            await __Playwright_expectValue_ref.applySyncPromise(undefined, [...info, expected, false]);
-          } catch (err) { throw __decodeError(err); }
-        },
-        async toBeEnabled() {
-          try {
-            await __Playwright_expectEnabled_ref.applySyncPromise(undefined, [...info, false]);
-          } catch (err) { throw __decodeError(err); }
-        },
-        async toBeChecked() {
-          try {
-            await __Playwright_expectChecked_ref.applySyncPromise(undefined, [...info, false]);
-          } catch (err) { throw __decodeError(err); }
-        },
-        not: {
-          async toBeVisible() {
-            try {
-              await __Playwright_expectVisible_ref.applySyncPromise(undefined, [...info, true]);
-            } catch (err) { throw __decodeError(err); }
-          },
-          async toContainText(expected) {
-            try {
-              await __Playwright_expectText_ref.applySyncPromise(undefined, [...info, expected, true]);
-            } catch (err) { throw __decodeError(err); }
-          },
-          async toHaveValue(expected) {
-            try {
-              await __Playwright_expectValue_ref.applySyncPromise(undefined, [...info, expected, true]);
-            } catch (err) { throw __decodeError(err); }
-          },
-          async toBeEnabled() {
-            try {
-              await __Playwright_expectEnabled_ref.applySyncPromise(undefined, [...info, true]);
-            } catch (err) { throw __decodeError(err); }
-          },
-          async toBeChecked() {
-            try {
-              await __Playwright_expectChecked_ref.applySyncPromise(undefined, [...info, true]);
-            } catch (err) { throw __decodeError(err); }
-          },
-        },
-      };
-    }
-    // Fallback: basic matchers for primitives
-    return {
-      toBe(expected) {
-        if (actual !== expected) throw new Error(\`Expected \${JSON.stringify(actual)} to be \${JSON.stringify(expected)}\`);
+  // Helper to create locator matchers
+  function createLocatorMatchers(locator, baseMatchers) {
+    const info = locator._getInfo();
+
+    const locatorMatchers = {
+      async toBeVisible(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeVisible", null, false, options?.timeout]);
       },
-      toEqual(expected) {
-        if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-          throw new Error(\`Expected \${JSON.stringify(actual)} to equal \${JSON.stringify(expected)}\`);
-        }
+      async toContainText(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toContainText", expected, false, options?.timeout]);
       },
-      toBeTruthy() {
-        if (!actual) throw new Error(\`Expected \${JSON.stringify(actual)} to be truthy\`);
+      async toHaveValue(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, false, options?.timeout]);
       },
-      toBeFalsy() {
-        if (actual) throw new Error(\`Expected \${JSON.stringify(actual)} to be falsy\`);
+      async toBeEnabled(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout]);
       },
-      toContain(expected) {
-        if (typeof actual === 'string' && !actual.includes(expected)) {
-          throw new Error(\`Expected "\${actual}" to contain "\${expected}"\`);
-        }
-        if (Array.isArray(actual) && !actual.includes(expected)) {
-          throw new Error(\`Expected array to contain \${JSON.stringify(expected)}\`);
-        }
+      async toBeChecked(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout]);
       },
       not: {
-        toBe(expected) {
-          if (actual === expected) throw new Error(\`Expected \${JSON.stringify(actual)} to not be \${JSON.stringify(expected)}\`);
+        async toBeVisible(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeVisible", null, true, options?.timeout]);
         },
-        toEqual(expected) {
-          if (JSON.stringify(actual) === JSON.stringify(expected)) {
-            throw new Error(\`Expected \${JSON.stringify(actual)} to not equal \${JSON.stringify(expected)}\`);
-          }
+        async toContainText(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toContainText", expected, true, options?.timeout]);
         },
-        toBeTruthy() {
-          if (actual) throw new Error(\`Expected \${JSON.stringify(actual)} to not be truthy\`);
+        async toHaveValue(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, true, options?.timeout]);
         },
-        toBeFalsy() {
-          if (!actual) throw new Error(\`Expected \${JSON.stringify(actual)} to not be falsy\`);
+        async toBeEnabled(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout]);
         },
-        toContain(expected) {
-          if (typeof actual === 'string' && actual.includes(expected)) {
-            throw new Error(\`Expected "\${actual}" to not contain "\${expected}"\`);
-          }
-          if (Array.isArray(actual) && actual.includes(expected)) {
-            throw new Error(\`Expected array to not contain \${JSON.stringify(expected)}\`);
-          }
+        async toBeChecked(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout]);
         },
-      },
+      }
     };
-  };
+
+    // Merge locator matchers with base matchers from test-environment
+    if (baseMatchers) {
+      return {
+        ...baseMatchers,
+        ...locatorMatchers,
+        not: { ...baseMatchers.not, ...locatorMatchers.not }
+      };
+    }
+    return locatorMatchers;
+  }
+
+  // Only extend expect if test-environment already defined it
+  if (typeof globalThis.expect === 'function') {
+    const originalExpect = globalThis.expect;
+    globalThis.expect = function(actual) {
+      const baseMatchers = originalExpect(actual);
+      // If actual is a Locator, add locator-specific matchers
+      if (actual && actual.constructor && actual.constructor.name === 'Locator') {
+        return createLocatorMatchers(actual, baseMatchers);
+      }
+      return baseMatchers;
+    };
+  }
+  // If test-environment not loaded, expect remains undefined
 })();
 `);
   return {
     dispose() {
-      page.off("request", requestHandler);
-      page.off("response", responseHandler);
-      page.off("console", consoleHandler);
-      consoleLogs.length = 0;
+      if (page && requestHandler && responseHandler && consoleHandler) {
+        page.off("request", requestHandler);
+        page.off("response", responseHandler);
+        page.off("console", consoleHandler);
+      }
+      browserConsoleLogs.length = 0;
       networkRequests.length = 0;
       networkResponses.length = 0;
     },
-    getConsoleLogs() {
-      return [...consoleLogs];
+    getBrowserConsoleLogs() {
+      return [...browserConsoleLogs];
     },
     getNetworkRequests() {
       return [...networkRequests];
@@ -714,24 +627,12 @@ async function setupPlaywright(context, options) {
       return [...networkResponses];
     },
     clearCollected() {
-      consoleLogs.length = 0;
+      browserConsoleLogs.length = 0;
       networkRequests.length = 0;
       networkResponses.length = 0;
     }
   };
 }
-async function runPlaywrightTests(context) {
-  const runTestsRef = context.global.getSync("__runPlaywrightTests", {
-    reference: true
-  });
-  const resultJson = await runTestsRef.apply(undefined, [], {
-    result: { promise: true }
-  });
-  return JSON.parse(resultJson);
-}
-async function resetPlaywrightTests(context) {
-  context.evalSync("__resetPlaywrightTests()");
-}
 })
 
-//# debugId=B798FB5EEEDF725764756E2164756E21
+//# debugId=4D1ABAEF45F490EA64756E2164756E21