@ricsam/isolate-playwright 0.1.13 → 0.1.15

package/dist/mjs/index.mjs

@@ -3,1082 +3,149 @@ import ivm from "isolated-vm";
 import {
   DEFAULT_PLAYWRIGHT_HANDLER_META
 } from "./types.mjs";
-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;
-    }
-    case "and": {
-      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.and(second);
-      break;
-    }
-    case "chained": {
-      const [parentInfo, childInfo] = JSON.parse(selectorValue);
-      const parent = getLocator(page, parentInfo[0], parentInfo[1], parentInfo[2]);
-      const childType = childInfo[0];
-      const childValue = childInfo[1];
-      const childOptionsJson = childInfo[2];
-      const childOptions = childOptionsJson ? JSON.parse(childOptionsJson) : undefined;
-      switch (childType) {
-        case "css":
-          locator = parent.locator(childValue);
-          break;
-        case "role": {
-          const roleOpts = childOptions ? { ...childOptions } : undefined;
-          if (roleOpts) {
-            delete roleOpts.nth;
-            delete roleOpts.filter;
-            if (roleOpts.name && typeof roleOpts.name === "object" && roleOpts.name.$regex) {
-              roleOpts.name = new RegExp(roleOpts.name.$regex, roleOpts.name.$flags);
-            }
-          }
-          locator = parent.getByRole(childValue, roleOpts && Object.keys(roleOpts).length > 0 ? roleOpts : undefined);
-          break;
-        }
-        case "text":
-          locator = parent.getByText(childValue);
-          break;
-        case "label":
-          locator = parent.getByLabel(childValue);
-          break;
-        case "placeholder":
-          locator = parent.getByPlaceholder(childValue);
-          break;
-        case "testId":
-          locator = parent.getByTestId(childValue);
-          break;
-        case "altText":
-          locator = parent.getByAltText(childValue);
-          break;
-        case "title":
-          locator = parent.getByTitle(childValue);
-          break;
-        default:
-          locator = parent.locator(childValue);
-      }
-      if (childOptions?.nth !== undefined) {
-        locator = locator.nth(childOptions.nth);
-      }
-      if (childOptions?.filter) {
-        const filterOpts = { ...childOptions.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);
-      }
-      break;
-    }
-    case "altText":
-      locator = page.getByAltText(selectorValue);
-      break;
-    case "title":
-      locator = page.getByTitle(selectorValue);
-      break;
-    case "frame": {
-      const [frameSelectorInfo, innerLocatorInfo] = JSON.parse(selectorValue);
-      const frameSelector = frameSelectorInfo[1];
-      const frame = page.frameLocator(frameSelector);
-      const innerType = innerLocatorInfo[0];
-      const innerValue = innerLocatorInfo[1];
-      const innerOptionsJson = innerLocatorInfo[2];
-      const innerOptions = innerOptionsJson ? JSON.parse(innerOptionsJson) : undefined;
-      switch (innerType) {
-        case "css":
-          locator = frame.locator(innerValue);
-          break;
-        case "role": {
-          const roleOpts = innerOptions ? { ...innerOptions } : undefined;
-          if (roleOpts) {
-            delete roleOpts.nth;
-            delete roleOpts.filter;
-            if (roleOpts.name && typeof roleOpts.name === "object" && roleOpts.name.$regex) {
-              roleOpts.name = new RegExp(roleOpts.name.$regex, roleOpts.name.$flags);
-            }
-          }
-          locator = frame.getByRole(innerValue, roleOpts && Object.keys(roleOpts).length > 0 ? roleOpts : undefined);
-          break;
-        }
-        case "text":
-          locator = frame.getByText(innerValue);
-          break;
-        case "label":
-          locator = frame.getByLabel(innerValue);
-          break;
-        case "placeholder":
-          locator = frame.getByPlaceholder(innerValue);
-          break;
-        case "testId":
-          locator = frame.getByTestId(innerValue);
-          break;
-        case "altText":
-          locator = frame.getByAltText(innerValue);
-          break;
-        case "title":
-          locator = frame.getByTitle(innerValue);
-          break;
-        default:
-          locator = frame.locator(innerValue);
-      }
-      if (innerOptions?.nth !== undefined) {
-        locator = locator.nth(innerOptions.nth);
-      }
-      if (innerOptions?.filter) {
-        const filterOpts = { ...innerOptions.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);
-      }
-      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, fileIO) {
-  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 });
-    case "setInputFiles": {
-      const files = actionArg;
-      if (Array.isArray(files) && files.length > 0 && typeof files[0] === "object" && "buffer" in files[0]) {
-        const fileBuffers2 = files.map((f) => ({
-          name: f.name,
-          mimeType: f.mimeType,
-          buffer: Buffer.from(f.buffer, "base64")
-        }));
-        await locator.setInputFiles(fileBuffers2, { timeout });
-        return null;
-      }
-      const filePaths = Array.isArray(files) ? files : [files];
-      if (!fileIO?.readFile) {
-        throw new Error("setInputFiles() with file paths requires a readFile callback in defaultPlaywrightHandler options. " + "Either provide file data directly using { name, mimeType, buffer } format, or " + "configure a readFile callback to control file access from the isolate.");
-      }
-      const fileBuffers = await Promise.all(filePaths.map(async (filePath) => {
-        const fileData = await fileIO.readFile(filePath);
-        return {
-          name: fileData.name,
-          mimeType: fileData.mimeType,
-          buffer: fileData.buffer
-        };
-      }));
-      await locator.setInputFiles(fileBuffers, { timeout });
-      return null;
-    }
-    case "screenshot": {
-      const opts = actionArg;
-      const buffer = await locator.screenshot({
-        timeout,
-        type: opts?.type,
-        quality: opts?.quality
-      });
-      if (opts?.path) {
-        if (!fileIO?.writeFile) {
-          throw new Error("screenshot() with path option requires a writeFile callback in defaultPlaywrightHandler options. " + "Either omit the path option (screenshot returns base64 data), or " + "configure a writeFile callback to control file writing from the isolate.");
-        }
-        await fileIO.writeFile(opts.path, buffer);
-      }
-      return buffer.toString("base64");
-    }
-    case "dragTo": {
-      const targetInfo = actionArg;
-      const targetLocator = getLocator(locator.page(), targetInfo[0], targetInfo[1], targetInfo[2]);
-      await locator.dragTo(targetLocator, { timeout });
-      return null;
-    }
-    case "scrollIntoViewIfNeeded":
-      await locator.scrollIntoViewIfNeeded({ timeout });
-      return null;
-    case "highlight":
-      await locator.highlight();
-      return null;
-    case "evaluate": {
-      const [fnString, arg] = actionArg;
-      const fn = new Function("return (" + fnString + ")")();
-      return await locator.evaluate(fn, arg);
-    }
-    case "evaluateAll": {
-      const [fnString, arg] = actionArg;
-      const fn = new Function("return (" + fnString + ")")();
-      return await locator.evaluateAll(fn, arg);
-    }
-    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;
-    }
-    case "toBeAttached": {
-      const count = await locator.count();
-      const isAttached = count > 0;
-      if (negated) {
-        if (isAttached)
-          throw new Error("Expected element to not be attached to DOM, but it was");
-      } else {
-        if (!isAttached)
-          throw new Error("Expected element to be attached to DOM, but it was not");
-      }
-      break;
-    }
-    case "toBeEditable": {
-      const isEditable = await locator.isEditable({ timeout });
-      if (negated) {
-        if (isEditable)
-          throw new Error("Expected element to not be editable, but it was");
-      } else {
-        if (!isEditable)
-          throw new Error("Expected element to be editable, but it was not");
-      }
-      break;
-    }
-    case "toHaveClass": {
-      const classAttr = await locator.getAttribute("class", { timeout }) ?? "";
-      const classes = classAttr.split(/\s+/).filter(Boolean);
-      let matches;
-      let expectedDisplay;
-      if (expected && typeof expected === "object" && expected.$regex) {
-        const regex = new RegExp(expected.$regex, expected.$flags);
-        matches = regex.test(classAttr);
-        expectedDisplay = String(regex);
-      } else if (Array.isArray(expected)) {
-        matches = expected.every((c) => classes.includes(c));
-        expectedDisplay = JSON.stringify(expected);
-      } else {
-        matches = classAttr === String(expected) || classes.includes(String(expected));
-        expectedDisplay = String(expected);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected class to not match ${expectedDisplay}, but got "${classAttr}"`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected class to match ${expectedDisplay}, but got "${classAttr}"`);
-      }
-      break;
-    }
-    case "toContainClass": {
-      const classAttr = await locator.getAttribute("class", { timeout }) ?? "";
-      const classes = classAttr.split(/\s+/).filter(Boolean);
-      const expectedClass = String(expected);
-      const hasClass = classes.includes(expectedClass);
-      if (negated) {
-        if (hasClass)
-          throw new Error(`Expected element to not contain class "${expectedClass}", but it does`);
-      } else {
-        if (!hasClass)
-          throw new Error(`Expected element to contain class "${expectedClass}", but classes are "${classAttr}"`);
-      }
-      break;
-    }
-    case "toHaveId": {
-      const id = await locator.getAttribute("id", { timeout });
-      const matches = id === String(expected);
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected id to not be "${expected}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected id to be "${expected}", but got "${id}"`);
-      }
-      break;
-    }
-    case "toBeInViewport": {
-      const isInViewport = await locator.evaluate((el) => {
-        const rect = el.getBoundingClientRect();
-        return rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
-      });
-      if (negated) {
-        if (isInViewport)
-          throw new Error("Expected element to not be in viewport, but it was");
-      } else {
-        if (!isInViewport)
-          throw new Error("Expected element to be in viewport, but it was not");
-      }
-      break;
-    }
-    case "toHaveCSS": {
-      const { name, value } = expected;
-      const actual = await locator.evaluate((el, propName) => {
-        return getComputedStyle(el).getPropertyValue(propName);
-      }, name);
-      let matches;
-      if (value && typeof value === "object" && value.$regex) {
-        const regex = new RegExp(value.$regex, value.$flags);
-        matches = regex.test(actual);
-      } else {
-        matches = actual === String(value);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected CSS "${name}" to not be "${value}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected CSS "${name}" to be "${value}", but got "${actual}"`);
-      }
-      break;
-    }
-    case "toHaveJSProperty": {
-      const { name, value } = expected;
-      const actual = await locator.evaluate((el, propName) => {
-        return el[propName];
-      }, name);
-      const matches = JSON.stringify(actual) === JSON.stringify(value);
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected JS property "${name}" to not be ${JSON.stringify(value)}, but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected JS property "${name}" to be ${JSON.stringify(value)}, but got ${JSON.stringify(actual)}`);
-      }
-      break;
-    }
-    case "toHaveAccessibleName": {
-      const accessibleName = await locator.evaluate((el) => {
-        return el.getAttribute("aria-label") || el.getAttribute("aria-labelledby") || el.innerText || "";
-      });
-      let matches;
-      if (expected && typeof expected === "object" && expected.$regex) {
-        const regex = new RegExp(expected.$regex, expected.$flags);
-        matches = regex.test(accessibleName);
-      } else {
-        matches = accessibleName === String(expected);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected accessible name to not be "${expected}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected accessible name to be "${expected}", but got "${accessibleName}"`);
-      }
-      break;
-    }
-    case "toHaveAccessibleDescription": {
-      const accessibleDesc = await locator.evaluate((el) => {
-        const describedby = el.getAttribute("aria-describedby");
-        if (describedby) {
-          const descEl = document.getElementById(describedby);
-          return descEl?.textContent || "";
-        }
-        return el.getAttribute("aria-description") || "";
-      });
-      let matches;
-      if (expected && typeof expected === "object" && expected.$regex) {
-        const regex = new RegExp(expected.$regex, expected.$flags);
-        matches = regex.test(accessibleDesc);
-      } else {
-        matches = accessibleDesc === String(expected);
-      }
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected accessible description to not be "${expected}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected accessible description to be "${expected}", but got "${accessibleDesc}"`);
-      }
-      break;
-    }
-    case "toHaveRole": {
-      const role = await locator.evaluate((el) => {
-        return el.getAttribute("role") || el.tagName.toLowerCase();
-      });
-      const matches = role === String(expected);
-      if (negated) {
-        if (matches)
-          throw new Error(`Expected role to not be "${expected}", but it was`);
-      } else {
-        if (!matches)
-          throw new Error(`Expected role to be "${expected}", but got "${role}"`);
-      }
-      break;
-    }
-    default:
-      throw new Error(`Unknown matcher: ${matcher}`);
-  }
-}
-async function executePageExpectAssertion(page, matcher, expected, negated, timeout) {
-  let expectedValue = expected;
-  if (expected && typeof expected === "object" && expected.$regex) {
-    expectedValue = new RegExp(expected.$regex, expected.$flags);
-  }
-  switch (matcher) {
-    case "toHaveURL": {
-      const expectedUrl = expectedValue;
-      const startTime = Date.now();
-      let lastUrl = "";
-      while (Date.now() - startTime < timeout) {
-        lastUrl = page.url();
-        const matches = expectedUrl instanceof RegExp ? expectedUrl.test(lastUrl) : lastUrl === expectedUrl;
-        if (negated ? !matches : matches)
-          return;
-        await new Promise((r) => setTimeout(r, 100));
-      }
-      if (negated) {
-        throw new Error(`Expected URL to not match "${expectedUrl}", but got "${lastUrl}"`);
-      } else {
-        throw new Error(`Expected URL to be "${expectedUrl}", but got "${lastUrl}"`);
-      }
-    }
-    case "toHaveTitle": {
-      const expectedTitle = expectedValue;
-      const startTime = Date.now();
-      let lastTitle = "";
-      while (Date.now() - startTime < timeout) {
-        lastTitle = await page.title();
-        const matches = expectedTitle instanceof RegExp ? expectedTitle.test(lastTitle) : lastTitle === expectedTitle;
-        if (negated ? !matches : matches)
-          return;
-        await new Promise((r) => setTimeout(r, 100));
-      }
-      if (negated) {
-        throw new Error(`Expected title to not match "${expectedTitle}", but got "${lastTitle}"`);
-      } else {
-        throw new Error(`Expected title to be "${expectedTitle}", but got "${lastTitle}"`);
-      }
-    }
-    default:
-      throw new Error(`Unknown page matcher: ${matcher}`);
-  }
-}
-function createPlaywrightHandler(page, options) {
-  const timeout = options?.timeout ?? 30000;
-  const fileIO = {
-    readFile: options?.readFile,
-    writeFile: options?.writeFile
-  };
-  const registry = {
-    pages: new Map([["page_0", page]]),
-    contexts: new Map([["ctx_0", page.context()]]),
-    nextPageId: 1,
-    nextContextId: 1
-  };
+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 "newContext": {
-          if (!options?.createContext) {
-            return { ok: false, error: { name: "Error", message: "createContext callback not provided. Configure createContext in playwright options to enable browser.newContext()." } };
-          }
-          const [contextOptions] = op.args;
-          const newContext = await options.createContext(contextOptions);
-          const contextId2 = `ctx_${registry.nextContextId++}`;
-          registry.contexts.set(contextId2, newContext);
-          return { ok: true, value: { contextId: contextId2 } };
-        }
-        case "newPage": {
-          if (!options?.createPage) {
-            return { ok: false, error: { name: "Error", message: "createPage callback not provided. Configure createPage in playwright options to enable context.newPage()." } };
-          }
-          const contextId2 = op.contextId ?? "ctx_0";
-          const targetContext2 = registry.contexts.get(contextId2);
-          if (!targetContext2) {
-            return { ok: false, error: { name: "Error", message: `Context ${contextId2} not found` } };
-          }
-          const newPage = await options.createPage(targetContext2);
-          const pageId2 = `page_${registry.nextPageId++}`;
-          registry.pages.set(pageId2, newPage);
-          return { ok: true, value: { pageId: pageId2 } };
-        }
-        case "closeContext": {
-          const contextId2 = op.contextId ?? "ctx_0";
-          const context = registry.contexts.get(contextId2);
-          if (!context) {
-            return { ok: false, error: { name: "Error", message: `Context ${contextId2} not found` } };
-          }
-          await context.close();
-          registry.contexts.delete(contextId2);
-          for (const [pid, p] of registry.pages) {
-            if (p.context() === context) {
-              registry.pages.delete(pid);
+    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 } };
             }
           }
-          return { ok: true };
-        }
-      }
-      const pageId = op.pageId ?? "page_0";
-      const targetPage = registry.pages.get(pageId);
-      if (!targetPage) {
-        return { ok: false, error: { name: "Error", message: `Page ${pageId} not found` } };
-      }
-      const contextId = op.contextId ?? "ctx_0";
-      const targetContext = registry.contexts.get(contextId);
-      switch (op.type) {
-        case "goto": {
-          const [url, waitUntil] = op.args;
-          await targetPage.goto(url, {
-            timeout,
-            waitUntil: waitUntil ?? "load"
-          });
-          return { ok: true };
-        }
-        case "reload":
-          await targetPage.reload({ timeout });
-          return { ok: true };
-        case "url":
-          return { ok: true, value: targetPage.url() };
-        case "title":
-          return { ok: true, value: await targetPage.title() };
-        case "content":
-          return { ok: true, value: await targetPage.content() };
-        case "waitForSelector": {
-          const [selector, optionsJson] = op.args;
-          const opts = optionsJson ? JSON.parse(optionsJson) : {};
-          await targetPage.waitForSelector(selector, { timeout, ...opts });
-          return { ok: true };
-        }
-        case "waitForTimeout": {
-          const [ms] = op.args;
-          await targetPage.waitForTimeout(ms);
-          return { ok: true };
-        }
-        case "waitForLoadState": {
-          const [state] = op.args;
-          await targetPage.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 targetPage.evaluate(fn, arg);
-            return { ok: true, value: result2 };
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for URL` } };
           }
-          const result = await targetPage.evaluate(script);
-          return { ok: true, value: result };
-        }
-        case "locatorAction": {
-          const [selectorType, selectorValue, roleOptions, action, actionArg] = op.args;
-          const locator = getLocator(targetPage, selectorType, selectorValue, roleOptions);
-          const result = await executeLocatorAction(locator, action, actionArg, timeout, fileIO);
-          return { ok: true, value: result };
+          await new Promise((r) => setTimeout(r, pollInterval));
         }
-        case "expectLocator": {
-          const [selectorType, selectorValue, roleOptions, matcher, expected, negated, customTimeout] = op.args;
-          const locator = getLocator(targetPage, selectorType, selectorValue, roleOptions);
-          const effectiveTimeout = customTimeout ?? timeout;
-          await executeExpectAssertion(locator, matcher, expected, negated ?? false, effectiveTimeout);
-          return { ok: true };
-        }
-        case "expectPage": {
-          const [matcher, expected, negated, customTimeout] = op.args;
-          const effectiveTimeout = customTimeout ?? timeout;
-          await executePageExpectAssertion(targetPage, 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;
-          }
-          if (data !== undefined && data !== null) {
-            requestOptions.data = data;
-          }
-          const response = await targetPage.request.fetch(url, {
-            method,
-            ...requestOptions
+      }
+      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 targetPage.goBack({
-            timeout,
-            waitUntil: waitUntil ?? "load"
-          });
-          return { ok: true };
-        }
-        case "goForward": {
-          const [waitUntil] = op.args;
-          await targetPage.goForward({
-            timeout,
-            waitUntil: waitUntil ?? "load"
-          });
-          return { ok: true };
-        }
-        case "waitForURL": {
-          const [urlArg, customTimeout, waitUntil] = op.args;
-          const url = urlArg && typeof urlArg === "object" && "$regex" in urlArg ? new RegExp(urlArg.$regex, urlArg.$flags) : urlArg;
-          await targetPage.waitForURL(url, {
-            timeout: customTimeout ?? timeout,
-            waitUntil: waitUntil ?? undefined
+          } 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 };
-        }
-        case "clearCookies": {
-          const ctx = targetContext ?? targetPage.context();
-          await ctx.clearCookies();
-          return { ok: true };
+          if (!nextStartResult.ok)
+            return nextStartResult;
+          currentListenerId = nextStartResult.value.listenerId;
         }
-        case "screenshot": {
-          const [screenshotOptions] = op.args;
-          const buffer = await targetPage.screenshot({
-            type: screenshotOptions?.type,
-            quality: screenshotOptions?.quality,
-            fullPage: screenshotOptions?.fullPage,
-            clip: screenshotOptions?.clip
+      }
+      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 (screenshotOptions?.path) {
-            if (!fileIO.writeFile) {
-              throw new Error("screenshot() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or omit the path option " + "and handle the returned base64 data yourself.");
+          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;
             }
-            await fileIO.writeFile(screenshotOptions.path, buffer);
+          } catch (e) {
+            const error = e;
+            return { ok: false, error: { name: error.name, message: error.message } };
           }
-          return { ok: true, value: buffer.toString("base64") };
-        }
-        case "setViewportSize": {
-          const [size] = op.args;
-          await targetPage.setViewportSize(size);
-          return { ok: true };
-        }
-        case "viewportSize": {
-          return { ok: true, value: targetPage.viewportSize() };
-        }
-        case "keyboardType": {
-          const [text, typeOptions] = op.args;
-          await targetPage.keyboard.type(text, typeOptions);
-          return { ok: true };
-        }
-        case "keyboardPress": {
-          const [key, pressOptions] = op.args;
-          await targetPage.keyboard.press(key, pressOptions);
-          return { ok: true };
-        }
-        case "keyboardDown": {
-          const [key] = op.args;
-          await targetPage.keyboard.down(key);
-          return { ok: true };
-        }
-        case "keyboardUp": {
-          const [key] = op.args;
-          await targetPage.keyboard.up(key);
-          return { ok: true };
-        }
-        case "keyboardInsertText": {
-          const [text] = op.args;
-          await targetPage.keyboard.insertText(text);
-          return { ok: true };
-        }
-        case "mouseMove": {
-          const [x, y, moveOptions] = op.args;
-          await targetPage.mouse.move(x, y, moveOptions);
-          return { ok: true };
-        }
-        case "mouseClick": {
-          const [x, y, clickOptions] = op.args;
-          await targetPage.mouse.click(x, y, clickOptions);
-          return { ok: true };
-        }
-        case "mouseDown": {
-          const [downOptions] = op.args;
-          await targetPage.mouse.down(downOptions);
-          return { ok: true };
-        }
-        case "mouseUp": {
-          const [upOptions] = op.args;
-          await targetPage.mouse.up(upOptions);
-          return { ok: true };
-        }
-        case "mouseWheel": {
-          const [deltaX, deltaY] = op.args;
-          await targetPage.mouse.wheel(deltaX, deltaY);
-          return { ok: true };
-        }
-        case "frames": {
-          const frames = targetPage.frames();
-          return { ok: true, value: frames.map((f) => ({ name: f.name(), url: f.url() })) };
-        }
-        case "mainFrame": {
-          const mainFrame = targetPage.mainFrame();
-          return { ok: true, value: { name: mainFrame.name(), url: mainFrame.url() } };
-        }
-        case "bringToFront": {
-          await targetPage.bringToFront();
-          return { ok: true };
-        }
-        case "close": {
-          await targetPage.close();
-          registry.pages.delete(pageId);
-          return { ok: true };
-        }
-        case "isClosed": {
-          return { ok: true, value: targetPage.isClosed() };
-        }
-        case "pdf": {
-          const [pdfOptions] = op.args;
-          const { path: pdfPath, ...restPdfOptions } = pdfOptions ?? {};
-          const buffer = await targetPage.pdf(restPdfOptions);
-          if (pdfPath) {
-            if (!fileIO.writeFile) {
-              throw new Error("pdf() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or omit the path option " + "and handle the returned base64 data yourself.");
-            }
-            await fileIO.writeFile(pdfPath, buffer);
+          if (effectiveTimeout > 0 && Date.now() - startTime >= effectiveTimeout) {
+            return { ok: false, error: { name: "Error", message: `Timeout ${effectiveTimeout}ms exceeded waiting for request` } };
           }
-          return { ok: true, value: buffer.toString("base64") };
-        }
-        case "emulateMedia": {
-          const [mediaOptions] = op.args;
-          await targetPage.emulateMedia(mediaOptions);
-          return { ok: true };
-        }
-        case "addCookies": {
-          const [cookies] = op.args;
-          const ctx = targetContext ?? targetPage.context();
-          await ctx.addCookies(cookies);
-          return { ok: true };
-        }
-        case "cookies": {
-          const [urls] = op.args;
-          const ctx = targetContext ?? targetPage.context();
-          const cookies = await ctx.cookies(urls);
-          return { ok: true, value: cookies };
-        }
-        case "setExtraHTTPHeaders": {
-          const [headers] = op.args;
-          await targetPage.setExtraHTTPHeaders(headers);
-          return { ok: true };
-        }
-        case "pause": {
-          await targetPage.pause();
-          return { ok: true };
+          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 { 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);
     }
   };
 }
-function defaultPlaywrightHandler(page, options) {
-  const handler = createPlaywrightHandler(page, options);
-  handler[DEFAULT_PLAYWRIGHT_HANDLER_META] = { page, options };
-  return handler;
-}
-function getDefaultPlaywrightHandlerMetadata(handler) {
-  return handler[DEFAULT_PLAYWRIGHT_HANDLER_META];
-}
 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 ? getDefaultPlaywrightHandlerMetadata(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 effectiveHandler = handler ?? (page ? createPlaywrightHandler(page, {
-    timeout,
-    createPage,
-    createContext
-  }) : undefined);
-  if (!effectiveHandler) {
+  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 = [];
@@ -1157,14 +224,9 @@ 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, options) {
+  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);
@@ -1176,13 +238,68 @@ 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() {
+  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; #currentUrl = '';
+    #pageId; #contextId;
     constructor(pageId, contextId) {
       this.#pageId = pageId;
       this.#contextId = contextId;
@@ -1193,15 +310,11 @@ async function setupPlaywright(context, options) {
 
     async goto(url, options) {
       await __pw_invoke("goto", [url, options?.waitUntil || null], { pageId: this.#pageId });
-      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
-      this.#currentUrl = resolvedUrl || url;
     }
     async reload() {
       await __pw_invoke("reload", [], { pageId: this.#pageId });
-      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
-      if (resolvedUrl) this.#currentUrl = resolvedUrl;
     }
-    url() { return this.#currentUrl; }
+    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) {
@@ -1251,21 +364,139 @@ async function setupPlaywright(context, options) {
     }
     async goBack(options) {
       await __pw_invoke("goBack", [options?.waitUntil || null], { pageId: this.#pageId });
-      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
-      if (resolvedUrl) this.#currentUrl = resolvedUrl;
     }
     async goForward(options) {
       await __pw_invoke("goForward", [options?.waitUntil || null], { pageId: this.#pageId });
-      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
-      if (resolvedUrl) this.#currentUrl = resolvedUrl;
     }
     async waitForURL(url, options) {
-      let serializedUrl = url;
-      if (url && typeof url === 'object' && typeof url.source === 'string' && typeof url.flags === 'string') {
-        serializedUrl = { $regex: url.source, $flags: url.flags };
+      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 {
+        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); }
+        }
+      };
+    }
+    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 {
+          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); }
+          }
+        };
+      }
+      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);
@@ -1381,6 +612,86 @@ async function setupPlaywright(context, options) {
     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) {
@@ -1479,15 +790,7 @@ async function setupPlaywright(context, options) {
       return __pw_invoke("locatorAction", [...this._getInfo(), "boundingBox", null], { pageId: this.#pageId });
     }
     async setInputFiles(files) {
-      // Serialize files - if they have buffers, convert to base64
-      let serializedFiles = files;
-      if (Array.isArray(files) && files.length > 0 && typeof files[0] === 'object' && files[0].buffer) {
-        serializedFiles = files.map(f => ({
-          name: f.name,
-          mimeType: f.mimeType,
-          buffer: typeof f.buffer === 'string' ? f.buffer : btoa(String.fromCharCode(...new Uint8Array(f.buffer)))
-        }));
-      }
+      const serializedFiles = normalizeSetInputFilesArg(files);
       return __pw_invoke("locatorAction", [...this._getInfo(), "setInputFiles", serializedFiles], { pageId: this.#pageId });
     }
     async screenshot(options) {
@@ -1857,4 +1160,4 @@ export {
   DEFAULT_PLAYWRIGHT_HANDLER_META
 };
 
-//# debugId=AFE0563DA4EAC06264756E2164756E21
+//# debugId=917AA0A37B759B7B64756E2164756E21