@ricsam/isolate-playwright 0.1.11 → 0.1.13

package/dist/mjs/client.mjs

@@ -1,10 +1,17 @@
 // packages/playwright/src/client.ts
+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) {
@@ -26,15 +33,180 @@ function getLocator(page, selectorType, selectorValue, optionsJson) {
     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);
+        }
+        if (filterOpts.has && typeof filterOpts.has === "object" && filterOpts.has.$locator) {
+          const [type, value, opts] = filterOpts.has.$locator;
+          filterOpts.has = getLocator(page, type, value, opts);
+        }
+        if (filterOpts.hasNot && typeof filterOpts.hasNot === "object" && filterOpts.hasNot.$locator) {
+          const [type, value, opts] = filterOpts.hasNot.$locator;
+          filterOpts.hasNot = getLocator(page, type, value, opts);
+        }
+        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);
+    }
+    if (filterOpts.has && typeof filterOpts.has === "object" && filterOpts.has.$locator) {
+      const [type, value, opts] = filterOpts.has.$locator;
+      filterOpts.has = getLocator(page, type, value, opts);
+    }
+    if (filterOpts.hasNot && typeof filterOpts.hasNot === "object" && filterOpts.hasNot.$locator) {
+      const [type, value, opts] = filterOpts.hasNot.$locator;
+      filterOpts.hasNot = getLocator(page, type, value, opts);
+    }
+    locator = locator.filter(filterOpts);
+  }
   return locator;
 }
-async function executeLocatorAction(locator, action, actionArg, timeout) {
+async function executeLocatorAction(locator, action, actionArg, timeout, fileIO) {
   switch (action) {
     case "click":
       await locator.click({ timeout });
@@ -81,6 +253,94 @@ async function executeLocatorAction(locator, action, actionArg, timeout) {
       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) {
+        await locator.setInputFiles([], { timeout });
+        return null;
+      }
+      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 to be provided. " + "Either provide a readFile callback in defaultPlaywrightHandler options, or pass file data directly " + "as { name, mimeType, buffer } objects.");
+      }
+      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 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(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}`);
   }
@@ -100,13 +360,22 @@ async function executeExpectAssertion(locator, matcher, expected, negated, timeo
     }
     case "toContainText": {
       const text = await locator.textContent({ timeout });
-      const matches = text?.includes(String(expected)) ?? false;
+      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 "${expected}", but got "${text}"`);
+          throw new Error(`Expected text to not contain ${expectedDisplay}, but got "${text}"`);
       } else {
         if (!matches)
-          throw new Error(`Expected text to contain "${expected}", but got "${text}"`);
+          throw new Error(`Expected text to contain ${expectedDisplay}, but got "${text}"`);
       }
       break;
     }
@@ -144,71 +413,468 @@ async function executeExpectAssertion(locator, matcher, expected, negated, timeo
       }
       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 baseUrl = options?.baseUrl;
+  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
+  };
   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);
+            }
+          }
+          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;
-          const targetUrl = baseUrl && !url.startsWith("http") ? `${baseUrl}${url}` : url;
-          await page.goto(targetUrl, {
+          await targetPage.goto(url, {
             timeout,
             waitUntil: waitUntil ?? "load"
           });
           return { ok: true };
         }
         case "reload":
-          await page.reload({ timeout });
+          await targetPage.reload({ timeout });
           return { ok: true };
         case "url":
-          return { ok: true, value: page.url() };
+          return { ok: true, value: targetPage.url() };
         case "title":
-          return { ok: true, value: await page.title() };
+          return { ok: true, value: await targetPage.title() };
         case "content":
-          return { ok: true, value: await page.content() };
+          return { ok: true, value: await targetPage.content() };
         case "waitForSelector": {
           const [selector, optionsJson] = op.args;
           const opts = optionsJson ? JSON.parse(optionsJson) : {};
-          await page.waitForSelector(selector, { timeout, ...opts });
+          await targetPage.waitForSelector(selector, { timeout, ...opts });
           return { ok: true };
         }
         case "waitForTimeout": {
           const [ms] = op.args;
-          await page.waitForTimeout(ms);
+          await targetPage.waitForTimeout(ms);
           return { ok: true };
         }
         case "waitForLoadState": {
           const [state] = op.args;
-          await page.waitForLoadState(state ?? "load", { timeout });
+          await targetPage.waitForLoadState(state ?? "load", { timeout });
           return { ok: true };
         }
         case "evaluate": {
-          const [script] = op.args;
-          const result = await page.evaluate(script);
+          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 };
+          }
+          const result = await targetPage.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);
+          const locator = getLocator(targetPage, selectorType, selectorValue, roleOptions);
+          const result = await executeLocatorAction(locator, action, actionArg, timeout, fileIO);
           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 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 targetUrl = baseUrl && !url.startsWith("http") ? `${baseUrl}${url}` : url;
           const requestOptions = {
             timeout
           };
@@ -218,7 +884,7 @@ function createPlaywrightHandler(page, options) {
           if (data !== undefined && data !== null) {
             requestOptions.data = data;
           }
-          const response = await page.request.fetch(targetUrl, {
+          const response = await targetPage.request.fetch(url, {
             method,
             ...requestOptions
           });
@@ -239,6 +905,176 @@ function createPlaywrightHandler(page, options) {
             }
           };
         }
+        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
+          });
+          return { ok: true };
+        }
+        case "clearCookies": {
+          const ctx = targetContext ?? targetPage.context();
+          await ctx.clearCookies();
+          return { ok: true };
+        }
+        case "screenshot": {
+          const [screenshotOptions] = op.args;
+          const buffer = await targetPage.screenshot({
+            type: screenshotOptions?.type,
+            quality: screenshotOptions?.quality,
+            fullPage: screenshotOptions?.fullPage,
+            clip: screenshotOptions?.clip
+          });
+          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.");
+            }
+            await fileIO.writeFile(screenshotOptions.path, buffer);
+          }
+          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;
+          if (downOptions) {
+            await targetPage.mouse.down(downOptions);
+          } else {
+            await targetPage.mouse.down();
+          }
+          return { ok: true };
+        }
+        case "mouseUp": {
+          const [upOptions] = op.args;
+          if (upOptions) {
+            await targetPage.mouse.up(upOptions);
+          } else {
+            await targetPage.mouse.up();
+          }
+          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);
+          }
+          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 };
+        }
         default:
           return { ok: false, error: { name: "Error", message: `Unknown operation: ${op.type}` } };
       }
@@ -248,8 +1084,18 @@ function createPlaywrightHandler(page, options) {
     }
   };
 }
+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];
+}
 export {
+  getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler,
   createPlaywrightHandler
 };
 
-//# debugId=44ADF5BEF22F8B0964756E2164756E21
+//# debugId=2862876D472EB54E64756E2164756E21