@ricsam/isolate 0.0.1 → 0.1.0

package/dist/mjs/internal/playwright/index.mjs

@@ -0,0 +1,1234 @@
+// packages/isolate/src/internal/playwright/index.ts
+import ivm from "isolated-vm";
+import {
+  DEFAULT_PLAYWRIGHT_HANDLER_META
+} from "./types.mjs";
+import {
+  createPlaywrightHandler,
+  defaultPlaywrightHandler,
+  getDefaultPlaywrightHandlerMetadata
+} from "./handler.mjs";
+import {
+  createPlaywrightHandler as createPlaywrightHandler2,
+  getDefaultPlaywrightHandlerMetadata as getDefaultPlaywrightHandlerMetadata2
+} from "./handler.mjs";
+function wrapHandlerWithPredicateSupport(handler, evaluatePredicate, defaultTimeout) {
+  return async (op) => {
+    switch (op.type) {
+      case "waitForURLPredicate": {
+        const [predicateId, customTimeout, waitUntil] = op.args;
+        const effectiveTimeout = customTimeout ?? defaultTimeout;
+        const startTime = Date.now();
+        const pollInterval = 100;
+        while (true) {
+          const urlResult = await handler({ type: "url", args: [], pageId: op.pageId, contextId: op.contextId });
+          if (urlResult.ok) {
+            try {
+              if (evaluatePredicate(predicateId, urlResult.value)) {
+                return { ok: true };
+              }
+            } catch (e) {
+              const error = e;
+              return { ok: false, error: { name: error.name, message: error.message } };
+            }
+          }
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for URL` } };
+          }
+          await new Promise((r) => setTimeout(r, pollInterval));
+        }
+      }
+      case "waitForResponsePredicateFinish": {
+        const [initialListenerId, predicateId, customTimeout] = op.args;
+        const effectiveTimeout = customTimeout ?? defaultTimeout;
+        const broadMatcher = { type: "regex", value: { $regex: ".*", $flags: "" } };
+        const startTime = Date.now();
+        let currentListenerId = initialListenerId;
+        while (true) {
+          const finishResult = await handler({
+            type: "waitForResponseFinish",
+            args: [currentListenerId],
+            pageId: op.pageId,
+            contextId: op.contextId
+          });
+          if (!finishResult.ok)
+            return finishResult;
+          const responseData = finishResult.value;
+          try {
+            const serialized = {
+              method: "",
+              headers: Object.entries(responseData.headers || {}),
+              url: responseData.url,
+              status: responseData.status,
+              statusText: responseData.statusText,
+              body: responseData.text || ""
+            };
+            if (evaluatePredicate(predicateId, serialized)) {
+              return finishResult;
+            }
+          } catch (e) {
+            const error = e;
+            return { ok: false, error: { name: error.name, message: error.message } };
+          }
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for response` } };
+          }
+          const remainingTimeout = effectiveTimeout > 0 ? Math.max(1, effectiveTimeout - (Date.now() - startTime)) : effectiveTimeout;
+          const nextStartResult = await handler({
+            type: "waitForResponseStart",
+            args: [broadMatcher, remainingTimeout],
+            pageId: op.pageId,
+            contextId: op.contextId
+          });
+          if (!nextStartResult.ok)
+            return nextStartResult;
+          currentListenerId = nextStartResult.value.listenerId;
+        }
+      }
+      case "waitForRequestPredicateFinish": {
+        const [initialListenerId, predicateId, customTimeout] = op.args;
+        const effectiveTimeout = customTimeout ?? defaultTimeout;
+        const broadMatcher = { type: "regex", value: { $regex: ".*", $flags: "" } };
+        const startTime = Date.now();
+        let currentListenerId = initialListenerId;
+        while (true) {
+          const finishResult = await handler({
+            type: "waitForRequestFinish",
+            args: [currentListenerId],
+            pageId: op.pageId,
+            contextId: op.contextId
+          });
+          if (!finishResult.ok)
+            return finishResult;
+          const requestData = finishResult.value;
+          try {
+            const serialized = {
+              method: requestData.method,
+              headers: Object.entries(requestData.headers || {}),
+              url: requestData.url,
+              body: requestData.postData || ""
+            };
+            if (evaluatePredicate(predicateId, serialized)) {
+              return finishResult;
+            }
+          } catch (e) {
+            const error = e;
+            return { ok: false, error: { name: error.name, message: error.message } };
+          }
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for request` } };
+          }
+          const remainingTimeout = effectiveTimeout > 0 ? Math.max(1, effectiveTimeout - (Date.now() - startTime)) : effectiveTimeout;
+          const nextStartResult = await handler({
+            type: "waitForRequestStart",
+            args: [broadMatcher, remainingTimeout],
+            pageId: op.pageId,
+            contextId: op.contextId
+          });
+          if (!nextStartResult.ok)
+            return nextStartResult;
+          currentListenerId = nextStartResult.value.listenerId;
+        }
+      }
+      default:
+        return handler(op);
+    }
+  };
+}
+async function setupPlaywright(context, options) {
+  const timeout = options.timeout ?? 30000;
+  const explicitPage = "page" in options ? options.page : undefined;
+  const handler = "handler" in options ? options.handler : undefined;
+  const handlerMetadata = handler ? getDefaultPlaywrightHandlerMetadata2(handler) : undefined;
+  const page = explicitPage ?? handlerMetadata?.page;
+  const createPage = "createPage" in options ? options.createPage : undefined;
+  const createContext = "createContext" in options ? options.createContext : undefined;
+  const readFile = "readFile" in options ? options.readFile : undefined;
+  const writeFile = "writeFile" in options ? options.writeFile : undefined;
+  if (!handler && !page) {
+    throw new Error("Either page or handler must be provided to setupPlaywright");
+  }
+  const browserConsoleLogs = [];
+  const pageErrors = [];
+  const networkRequests = [];
+  const networkResponses = [];
+  const requestFailures = [];
+  const global = context.global;
+  let requestHandler;
+  let responseHandler;
+  let requestFailedHandler;
+  let consoleHandler;
+  let pageErrorHandler;
+  if (page) {
+    const onEvent = "onEvent" in options ? options.onEvent : undefined;
+    const requestIds = new WeakMap;
+    let nextRequestId = 1;
+    const getRequestId = (request) => {
+      let requestId = requestIds.get(request);
+      if (!requestId) {
+        requestId = `req_${nextRequestId++}`;
+        requestIds.set(request, requestId);
+      }
+      return requestId;
+    };
+    const toLocation = (location) => {
+      if (!location || !location.url && location.lineNumber == null && location.columnNumber == null) {
+        return;
+      }
+      return {
+        url: location.url || undefined,
+        lineNumber: location.lineNumber != null ? location.lineNumber + 1 : undefined,
+        columnNumber: location.columnNumber != null ? location.columnNumber + 1 : undefined
+      };
+    };
+    requestHandler = (request) => {
+      const info = {
+        requestId: getRequestId(request),
+        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",
+          requestId: info.requestId,
+          url: info.url,
+          method: info.method,
+          headers: info.headers,
+          postData: info.postData,
+          resourceType: info.resourceType,
+          timestamp: info.timestamp
+        });
+      }
+    };
+    responseHandler = (response) => {
+      const request = response.request();
+      const info = {
+        requestId: getRequestId(request),
+        url: response.url(),
+        status: response.status(),
+        statusText: response.statusText(),
+        headers: response.headers(),
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      networkResponses.push(info);
+      if (onEvent) {
+        onEvent({
+          type: "networkResponse",
+          requestId: info.requestId,
+          url: info.url,
+          status: info.status,
+          statusText: info.statusText,
+          headers: info.headers,
+          resourceType: info.resourceType,
+          timestamp: info.timestamp
+        });
+      }
+    };
+    requestFailedHandler = (request) => {
+      const info = {
+        requestId: getRequestId(request),
+        url: request.url(),
+        method: request.method(),
+        failureText: request.failure()?.errorText || "request failed",
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      requestFailures.push(info);
+      if (onEvent) {
+        onEvent({
+          type: "requestFailure",
+          requestId: info.requestId,
+          url: info.url,
+          method: info.method,
+          failureText: info.failureText,
+          resourceType: info.resourceType,
+          timestamp: info.timestamp
+        });
+      }
+    };
+    consoleHandler = (msg) => {
+      const args = msg.args().map((arg) => String(arg));
+      const entry = {
+        level: msg.type(),
+        stdout: args.join(" "),
+        location: toLocation(msg.location()),
+        timestamp: Date.now()
+      };
+      browserConsoleLogs.push(entry);
+      if (onEvent) {
+        onEvent({
+          type: "browserConsoleLog",
+          level: entry.level,
+          stdout: entry.stdout,
+          location: entry.location,
+          timestamp: entry.timestamp
+        });
+      }
+      if ("console" in options && options.console) {
+        const prefix = `[browser:${entry.level}]`;
+        console.log(prefix, entry.stdout);
+      }
+    };
+    pageErrorHandler = (error) => {
+      const entry = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        timestamp: Date.now()
+      };
+      pageErrors.push(entry);
+      if (onEvent) {
+        onEvent({
+          type: "pageError",
+          name: entry.name,
+          message: entry.message,
+          stack: entry.stack,
+          timestamp: entry.timestamp
+        });
+      }
+    };
+    page.on("request", requestHandler);
+    page.on("response", responseHandler);
+    page.on("requestfailed", requestFailedHandler);
+    page.on("console", consoleHandler);
+    page.on("pageerror", pageErrorHandler);
+  }
+  context.evalSync(`
+(function() {
+  globalThis.__pw_invoke = async function(type, args, options) {
+    const op = JSON.stringify({ type, args, pageId: options?.pageId, contextId: options?.contextId });
+    const resultJson = await __Playwright_handler_ref.apply(
+      undefined,
+      [op],
+      { result: { promise: true, copy: true } }
+    );
+    const result = JSON.parse(resultJson);
+    if (result.ok) {
+      return result.value;
+    }
+    const error = new Error(result.error.message);
+    error.name = result.error.name;
+    throw error;
+  };
+})();
+`);
+  context.evalSync(`
+(function() {
+  const __pw_predicates = new Map();
+  let __pw_next_id = 0;
+  globalThis.__pw_register_predicate = function(fn) {
+    const id = __pw_next_id++;
+    __pw_predicates.set(id, fn);
+    return id;
+  };
+  globalThis.__pw_unregister_predicate = function(id) {
+    __pw_predicates.delete(id);
+  };
+  globalThis.__pw_evaluate_predicate = function(id, data) {
+    const fn = __pw_predicates.get(id);
+    if (!fn) throw new Error('Predicate not found: ' + id);
+    const result = fn(data);
+    if (result && typeof result === 'object' && typeof result.then === 'function') {
+      throw new Error('Async predicates are not supported. Use a synchronous predicate function.');
+    }
+    return !!result;
+  };
+})();
+`);
+  const evaluatePredicateRef = context.global.getSync("__pw_evaluate_predicate", { reference: true });
+  const evaluatePredicateFn = (predicateId, data) => {
+    return evaluatePredicateRef.applySync(undefined, [new ivm.ExternalCopy(predicateId).copyInto(), new ivm.ExternalCopy(data).copyInto()]);
+  };
+  let effectiveHandler;
+  if (handler && handlerMetadata?.page) {
+    effectiveHandler = createPlaywrightHandler2(handlerMetadata.page, {
+      ...handlerMetadata.options,
+      evaluatePredicate: evaluatePredicateFn
+    });
+  } else if (handler) {
+    effectiveHandler = wrapHandlerWithPredicateSupport(handler, evaluatePredicateFn, timeout);
+  } else if (page) {
+    effectiveHandler = createPlaywrightHandler2(page, {
+      timeout,
+      readFile,
+      writeFile,
+      createPage,
+      createContext,
+      evaluatePredicate: evaluatePredicateFn
+    });
+  } else {
+    throw new Error("Either page or handler must be provided to setupPlaywright");
+  }
+  global.setSync("__Playwright_handler_ref", new ivm.Reference(async (opJson) => {
+    const op = JSON.parse(opJson);
+    const result = await effectiveHandler(op);
+    return JSON.stringify(result);
+  }));
+  context.evalSync(`
+(function() {
+  // IsolatePage class - represents a page with a specific pageId
+  class IsolatePage {
+    #pageId; #contextId;
+    constructor(pageId, contextId) {
+      this.#pageId = pageId;
+      this.#contextId = contextId;
+    }
+    get __isPage() { return true; }
+    get __pageId() { return this.#pageId; }
+    get __contextId() { return this.#contextId; }
+
+    async goto(url, options) {
+      await __pw_invoke("goto", [url, options?.waitUntil || null], { pageId: this.#pageId });
+    }
+    async reload() {
+      await __pw_invoke("reload", [], { pageId: this.#pageId });
+    }
+    async url() { return __pw_invoke("url", [], { pageId: this.#pageId }); }
+    async title() { return __pw_invoke("title", [], { pageId: this.#pageId }); }
+    async content() { return __pw_invoke("content", [], { pageId: this.#pageId }); }
+    async waitForSelector(selector, options) {
+      return __pw_invoke("waitForSelector", [selector, options ? JSON.stringify(options) : null], { pageId: this.#pageId });
+    }
+    async waitForTimeout(ms) { return __pw_invoke("waitForTimeout", [ms], { pageId: this.#pageId }); }
+    async waitForLoadState(state) { return __pw_invoke("waitForLoadState", [state || null], { pageId: this.#pageId }); }
+    async evaluate(script, arg) {
+      const hasArg = arguments.length > 1;
+      if (hasArg) {
+        const serialized = typeof script === "function" ? script.toString() : script;
+        return __pw_invoke("evaluate", [serialized, arg], { pageId: this.#pageId });
+      }
+      const serialized = typeof script === "function" ? "(" + script.toString() + ")()" : script;
+      return __pw_invoke("evaluate", [serialized], { pageId: this.#pageId });
+    }
+    locator(selector) { return new Locator("css", selector, null, this.#pageId); }
+    getByRole(role, options) {
+      if (options) {
+        const serialized = { ...options };
+        const name = options.name;
+        if (name && typeof name === 'object' && typeof name.source === 'string' && typeof name.flags === 'string') {
+          serialized.name = { $regex: name.source, $flags: name.flags };
+        }
+        return new Locator("role", role, JSON.stringify(serialized), this.#pageId);
+      }
+      return new Locator("role", role, null, this.#pageId);
+    }
+    getByText(text) { return new Locator("text", text, null, this.#pageId); }
+    getByLabel(label) { return new Locator("label", label, null, this.#pageId); }
+    getByPlaceholder(p) { return new Locator("placeholder", p, null, this.#pageId); }
+    getByTestId(id) { return new Locator("testId", id, null, this.#pageId); }
+    getByAltText(alt) { return new Locator("altText", alt, null, this.#pageId); }
+    getByTitle(title) { return new Locator("title", title, null, this.#pageId); }
+    frameLocator(selector) {
+      const pageId = this.#pageId;
+      return {
+        locator(innerSelector) { return new Locator("frame", JSON.stringify([["css", selector, null], ["css", innerSelector, null]]), null, pageId); },
+        getByRole(role, options) { return new Locator("frame", JSON.stringify([["css", selector, null], ["role", role, options ? JSON.stringify(options) : null]]), null, pageId); },
+        getByText(text) { return new Locator("frame", JSON.stringify([["css", selector, null], ["text", text, null]]), null, pageId); },
+        getByLabel(label) { return new Locator("frame", JSON.stringify([["css", selector, null], ["label", label, null]]), null, pageId); },
+        getByPlaceholder(placeholder) { return new Locator("frame", JSON.stringify([["css", selector, null], ["placeholder", placeholder, null]]), null, pageId); },
+        getByTestId(testId) { return new Locator("frame", JSON.stringify([["css", selector, null], ["testId", testId, null]]), null, pageId); },
+        getByAltText(alt) { return new Locator("frame", JSON.stringify([["css", selector, null], ["altText", alt, null]]), null, pageId); },
+        getByTitle(title) { return new Locator("frame", JSON.stringify([["css", selector, null], ["title", title, null]]), null, pageId); },
+      };
+    }
+    async goBack(options) {
+      await __pw_invoke("goBack", [options?.waitUntil || null], { pageId: this.#pageId });
+    }
+    async goForward(options) {
+      await __pw_invoke("goForward", [options?.waitUntil || null], { pageId: this.#pageId });
+    }
+    async waitForURL(url, options) {
+      if (typeof url === 'function') {
+        const predicateId = __pw_register_predicate(url);
+        try {
+          await __pw_invoke("waitForURLPredicate", [predicateId, options?.timeout || null, options?.waitUntil || null], { pageId: this.#pageId });
+        } finally {
+          __pw_unregister_predicate(predicateId);
+        }
+        return;
+      }
+      let serializedUrl;
+      if (typeof url === 'string') {
+        serializedUrl = { type: 'string', value: url };
+      } else if (url && typeof url === 'object' && typeof url.source === 'string' && typeof url.flags === 'string') {
+        serializedUrl = { type: 'regex', value: { $regex: url.source, $flags: url.flags } };
+      } else {
+        serializedUrl = url;
+      }
+      return __pw_invoke("waitForURL", [serializedUrl, options?.timeout || null, options?.waitUntil || null], { pageId: this.#pageId });
+    }
+    async waitForRequest(urlOrPredicate, options) {
+      if (typeof urlOrPredicate === 'function') {
+        const userPredicate = urlOrPredicate;
+        const wrappedPredicate = (data) => {
+          const requestLike = {
+            url: () => data.url,
+            method: () => data.method,
+            headers: () => Object.fromEntries(data.headers),
+            headersArray: () => data.headers.map(h => ({ name: h[0], value: h[1] })),
+            postData: () => data.body || null,
+          };
+          return userPredicate(requestLike);
+        };
+        const predicateId = __pw_register_predicate(wrappedPredicate);
+        const pageId = this.#pageId;
+        // Start listening immediately (before the user triggers the request)
+        const broadMatcher = { type: 'regex', value: { $regex: '.*', $flags: '' } };
+        const startResult = await __pw_invoke("waitForRequestStart", [broadMatcher, options?.timeout || null], { pageId });
+        const listenerId = startResult.listenerId;
+        try {
+          const r = await __pw_invoke("waitForRequestPredicateFinish", [listenerId, predicateId, options?.timeout || null], { pageId });
+          return { url: () => r.url, method: () => r.method, headers: () => r.headers, postData: () => r.postData };
+        } finally {
+          __pw_unregister_predicate(predicateId);
+        }
+      }
+      let serializedMatcher;
+      if (typeof urlOrPredicate === 'string') {
+        serializedMatcher = { type: 'string', value: urlOrPredicate };
+      } else if (urlOrPredicate && typeof urlOrPredicate === 'object'
+                 && typeof urlOrPredicate.source === 'string'
+                 && typeof urlOrPredicate.flags === 'string') {
+        serializedMatcher = { type: 'regex', value: { $regex: urlOrPredicate.source, $flags: urlOrPredicate.flags } };
+      } else {
+        throw new Error('waitForRequest requires a URL string, RegExp, or predicate function');
+      }
+      const startResult = await __pw_invoke("waitForRequestStart", [serializedMatcher, options?.timeout || null], { pageId: this.#pageId });
+      const listenerId = startResult.listenerId;
+      const pageId = this.#pageId;
+      const r = await __pw_invoke("waitForRequestFinish", [listenerId], { pageId });
+      return { url: () => r.url, method: () => r.method, headers: () => r.headers, postData: () => r.postData };
+    }
+    async waitForResponse(urlOrPredicate, options) {
+      if (typeof urlOrPredicate === 'function') {
+        const userPredicate = urlOrPredicate;
+        const wrappedPredicate = (data) => {
+          const responseLike = {
+            url: () => data.url,
+            status: () => data.status,
+            statusText: () => data.statusText,
+            headers: () => Object.fromEntries(data.headers),
+            headersArray: () => data.headers.map(h => ({ name: h[0], value: h[1] })),
+            ok: () => data.status >= 200 && data.status < 300,
+          };
+          return userPredicate(responseLike);
+        };
+        const predicateId = __pw_register_predicate(wrappedPredicate);
+        const pageId = this.#pageId;
+        // Start listening immediately (before the user triggers the response)
+        const broadMatcher = { type: 'regex', value: { $regex: '.*', $flags: '' } };
+        const startResult = await __pw_invoke("waitForResponseStart", [broadMatcher, options?.timeout || null], { pageId });
+        const listenerId = startResult.listenerId;
+        try {
+          const r = await __pw_invoke("waitForResponsePredicateFinish", [listenerId, predicateId, options?.timeout || null], { pageId });
+          return {
+            url: () => r.url, status: () => r.status, statusText: () => r.statusText,
+            headers: () => r.headers, headersArray: () => r.headersArray,
+            ok: () => r.ok, json: async () => r.json, text: async () => r.text, body: async () => r.body,
+          };
+        } finally {
+          __pw_unregister_predicate(predicateId);
+        }
+      }
+      let serializedMatcher;
+      if (typeof urlOrPredicate === 'string') {
+        serializedMatcher = { type: 'string', value: urlOrPredicate };
+      } else if (urlOrPredicate && typeof urlOrPredicate === 'object'
+                 && typeof urlOrPredicate.source === 'string'
+                 && typeof urlOrPredicate.flags === 'string') {
+        serializedMatcher = { type: 'regex', value: { $regex: urlOrPredicate.source, $flags: urlOrPredicate.flags } };
+      } else {
+        throw new Error('waitForResponse requires a URL string, RegExp, or predicate function');
+      }
+      const startResult = await __pw_invoke("waitForResponseStart", [serializedMatcher, options?.timeout || null], { pageId: this.#pageId });
+      const listenerId = startResult.listenerId;
+      const pageId = this.#pageId;
+      const r = await __pw_invoke("waitForResponseFinish", [listenerId], { pageId });
+      return {
+        url: () => r.url, status: () => r.status, statusText: () => r.statusText,
+        headers: () => r.headers, headersArray: () => r.headersArray,
+        ok: () => r.ok, json: async () => r.json, text: async () => r.text, body: async () => r.body,
+      };
+    }
+    context() {
+      const contextId = this.#contextId;
+      return new IsolateContext(contextId);
+    }
+    async click(selector) { return this.locator(selector).click(); }
+    async fill(selector, value) { return this.locator(selector).fill(value); }
+    async textContent(selector) { return this.locator(selector).textContent(); }
+    async innerText(selector) { return this.locator(selector).innerText(); }
+    async innerHTML(selector) { return this.locator(selector).innerHTML(); }
+    async getAttribute(selector, name) { return this.locator(selector).getAttribute(name); }
+    async inputValue(selector) { return this.locator(selector).inputValue(); }
+    async isVisible(selector) { return this.locator(selector).isVisible(); }
+    async isEnabled(selector) { return this.locator(selector).isEnabled(); }
+    async isChecked(selector) { return this.locator(selector).isChecked(); }
+    async isHidden(selector) { return this.locator(selector).isHidden(); }
+    async isDisabled(selector) { return this.locator(selector).isDisabled(); }
+    async screenshot(options) { return __pw_invoke("screenshot", [options || {}], { pageId: this.#pageId }); }
+    async setViewportSize(size) { return __pw_invoke("setViewportSize", [size], { pageId: this.#pageId }); }
+    async viewportSize() { return __pw_invoke("viewportSize", [], { pageId: this.#pageId }); }
+    async emulateMedia(options) { return __pw_invoke("emulateMedia", [options], { pageId: this.#pageId }); }
+    async setExtraHTTPHeaders(headers) { return __pw_invoke("setExtraHTTPHeaders", [headers], { pageId: this.#pageId }); }
+    async bringToFront() { return __pw_invoke("bringToFront", [], { pageId: this.#pageId }); }
+    async close() { return __pw_invoke("close", [], { pageId: this.#pageId }); }
+    async isClosed() { return __pw_invoke("isClosed", [], { pageId: this.#pageId }); }
+    async pdf(options) { return __pw_invoke("pdf", [options || {}], { pageId: this.#pageId }); }
+    async pause() { return __pw_invoke("pause", [], { pageId: this.#pageId }); }
+    async frames() { return __pw_invoke("frames", [], { pageId: this.#pageId }); }
+    async mainFrame() { return __pw_invoke("mainFrame", [], { pageId: this.#pageId }); }
+    get keyboard() {
+      const pageId = this.#pageId;
+      return {
+        async type(text, options) { return __pw_invoke("keyboardType", [text, options], { pageId }); },
+        async press(key, options) { return __pw_invoke("keyboardPress", [key, options], { pageId }); },
+        async down(key) { return __pw_invoke("keyboardDown", [key], { pageId }); },
+        async up(key) { return __pw_invoke("keyboardUp", [key], { pageId }); },
+        async insertText(text) { return __pw_invoke("keyboardInsertText", [text], { pageId }); }
+      };
+    }
+    get mouse() {
+      const pageId = this.#pageId;
+      return {
+        async move(x, y, options) { return __pw_invoke("mouseMove", [x, y, options], { pageId }); },
+        async click(x, y, options) { return __pw_invoke("mouseClick", [x, y, options], { pageId }); },
+        async down(options) { return __pw_invoke("mouseDown", [options], { pageId }); },
+        async up(options) { return __pw_invoke("mouseUp", [options], { pageId }); },
+        async wheel(deltaX, deltaY) { return __pw_invoke("mouseWheel", [deltaX, deltaY], { pageId }); }
+      };
+    }
+    get request() {
+      const pageId = this.#pageId;
+      return {
+        async fetch(url, options) {
+          const result = await __pw_invoke("request", [url, options?.method || "GET", options?.data, options?.headers], { pageId });
+          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" }); },
+      };
+    }
+  }
+  globalThis.IsolatePage = IsolatePage;
+
+  // IsolateContext class - represents a browser context with a specific contextId
+  class IsolateContext {
+    #contextId;
+    constructor(contextId) { this.#contextId = contextId; }
+    get __contextId() { return this.#contextId; }
+
+    async newPage() {
+      const result = await __pw_invoke("newPage", [], { contextId: this.#contextId });
+      return new IsolatePage(result.pageId, this.#contextId);
+    }
+    async close() { return __pw_invoke("closeContext", [], { contextId: this.#contextId }); }
+    async clearCookies() { return __pw_invoke("clearCookies", [], { contextId: this.#contextId }); }
+    async addCookies(cookies) { return __pw_invoke("addCookies", [cookies], { contextId: this.#contextId }); }
+    async cookies(urls) { return __pw_invoke("cookies", [urls], { contextId: this.#contextId }); }
+  }
+  globalThis.IsolateContext = IsolateContext;
+
+  // browser global - for creating new contexts
+  globalThis.browser = {
+    async newContext(options) {
+      const result = await __pw_invoke("newContext", [options || null]);
+      return new IsolateContext(result.contextId);
+    }
+  };
+
+  // context global - represents the default context
+  globalThis.context = new IsolateContext("ctx_0");
+
+  // page global - represents the default page
+  globalThis.page = new IsolatePage("page_0", "ctx_0");
+})();
+`);
+  context.evalSync(`
+(function() {
+  // Helper to serialize options including RegExp
+  function serializeOptions(options) {
+    if (!options) return null;
+    const serialized = { ...options };
+    if (options.name && typeof options.name === 'object' && typeof options.name.source === 'string' && typeof options.name.flags === 'string') {
+      serialized.name = { $regex: options.name.source, $flags: options.name.flags };
+    }
+    return JSON.stringify(serialized);
+  }
+
+  const INPUT_FILES_VALIDATION_ERROR =
+    "setInputFiles() expects a file path string, an array of file path strings, " +
+    "a single inline file object ({ name, mimeType, buffer }), or an array of inline file objects.";
+
+  function isInlineFileObject(value) {
+    return !!value
+      && typeof value === 'object'
+      && typeof value.name === 'string'
+      && typeof value.mimeType === 'string'
+      && 'buffer' in value;
+  }
+
+  function encodeInlineFileBuffer(buffer) {
+    if (typeof buffer === 'string') {
+      return buffer;
+    }
+    let bytes;
+    if (buffer instanceof ArrayBuffer) {
+      bytes = new Uint8Array(buffer);
+    } else if (ArrayBuffer.isView(buffer)) {
+      bytes = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    } else {
+      throw new Error(
+        "setInputFiles() inline file buffer must be a base64 string, ArrayBuffer, or TypedArray."
+      );
+    }
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+
+  function serializeInlineFile(file) {
+    return {
+      name: file.name,
+      mimeType: file.mimeType,
+      buffer: encodeInlineFileBuffer(file.buffer),
+    };
+  }
+
+  function normalizeSetInputFilesArg(files) {
+    if (typeof files === 'string') {
+      return files;
+    }
+    if (isInlineFileObject(files)) {
+      return serializeInlineFile(files);
+    }
+    if (!Array.isArray(files)) {
+      throw new Error(INPUT_FILES_VALIDATION_ERROR);
+    }
+    if (files.length === 0) {
+      return [];
+    }
+
+    let hasPaths = false;
+    let hasInline = false;
+    const inlineFiles = [];
+
+    for (const file of files) {
+      if (typeof file === 'string') {
+        hasPaths = true;
+        continue;
+      }
+      if (isInlineFileObject(file)) {
+        hasInline = true;
+        inlineFiles.push(serializeInlineFile(file));
+        continue;
+      }
+      throw new Error(INPUT_FILES_VALIDATION_ERROR);
+    }
+
+    if (hasPaths && hasInline) {
+      throw new Error(
+        "setInputFiles() does not support mixing file paths and inline file objects in the same array."
+      );
+    }
+    return hasInline ? inlineFiles : files;
+  }
+
+  class Locator {
+    #type; #value; #options; #pageId;
+    constructor(type, value, options, pageId) {
+      this.#type = type;
+      this.#value = value;
+      this.#options = options;
+      this.#pageId = pageId || "page_0";
+    }
+
+    _getInfo() { return [this.#type, this.#value, this.#options]; }
+    _getPageId() { return this.#pageId; }
+
+    // Helper to create a chained locator
+    _chain(childType, childValue, childOptions) {
+      const parentInfo = this._getInfo();
+      const childInfo = [childType, childValue, childOptions];
+      return new Locator("chained", JSON.stringify([parentInfo, childInfo]), null, this.#pageId);
+    }
+
+    async click() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "click", null], { pageId: this.#pageId });
+    }
+    async dblclick() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null], { pageId: this.#pageId });
+    }
+    async fill(text) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text], { pageId: this.#pageId });
+    }
+    async type(text) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text], { pageId: this.#pageId });
+    }
+    async check() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null], { pageId: this.#pageId });
+    }
+    async uncheck() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null], { pageId: this.#pageId });
+    }
+    async selectOption(value) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value], { pageId: this.#pageId });
+    }
+    async clear() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null], { pageId: this.#pageId });
+    }
+    async press(key) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key], { pageId: this.#pageId });
+    }
+    async hover() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null], { pageId: this.#pageId });
+    }
+    async focus() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null], { pageId: this.#pageId });
+    }
+    async textContent() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null], { pageId: this.#pageId });
+    }
+    async inputValue() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null], { pageId: this.#pageId });
+    }
+    async isVisible() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null], { pageId: this.#pageId });
+    }
+    async isEnabled() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null], { pageId: this.#pageId });
+    }
+    async isChecked() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null], { pageId: this.#pageId });
+    }
+    async count() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null], { pageId: this.#pageId });
+    }
+    async getAttribute(name) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getAttribute", name], { pageId: this.#pageId });
+    }
+    async isDisabled() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isDisabled", null], { pageId: this.#pageId });
+    }
+    async isHidden() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isHidden", null], { pageId: this.#pageId });
+    }
+    async innerHTML() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerHTML", null], { pageId: this.#pageId });
+    }
+    async innerText() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerText", null], { pageId: this.#pageId });
+    }
+    async allTextContents() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allTextContents", null], { pageId: this.#pageId });
+    }
+    async allInnerTexts() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allInnerTexts", null], { pageId: this.#pageId });
+    }
+    async waitFor(options) {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "waitFor", options || {}], { pageId: this.#pageId });
+    }
+    async boundingBox() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "boundingBox", null], { pageId: this.#pageId });
+    }
+    async setInputFiles(files) {
+      const serializedFiles = normalizeSetInputFilesArg(files);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "setInputFiles", serializedFiles], { pageId: this.#pageId });
+    }
+    async screenshot(options) {
+      const base64 = await __pw_invoke("locatorAction", [...this._getInfo(), "screenshot", options || {}], { pageId: this.#pageId });
+      return base64;
+    }
+    async dragTo(target) {
+      const targetInfo = target._getInfo();
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dragTo", targetInfo], { pageId: this.#pageId });
+    }
+    async scrollIntoViewIfNeeded() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "scrollIntoViewIfNeeded", null], { pageId: this.#pageId });
+    }
+    async highlight() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "highlight", null], { pageId: this.#pageId });
+    }
+    async evaluate(fn, arg) {
+      const fnString = typeof fn === 'function' ? fn.toString() : fn;
+      return __pw_invoke("locatorAction", [...this._getInfo(), "evaluate", [fnString, arg]], { pageId: this.#pageId });
+    }
+    async evaluateAll(fn, arg) {
+      const fnString = typeof fn === 'function' ? fn.toString() : fn;
+      return __pw_invoke("locatorAction", [...this._getInfo(), "evaluateAll", [fnString, arg]], { pageId: this.#pageId });
+    }
+    locator(selector) {
+      return this._chain("css", selector, null);
+    }
+    // Chaining: getBy* methods within a locator
+    getByRole(role, options) {
+      return this._chain("role", role, serializeOptions(options));
+    }
+    getByText(text) {
+      return this._chain("text", text, null);
+    }
+    getByLabel(label) {
+      return this._chain("label", label, null);
+    }
+    getByPlaceholder(placeholder) {
+      return this._chain("placeholder", placeholder, null);
+    }
+    getByTestId(testId) {
+      return this._chain("testId", testId, null);
+    }
+    getByAltText(altText) {
+      return this._chain("altText", altText, null);
+    }
+    getByTitle(title) {
+      return this._chain("title", title, null);
+    }
+    async all() {
+      const n = await this.count();
+      const result = [];
+      for (let i = 0; i < n; i++) {
+        result.push(this.nth(i));
+      }
+      return result;
+    }
+    nth(index) {
+      const existingOpts = this.#options ? JSON.parse(this.#options) : {};
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }), this.#pageId);
+    }
+    first() {
+      return this.nth(0);
+    }
+    last() {
+      return this.nth(-1);
+    }
+    filter(options) {
+      const existingOpts = this.#options ? JSON.parse(this.#options) : {};
+      const serializedFilter = { ...options };
+      // Use duck-typing RegExp detection (instanceof fails across isolated-vm boundary)
+      const hasText = options.hasText;
+      if (hasText && typeof hasText === 'object' && typeof hasText.source === 'string' && typeof hasText.flags === 'string') {
+        serializedFilter.hasText = { $regex: hasText.source, $flags: hasText.flags };
+      }
+      const hasNotText = options.hasNotText;
+      if (hasNotText && typeof hasNotText === 'object' && typeof hasNotText.source === 'string' && typeof hasNotText.flags === 'string') {
+        serializedFilter.hasNotText = { $regex: hasNotText.source, $flags: hasNotText.flags };
+      }
+      // Serialize has/hasNot locators using duck-typing
+      const has = options.has;
+      if (has && typeof has === 'object' && typeof has._getInfo === 'function') {
+        serializedFilter.has = { $locator: has._getInfo() };
+      }
+      const hasNot = options.hasNot;
+      if (hasNot && typeof hasNot === 'object' && typeof hasNot._getInfo === 'function') {
+        serializedFilter.hasNot = { $locator: hasNot._getInfo() };
+      }
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, filter: serializedFilter }), this.#pageId);
+    }
+    or(other) {
+      // Create a composite locator that matches either this or other
+      const thisInfo = this._getInfo();
+      const otherInfo = other._getInfo();
+      return new Locator("or", JSON.stringify([thisInfo, otherInfo]), null, this.#pageId);
+    }
+    and(other) {
+      // Create a composite locator that matches both this and other
+      const thisInfo = this._getInfo();
+      const otherInfo = other._getInfo();
+      return new Locator("and", JSON.stringify([thisInfo, otherInfo]), null, this.#pageId);
+    }
+  }
+  globalThis.Locator = Locator;
+})();
+`);
+  context.evalSync(`
+(function() {
+  // Helper to create locator matchers
+  function createLocatorMatchers(locator, baseMatchers) {
+    const info = locator._getInfo();
+    const pageId = locator._getPageId ? locator._getPageId() : "page_0";
+
+    // Helper for serializing regex values
+    function serializeExpected(expected) {
+      if (expected instanceof RegExp) {
+        return { $regex: expected.source, $flags: expected.flags };
+      }
+      return expected;
+    }
+
+    const locatorMatchers = {
+      async toBeVisible(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeVisible", null, false, options?.timeout], { pageId });
+      },
+      async toContainText(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toContainText", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveValue(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, false, options?.timeout], { pageId });
+      },
+      async toBeEnabled(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout], { pageId });
+      },
+      async toBeChecked(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout], { pageId });
+      },
+      async toHaveAttribute(name, value, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, false, options?.timeout], { pageId });
+      },
+      async toHaveText(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveText", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveCount(count, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveCount", count, false, options?.timeout], { pageId });
+      },
+      async toBeHidden(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeHidden", null, false, options?.timeout], { pageId });
+      },
+      async toBeDisabled(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, false, options?.timeout], { pageId });
+      },
+      async toBeFocused(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeFocused", null, false, options?.timeout], { pageId });
+      },
+      async toBeEmpty(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, false, options?.timeout], { pageId });
+      },
+      // New matchers
+      async toBeAttached(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeAttached", null, false, options?.timeout], { pageId });
+      },
+      async toBeEditable(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeEditable", null, false, options?.timeout], { pageId });
+      },
+      async toHaveClass(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveClass", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toContainClass(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toContainClass", expected, false, options?.timeout], { pageId });
+      },
+      async toHaveId(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveId", expected, false, options?.timeout], { pageId });
+      },
+      async toBeInViewport(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeInViewport", null, false, options?.timeout], { pageId });
+      },
+      async toHaveCSS(name, value, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveCSS", { name, value: serializeExpected(value) }, false, options?.timeout], { pageId });
+      },
+      async toHaveJSProperty(name, value, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveJSProperty", { name, value }, false, options?.timeout], { pageId });
+      },
+      async toHaveAccessibleName(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveAccessibleName", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveAccessibleDescription(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveAccessibleDescription", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveRole(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveRole", expected, false, options?.timeout], { pageId });
+      },
+      not: {
+        async toBeVisible(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeVisible", null, true, options?.timeout], { pageId });
+        },
+        async toContainText(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toContainText", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveValue(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, true, options?.timeout], { pageId });
+        },
+        async toBeEnabled(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout], { pageId });
+        },
+        async toBeChecked(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout], { pageId });
+        },
+        async toHaveAttribute(name, value, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, true, options?.timeout], { pageId });
+        },
+        async toHaveText(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveText", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveCount(count, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveCount", count, true, options?.timeout], { pageId });
+        },
+        async toBeHidden(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeHidden", null, true, options?.timeout], { pageId });
+        },
+        async toBeDisabled(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, true, options?.timeout], { pageId });
+        },
+        async toBeFocused(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeFocused", null, true, options?.timeout], { pageId });
+        },
+        async toBeEmpty(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, true, options?.timeout], { pageId });
+        },
+        // New negated matchers
+        async toBeAttached(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeAttached", null, true, options?.timeout], { pageId });
+        },
+        async toBeEditable(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeEditable", null, true, options?.timeout], { pageId });
+        },
+        async toHaveClass(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveClass", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toContainClass(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toContainClass", expected, true, options?.timeout], { pageId });
+        },
+        async toHaveId(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveId", expected, true, options?.timeout], { pageId });
+        },
+        async toBeInViewport(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeInViewport", null, true, options?.timeout], { pageId });
+        },
+        async toHaveCSS(name, value, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveCSS", { name, value: serializeExpected(value) }, true, options?.timeout], { pageId });
+        },
+        async toHaveJSProperty(name, value, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveJSProperty", { name, value }, true, options?.timeout], { pageId });
+        },
+        async toHaveAccessibleName(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveAccessibleName", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveAccessibleDescription(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveAccessibleDescription", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveRole(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveRole", expected, true, options?.timeout], { pageId });
+        },
+      }
+    };
+
+    // Merge locator matchers with base matchers from test-environment
+    if (baseMatchers) {
+      return {
+        ...baseMatchers,
+        ...locatorMatchers,
+        not: { ...baseMatchers.not, ...locatorMatchers.not }
+      };
+    }
+    return locatorMatchers;
+  }
+
+  // Helper to create page matchers
+  function createPageMatchers(page, baseMatchers) {
+    const pageId = page.__pageId || "page_0";
+
+    function serializeExpected(expected) {
+      if (expected instanceof RegExp) {
+        return { $regex: expected.source, $flags: expected.flags };
+      }
+      return expected;
+    }
+
+    const pageMatchers = {
+      async toHaveURL(expected, options) {
+        return __pw_invoke("expectPage", ["toHaveURL", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveTitle(expected, options) {
+        return __pw_invoke("expectPage", ["toHaveTitle", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      not: {
+        async toHaveURL(expected, options) {
+          return __pw_invoke("expectPage", ["toHaveURL", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveTitle(expected, options) {
+          return __pw_invoke("expectPage", ["toHaveTitle", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+      }
+    };
+
+    if (baseMatchers) {
+      return {
+        ...baseMatchers,
+        ...pageMatchers,
+        not: { ...baseMatchers.not, ...pageMatchers.not }
+      };
+    }
+    return pageMatchers;
+  }
+
+  // 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);
+      }
+      // If actual is the page object (IsolatePage), add page-specific matchers
+      if (actual && actual.__isPage === true) {
+        return createPageMatchers(actual, baseMatchers);
+      }
+      return baseMatchers;
+    };
+  }
+  // If test-environment not loaded, expect remains undefined
+})();
+`);
+  return {
+    dispose() {
+      if (page && requestHandler && responseHandler && requestFailedHandler && consoleHandler && pageErrorHandler) {
+        page.off("request", requestHandler);
+        page.off("response", responseHandler);
+        page.off("requestfailed", requestFailedHandler);
+        page.off("console", consoleHandler);
+        page.off("pageerror", pageErrorHandler);
+      }
+      browserConsoleLogs.length = 0;
+      pageErrors.length = 0;
+      networkRequests.length = 0;
+      networkResponses.length = 0;
+      requestFailures.length = 0;
+    },
+    getBrowserConsoleLogs() {
+      return [...browserConsoleLogs];
+    },
+    getPageErrors() {
+      return [...pageErrors];
+    },
+    getNetworkRequests() {
+      return [...networkRequests];
+    },
+    getNetworkResponses() {
+      return [...networkResponses];
+    },
+    getRequestFailures() {
+      return [...requestFailures];
+    },
+    clearCollected() {
+      browserConsoleLogs.length = 0;
+      pageErrors.length = 0;
+      networkRequests.length = 0;
+      networkResponses.length = 0;
+      requestFailures.length = 0;
+    }
+  };
+}
+export {
+  setupPlaywright,
+  getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler,
+  createPlaywrightHandler,
+  DEFAULT_PLAYWRIGHT_HANDLER_META
+};
+
+//# debugId=58FDD2912C4D791E64756E2164756E21