@ricsam/isolate-playwright 0.1.12 → 0.1.14

package/dist/mjs/index.mjs

@@ -1,445 +1,151 @@
 // packages/playwright/src/index.ts
 import ivm from "isolated-vm";
-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;
-    delete roleOptions.filter;
-    if (roleOptions.name && typeof roleOptions.name === "object" && roleOptions.name.$regex) {
-      roleOptions.name = new RegExp(roleOptions.name.$regex, roleOptions.name.$flags);
-    }
-  }
-  let locator;
-  switch (selectorType) {
-    case "css":
-      locator = page.locator(selectorValue);
-      break;
-    case "role":
-      locator = page.getByRole(selectorValue, roleOptions && Object.keys(roleOptions).length > 0 ? roleOptions : undefined);
-      break;
-    case "text":
-      locator = page.getByText(selectorValue);
-      break;
-    case "label":
-      locator = page.getByLabel(selectorValue);
-      break;
-    case "placeholder":
-      locator = page.getByPlaceholder(selectorValue);
-      break;
-    case "testId":
-      locator = page.getByTestId(selectorValue);
-      break;
-    case "or": {
-      const [firstInfo, secondInfo] = JSON.parse(selectorValue);
-      const first = getLocator(page, firstInfo[0], firstInfo[1], firstInfo[2]);
-      const second = getLocator(page, secondInfo[0], secondInfo[1], secondInfo[2]);
-      locator = first.or(second);
-      break;
-    }
-    default:
-      locator = page.locator(selectorValue);
-  }
-  if (nthIndex !== undefined) {
-    locator = locator.nth(nthIndex);
-  }
-  if (options?.filter) {
-    const filterOpts = { ...options.filter };
-    if (filterOpts.hasText && typeof filterOpts.hasText === "object" && filterOpts.hasText.$regex) {
-      filterOpts.hasText = new RegExp(filterOpts.hasText.$regex, filterOpts.hasText.$flags);
-    }
-    if (filterOpts.hasNotText && typeof filterOpts.hasNotText === "object" && filterOpts.hasNotText.$regex) {
-      filterOpts.hasNotText = new RegExp(filterOpts.hasNotText.$regex, filterOpts.hasNotText.$flags);
-    }
-    locator = locator.filter(filterOpts);
-  }
-  return locator;
-}
-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();
-    case "getAttribute":
-      return await locator.getAttribute(String(actionArg ?? ""), { timeout });
-    case "isDisabled":
-      return await locator.isDisabled();
-    case "isHidden":
-      return await locator.isHidden();
-    case "innerHTML":
-      return await locator.innerHTML({ timeout });
-    case "innerText":
-      return await locator.innerText({ timeout });
-    case "allTextContents":
-      return await locator.allTextContents();
-    case "allInnerTexts":
-      return await locator.allInnerTexts();
-    case "waitFor": {
-      const opts = actionArg && typeof actionArg === "object" ? actionArg : {};
-      await locator.waitFor({ state: opts.state, timeout: opts.timeout ?? timeout });
-      return null;
-    }
-    case "boundingBox":
-      return await locator.boundingBox({ timeout });
-    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 (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");
-      }
-      break;
-    }
-    case "toContainText": {
-      const text = await locator.textContent({ timeout });
-      let matches;
-      let expectedDisplay;
-      if (expected && typeof expected === "object" && expected.$regex) {
-        const regex = new RegExp(expected.$regex, expected.$flags);
-        matches = regex.test(text ?? "");
-        expectedDisplay = String(regex);
-      } else {
-        matches = text?.includes(String(expected)) ?? false;
-        expectedDisplay = String(expected);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected text to not contain ${expectedDisplay}, but got "${text}"`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected text to contain ${expectedDisplay}, but got "${text}"`);
-      }
-      break;
-    }
-    case "toHaveValue": {
-      const value = await locator.inputValue({ timeout });
-      const matches = value === String(expected);
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected value to not be "${expected}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected value to be "${expected}", but got "${value}"`);
-      }
-      break;
-    }
-    case "toBeEnabled": {
-      const isEnabled = await locator.isEnabled();
-      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");
-      }
-      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");
-      }
-      break;
-    }
-    case "toHaveAttribute": {
-      const { name, value } = expected;
-      const actual = await locator.getAttribute(name, { timeout });
-      if (value instanceof RegExp || value && typeof value === "object" && value.$regex) {
-        const regex = value.$regex ? new RegExp(value.$regex, value.$flags) : value;
-        const matches = regex.test(actual ?? "");
-        if (negated) {
-          if (matches)
-            throw new Error(`Expected attribute "${name}" to not match ${regex}, but got "${actual}"`);
-        } else {
-          if (!matches)
-            throw new Error(`Expected attribute "${name}" to match ${regex}, but got "${actual}"`);
-        }
-      } else {
-        const matches = actual === String(value);
-        if (negated) {
-          if (matches)
-            throw new Error(`Expected attribute "${name}" to not be "${value}", but it was`);
-        } else {
-          if (!matches)
-            throw new Error(`Expected attribute "${name}" to be "${value}", but got "${actual}"`);
-        }
-      }
-      break;
-    }
-    case "toHaveText": {
-      const text = await locator.textContent({ timeout }) ?? "";
-      let matches;
-      let expectedDisplay;
-      if (expected && typeof expected === "object" && expected.$regex) {
-        const regex = new RegExp(expected.$regex, expected.$flags);
-        matches = regex.test(text);
-        expectedDisplay = String(regex);
-      } else {
-        matches = text === String(expected);
-        expectedDisplay = JSON.stringify(expected);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected text to not be ${expectedDisplay}, but got "${text}"`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected text to be ${expectedDisplay}, but got "${text}"`);
-      }
-      break;
-    }
-    case "toHaveCount": {
-      const count = await locator.count();
-      const expectedCount = Number(expected);
-      if (negated) {
-        if (count === expectedCount)
-          throw new Error(`Expected count to not be ${expectedCount}, but it was`);
-      } else {
-        if (count !== expectedCount)
-          throw new Error(`Expected count to be ${expectedCount}, but got ${count}`);
-      }
-      break;
-    }
-    case "toBeHidden": {
-      const isHidden = await locator.isHidden();
-      if (negated) {
-        if (isHidden)
-          throw new Error("Expected element to not be hidden, but it was hidden");
-      } else {
-        if (!isHidden)
-          throw new Error("Expected element to be hidden, but it was not");
-      }
-      break;
-    }
-    case "toBeDisabled": {
-      const isDisabled = await locator.isDisabled();
-      if (negated) {
-        if (isDisabled)
-          throw new Error("Expected element to not be disabled, but it was disabled");
-      } else {
-        if (!isDisabled)
-          throw new Error("Expected element to be disabled, but it was not");
-      }
-      break;
-    }
-    case "toBeFocused": {
-      const isFocused = await locator.evaluate((el) => document.activeElement === el).catch(() => false);
-      if (negated) {
-        if (isFocused)
-          throw new Error("Expected element to not be focused, but it was focused");
-      } else {
-        if (!isFocused)
-          throw new Error("Expected element to be focused, but it was not");
-      }
-      break;
-    }
-    case "toBeEmpty": {
-      const text = await locator.textContent({ timeout });
-      const value = await locator.inputValue({ timeout }).catch(() => null);
-      const isEmpty = value !== null ? value === "" : (text ?? "") === "";
-      if (negated) {
-        if (isEmpty)
-          throw new Error("Expected element to not be empty, but it was");
-      } else {
-        if (!isEmpty)
-          throw new Error("Expected element to be empty, but it was not");
-      }
-      break;
-    }
-    default:
-      throw new Error(`Unknown matcher: ${matcher}`);
-  }
-}
-function createPlaywrightHandler(page, options) {
-  const timeout = options?.timeout ?? 30000;
+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) => {
-    try {
-      switch (op.type) {
-        case "goto": {
-          const [url, waitUntil] = op.args;
-          await page.goto(url, {
-            timeout,
-            waitUntil: waitUntil ?? "load"
-          });
-          return { ok: true };
-        }
-        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, arg] = op.args;
-          if (op.args.length > 1) {
-            const fn = new Function("return (" + script + ")")();
-            const result2 = await page.evaluate(fn, arg);
-            return { ok: true, value: result2 };
-          }
-          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 requestOptions = {
-            timeout
-          };
-          if (headers) {
-            requestOptions.headers = headers;
+    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 (data !== undefined && data !== null) {
-            requestOptions.data = data;
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for URL` } };
           }
-          const response = await page.request.fetch(url, {
-            method,
-            ...requestOptions
+          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
           });
-          const text = await response.text();
-          let json = null;
+          if (!finishResult.ok)
+            return finishResult;
+          const responseData = finishResult.value;
           try {
-            json = JSON.parse(text);
-          } catch {}
-          return {
-            ok: true,
-            value: {
-              status: response.status(),
-              ok: response.ok(),
-              headers: response.headers(),
-              text,
-              json,
-              body: null
+            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;
             }
-          };
-        }
-        case "goBack": {
-          const [waitUntil] = op.args;
-          await page.goBack({
-            timeout,
-            waitUntil: waitUntil ?? "load"
+          } 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
           });
-          return { ok: true };
+          if (!nextStartResult.ok)
+            return nextStartResult;
+          currentListenerId = nextStartResult.value.listenerId;
         }
-        case "goForward": {
-          const [waitUntil] = op.args;
-          await page.goForward({
-            timeout,
-            waitUntil: waitUntil ?? "load"
+      }
+      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
           });
-          return { ok: true };
-        }
-        case "waitForURL": {
-          const [url, customTimeout, waitUntil] = op.args;
-          await page.waitForURL(url, {
-            timeout: customTimeout ?? timeout,
-            waitUntil: waitUntil ?? undefined
+          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
           });
-          return { ok: true };
+          if (!nextStartResult.ok)
+            return nextStartResult;
+          currentListenerId = nextStartResult.value.listenerId;
         }
-        case "clearCookies": {
-          await page.context().clearCookies();
-          return { ok: true };
-        }
-        default:
-          return { ok: false, error: { name: "Error", message: `Unknown operation: ${op.type}` } };
       }
-    } catch (err) {
-      const error = err;
-      return { ok: false, error: { name: error.name, message: error.message } };
+      default:
+        return handler(op);
     }
   };
 }
 async function setupPlaywright(context, options) {
   const timeout = options.timeout ?? 30000;
-  const page = "page" in options ? options.page : undefined;
+  const explicitPage = "page" in options ? options.page : undefined;
   const handler = "handler" in options ? options.handler : undefined;
-  const effectiveHandler = handler ?? (page ? createPlaywrightHandler(page, { timeout }) : undefined);
-  if (!effectiveHandler) {
+  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 = [];
@@ -518,15 +224,10 @@ async function setupPlaywright(context, options) {
     page.on("response", responseHandler);
     page.on("console", consoleHandler);
   }
-  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() {
-  globalThis.__pw_invoke = async function(type, args) {
-    const op = JSON.stringify({ type, args });
+  globalThis.__pw_invoke_sync = function(type, args, options) {
+    const op = JSON.stringify({ type, args, pageId: options?.pageId, contextId: options?.contextId });
     const resultJson = __Playwright_handler_ref.applySyncPromise(undefined, [op]);
     const result = JSON.parse(resultJson);
     if (result.ok) {
@@ -537,215 +238,607 @@ async function setupPlaywright(context, options) {
       throw error;
     }
   };
+  globalThis.__pw_invoke = async function(type, args, options) {
+    return globalThis.__pw_invoke_sync(type, args, options);
+  };
 })();
 `);
   context.evalSync(`
 (function() {
-  let __pw_currentUrl = '';
-  globalThis.page = {
+  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) {
-      const result = await __pw_invoke("goto", [url, options?.waitUntil || null]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      __pw_currentUrl = resolvedUrl || url;
-      return result;
-    },
+      await __pw_invoke("goto", [url, options?.waitUntil || null], { pageId: this.#pageId });
+    }
     async reload() {
-      const result = await __pw_invoke("reload", []);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-      return result;
-    },
-    url() {
-      return __pw_currentUrl;
-    },
-    async title() {
-      return __pw_invoke("title", []);
-    },
-    async content() {
-      return __pw_invoke("content", []);
-    },
+      await __pw_invoke("reload", [], { pageId: this.#pageId });
+    }
+    url() { return __pw_invoke_sync("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]);
-    },
-    async waitForTimeout(ms) {
-      return __pw_invoke("waitForTimeout", [ms]);
-    },
-    async waitForLoadState(state) {
-      return __pw_invoke("waitForLoadState", [state || null]);
-    },
+      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]);
+        return __pw_invoke("evaluate", [serialized, arg], { pageId: this.#pageId });
       }
       const serialized = typeof script === "function" ? "(" + script.toString() + ")()" : script;
-      return __pw_invoke("evaluate", [serialized]);
-    },
-    locator(selector) { return new Locator("css", selector, null); },
+      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 };
-        // Use duck-typing RegExp detection (instanceof fails across isolated-vm boundary)
         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));
+        return new Locator("role", role, JSON.stringify(serialized), this.#pageId);
       }
-      return new Locator("role", role, null);
-    },
-    getByText(text) { return new Locator("text", text, null); },
-    getByLabel(label) { return new Locator("label", label, null); },
-    getByPlaceholder(p) { return new Locator("placeholder", p, null); },
-    getByTestId(id) { return new Locator("testId", id, null); },
+      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]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-    },
+      await __pw_invoke("goBack", [options?.waitUntil || null], { pageId: this.#pageId });
+    }
     async goForward(options) {
-      await __pw_invoke("goForward", [options?.waitUntil || null]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-    },
+      await __pw_invoke("goForward", [options?.waitUntil || null], { pageId: this.#pageId });
+    }
     async waitForURL(url, options) {
-      return __pw_invoke("waitForURL", [url, options?.timeout || null, options?.waitUntil || null]);
-    },
-    context() {
+      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 });
+    }
+    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 = __pw_invoke_sync("waitForRequestStart", [broadMatcher, options?.timeout || null], { pageId });
+        const listenerId = startResult.listenerId;
+        return {
+          then(resolve, reject) {
+            try {
+              const r = __pw_invoke_sync("waitForRequestPredicateFinish", [listenerId, predicateId, options?.timeout || null], { pageId });
+              resolve({ url: () => r.url, method: () => r.method, headers: () => r.headers, postData: () => r.postData });
+            } catch(e) { reject(e); } 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 = __pw_invoke_sync("waitForRequestStart", [serializedMatcher, options?.timeout || null], { pageId: this.#pageId });
+      const listenerId = startResult.listenerId;
+      const pageId = this.#pageId;
       return {
-        async clearCookies() {
-          return __pw_invoke("clearCookies", []);
+        then(resolve, reject) {
+          try {
+            const r = __pw_invoke_sync("waitForRequestFinish", [listenerId], { pageId });
+            resolve({ url: () => r.url, method: () => r.method, headers: () => r.headers, postData: () => r.postData });
+          } catch(e) { reject(e); }
         }
       };
-    },
-    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]);
+    }
+    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 = __pw_invoke_sync("waitForResponseStart", [broadMatcher, options?.timeout || null], { pageId });
+        const listenerId = startResult.listenerId;
         return {
-          status: () => result.status,
-          ok: () => result.ok,
-          headers: () => result.headers,
-          json: async () => result.json,
-          text: async () => result.text,
-          body: async () => result.body,
+          then(resolve, reject) {
+            try {
+              const r = __pw_invoke_sync("waitForResponsePredicateFinish", [listenerId, predicateId, options?.timeout || null], { pageId });
+              resolve({
+                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,
+              });
+            } catch(e) { reject(e); } finally { __pw_unregister_predicate(predicateId); }
+          }
         };
-      },
-      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" });
-      },
-    },
+      }
+      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 = __pw_invoke_sync("waitForResponseStart", [serializedMatcher, options?.timeout || null], { pageId: this.#pageId });
+      const listenerId = startResult.listenerId;
+      const pageId = this.#pageId;
+      return {
+        then(resolve, reject) {
+          try {
+            const r = __pw_invoke_sync("waitForResponseFinish", [listenerId], { pageId });
+            resolve({
+              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,
+            });
+          } catch(e) { reject(e); }
+        }
+      };
+    }
+    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;
-    constructor(type, value, options) {
+    #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]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "click", null], { pageId: this.#pageId });
     }
     async dblclick() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null], { pageId: this.#pageId });
     }
     async fill(text) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text], { pageId: this.#pageId });
     }
     async type(text) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text], { pageId: this.#pageId });
     }
     async check() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null], { pageId: this.#pageId });
     }
     async uncheck() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null], { pageId: this.#pageId });
     }
     async selectOption(value) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value], { pageId: this.#pageId });
     }
     async clear() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null], { pageId: this.#pageId });
     }
     async press(key) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key], { pageId: this.#pageId });
     }
     async hover() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null], { pageId: this.#pageId });
     }
     async focus() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null], { pageId: this.#pageId });
     }
     async textContent() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null], { pageId: this.#pageId });
     }
     async inputValue() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null], { pageId: this.#pageId });
     }
     async isVisible() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null], { pageId: this.#pageId });
     }
     async isEnabled() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null], { pageId: this.#pageId });
     }
     async isChecked() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null], { pageId: this.#pageId });
     }
     async count() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null], { pageId: this.#pageId });
     }
     async getAttribute(name) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getAttribute", name]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getAttribute", name], { pageId: this.#pageId });
     }
     async isDisabled() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isDisabled", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isDisabled", null], { pageId: this.#pageId });
     }
     async isHidden() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isHidden", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isHidden", null], { pageId: this.#pageId });
     }
     async innerHTML() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "innerHTML", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerHTML", null], { pageId: this.#pageId });
     }
     async innerText() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "innerText", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerText", null], { pageId: this.#pageId });
     }
     async allTextContents() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "allTextContents", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allTextContents", null], { pageId: this.#pageId });
     }
     async allInnerTexts() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "allInnerTexts", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allInnerTexts", null], { pageId: this.#pageId });
     }
     async waitFor(options) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "waitFor", options || {}]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "waitFor", options || {}], { pageId: this.#pageId });
     }
     async boundingBox() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "boundingBox", null]);
+      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) {
-      const parentSelector = this.#type === 'css' ? this.#value : null;
-      if (parentSelector) {
-        return new Locator("css", parentSelector + " " + selector, this.#options);
-      }
-      // For non-css locators, use css with the combined approach
-      return new Locator("css", selector, this.#options);
+      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();
@@ -757,7 +850,7 @@ async function setupPlaywright(context, options) {
     }
     nth(index) {
       const existingOpts = this.#options ? JSON.parse(this.#options) : {};
-      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }));
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }), this.#pageId);
     }
     first() {
       return this.nth(0);
@@ -777,13 +870,28 @@ async function setupPlaywright(context, options) {
       if (hasNotText && typeof hasNotText === 'object' && typeof hasNotText.source === 'string' && typeof hasNotText.flags === 'string') {
         serializedFilter.hasNotText = { $regex: hasNotText.source, $flags: hasNotText.flags };
       }
-      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, filter: serializedFilter }));
+      // 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);
+      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;
@@ -794,84 +902,157 @@ async function setupPlaywright(context, options) {
   // 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]);
+        return __pw_invoke("expectLocator", [...info, "toBeVisible", null, false, options?.timeout], { pageId });
       },
       async toContainText(expected, options) {
-        const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-        return __pw_invoke("expectLocator", [...info, "toContainText", serialized, false, options?.timeout]);
+        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]);
+        return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, false, options?.timeout], { pageId });
       },
       async toBeEnabled(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout], { pageId });
       },
       async toBeChecked(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout], { pageId });
       },
       async toHaveAttribute(name, value, options) {
-        return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value }, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, false, options?.timeout], { pageId });
       },
       async toHaveText(expected, options) {
-        const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-        return __pw_invoke("expectLocator", [...info, "toHaveText", serialized, false, options?.timeout]);
+        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]);
+        return __pw_invoke("expectLocator", [...info, "toHaveCount", count, false, options?.timeout], { pageId });
       },
       async toBeHidden(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeHidden", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeHidden", null, false, options?.timeout], { pageId });
       },
       async toBeDisabled(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, false, options?.timeout], { pageId });
       },
       async toBeFocused(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeFocused", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeFocused", null, false, options?.timeout], { pageId });
       },
       async toBeEmpty(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, false, options?.timeout]);
+        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]);
+          return __pw_invoke("expectLocator", [...info, "toBeVisible", null, true, options?.timeout], { pageId });
         },
         async toContainText(expected, options) {
-          const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-          return __pw_invoke("expectLocator", [...info, "toContainText", serialized, true, options?.timeout]);
+          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]);
+          return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, true, options?.timeout], { pageId });
         },
         async toBeEnabled(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout], { pageId });
         },
         async toBeChecked(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout], { pageId });
         },
         async toHaveAttribute(name, value, options) {
-          return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value }, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, true, options?.timeout], { pageId });
         },
         async toHaveText(expected, options) {
-          const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-          return __pw_invoke("expectLocator", [...info, "toHaveText", serialized, true, options?.timeout]);
+          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]);
+          return __pw_invoke("expectLocator", [...info, "toHaveCount", count, true, options?.timeout], { pageId });
         },
         async toBeHidden(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeHidden", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeHidden", null, true, options?.timeout], { pageId });
         },
         async toBeDisabled(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, true, options?.timeout], { pageId });
         },
         async toBeFocused(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeFocused", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeFocused", null, true, options?.timeout], { pageId });
         },
         async toBeEmpty(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, true, options?.timeout]);
+          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 });
         },
       }
     };
@@ -887,6 +1068,44 @@ async function setupPlaywright(context, options) {
     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;
@@ -896,6 +1115,10 @@ async function setupPlaywright(context, options) {
       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;
     };
   }
@@ -931,7 +1154,10 @@ async function setupPlaywright(context, options) {
 }
 export {
   setupPlaywright,
-  createPlaywrightHandler
+  getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler,
+  createPlaywrightHandler,
+  DEFAULT_PLAYWRIGHT_HANDLER_META
 };
 
-//# debugId=6B90A150912AD17864756E2164756E21
+//# debugId=917AA0A37B759B7B64756E2164756E21