@ricsam/isolate-playwright 0.1.11 → 0.1.13

package/dist/cjs/index.cjs

@@ -43,10 +43,14 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   setupPlaywright: () => setupPlaywright,
-  createPlaywrightHandler: () => createPlaywrightHandler
+  getDefaultPlaywrightHandlerMetadata: () => getDefaultPlaywrightHandlerMetadata,
+  defaultPlaywrightHandler: () => defaultPlaywrightHandler,
+  createPlaywrightHandler: () => createPlaywrightHandler,
+  DEFAULT_PLAYWRIGHT_HANDLER_META: () => import_types.DEFAULT_PLAYWRIGHT_HANDLER_META
 });
 module.exports = __toCommonJS(exports_src);
 var import_isolated_vm = __toESM(require("isolated-vm"));
+var import_types = require("./types.cjs");
 function getLocator(page, selectorType, selectorValue, optionsJson) {
   const options = optionsJson ? JSON.parse(optionsJson) : undefined;
   const nthIndex = options?.nth;
@@ -78,6 +82,145 @@ 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);
+        }
+        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);
   }
@@ -96,7 +239,7 @@ function getLocator(page, selectorType, selectorValue, optionsJson) {
   }
   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 });
@@ -164,6 +307,69 @@ async function executeLocatorAction(locator, action, actionArg, timeout) {
     }
     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}`);
   }
@@ -340,76 +546,364 @@ async function executeExpectAssertion(locator, matcher, expected, negated, timeo
       }
       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, arg] = op.args;
           if (op.args.length > 1) {
             const fn = new Function("return (" + script + ")")();
-            const result2 = await page.evaluate(fn, arg);
+            const result2 = await targetPage.evaluate(fn, arg);
             return { ok: true, value: result2 };
           }
-          const result = await page.evaluate(script);
+          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
           };
@@ -419,7 +913,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
           });
@@ -442,7 +936,7 @@ function createPlaywrightHandler(page, options) {
         }
         case "goBack": {
           const [waitUntil] = op.args;
-          await page.goBack({
+          await targetPage.goBack({
             timeout,
             waitUntil: waitUntil ?? "load"
           });
@@ -450,22 +944,156 @@ function createPlaywrightHandler(page, options) {
         }
         case "goForward": {
           const [waitUntil] = op.args;
-          await page.goForward({
+          await targetPage.goForward({
             timeout,
             waitUntil: waitUntil ?? "load"
           });
           return { ok: true };
         }
         case "waitForURL": {
-          const [url, customTimeout, waitUntil] = op.args;
-          await page.waitForURL(url, {
+          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": {
-          await page.context().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;
+          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);
+          }
+          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:
@@ -477,12 +1105,27 @@ function createPlaywrightHandler(page, options) {
     }
   };
 }
+function defaultPlaywrightHandler(page, options) {
+  const handler = createPlaywrightHandler(page, options);
+  handler[import_types.DEFAULT_PLAYWRIGHT_HANDLER_META] = { page, options };
+  return handler;
+}
+function getDefaultPlaywrightHandlerMetadata(handler) {
+  return handler[import_types.DEFAULT_PLAYWRIGHT_HANDLER_META];
+}
 async function setupPlaywright(context, options) {
   const timeout = options.timeout ?? 30000;
-  const baseUrl = options.baseUrl;
-  const page = "page" in options ? options.page : undefined;
+  const explicitPage = "page" in options ? options.page : undefined;
   const handler = "handler" in options ? options.handler : undefined;
-  const effectiveHandler = handler ?? (page ? createPlaywrightHandler(page, { timeout, baseUrl }) : undefined);
+  const handlerMetadata = handler ? getDefaultPlaywrightHandlerMetadata(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) {
     throw new Error("Either page or handler must be provided to setupPlaywright");
   }
@@ -569,8 +1212,8 @@ async function setupPlaywright(context, options) {
   }));
   context.evalSync(`
 (function() {
-  globalThis.__pw_invoke = async function(type, args) {
-    const op = JSON.stringify({ type, args });
+  globalThis.__pw_invoke = async function(type, args, options) {
+    const op = JSON.stringify({ type, args, pageId: options?.pageId, contextId: options?.contextId });
     const resultJson = __Playwright_handler_ref.applySyncPromise(undefined, [op]);
     const result = JSON.parse(resultJson);
     if (result.ok) {
@@ -585,209 +1228,362 @@ async function setupPlaywright(context, options) {
 `);
   context.evalSync(`
 (function() {
-  let __pw_currentUrl = '';
-  globalThis.page = {
+  // IsolatePage class - represents a page with a specific pageId
+  class IsolatePage {
+    #pageId; #contextId; #currentUrl = '';
+    constructor(pageId, contextId) {
+      this.#pageId = pageId;
+      this.#contextId = contextId;
+    }
+    get __isPage() { return true; }
+    get __pageId() { return this.#pageId; }
+    get __contextId() { return this.#contextId; }
+
     async goto(url, options) {
-      const result = await __pw_invoke("goto", [url, options?.waitUntil || null]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      __pw_currentUrl = resolvedUrl || url;
-      return result;
-    },
+      await __pw_invoke("goto", [url, options?.waitUntil || null], { pageId: this.#pageId });
+      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
+      this.#currentUrl = resolvedUrl || url;
+    }
     async reload() {
-      const result = await __pw_invoke("reload", []);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-      return result;
-    },
-    url() {
-      return __pw_currentUrl;
-    },
-    async title() {
-      return __pw_invoke("title", []);
-    },
-    async content() {
-      return __pw_invoke("content", []);
-    },
+      await __pw_invoke("reload", [], { pageId: this.#pageId });
+      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
+      if (resolvedUrl) this.#currentUrl = resolvedUrl;
+    }
+    url() { return this.#currentUrl; }
+    async title() { return __pw_invoke("title", [], { pageId: this.#pageId }); }
+    async content() { return __pw_invoke("content", [], { pageId: this.#pageId }); }
     async waitForSelector(selector, options) {
-      return __pw_invoke("waitForSelector", [selector, options ? JSON.stringify(options) : null]);
-    },
-    async waitForTimeout(ms) {
-      return __pw_invoke("waitForTimeout", [ms]);
-    },
-    async waitForLoadState(state) {
-      return __pw_invoke("waitForLoadState", [state || null]);
-    },
+      return __pw_invoke("waitForSelector", [selector, options ? JSON.stringify(options) : null], { pageId: this.#pageId });
+    }
+    async waitForTimeout(ms) { return __pw_invoke("waitForTimeout", [ms], { pageId: this.#pageId }); }
+    async waitForLoadState(state) { return __pw_invoke("waitForLoadState", [state || null], { pageId: this.#pageId }); }
     async evaluate(script, arg) {
       const hasArg = arguments.length > 1;
       if (hasArg) {
         const serialized = typeof script === "function" ? script.toString() : script;
-        return __pw_invoke("evaluate", [serialized, arg]);
+        return __pw_invoke("evaluate", [serialized, arg], { pageId: this.#pageId });
       }
       const serialized = typeof script === "function" ? "(" + script.toString() + ")()" : script;
-      return __pw_invoke("evaluate", [serialized]);
-    },
-    locator(selector) { return new Locator("css", selector, null); },
+      return __pw_invoke("evaluate", [serialized], { pageId: this.#pageId });
+    }
+    locator(selector) { return new Locator("css", selector, null, this.#pageId); }
     getByRole(role, options) {
       if (options) {
         const serialized = { ...options };
-        if (options.name instanceof RegExp) {
-          serialized.name = { $regex: options.name.source, $flags: options.name.flags };
+        const name = options.name;
+        if (name && typeof name === 'object' && typeof name.source === 'string' && typeof name.flags === 'string') {
+          serialized.name = { $regex: name.source, $flags: name.flags };
         }
-        return new Locator("role", role, JSON.stringify(serialized));
+        return new Locator("role", role, JSON.stringify(serialized), this.#pageId);
       }
-      return new Locator("role", role, null);
-    },
-    getByText(text) { return new Locator("text", text, null); },
-    getByLabel(label) { return new Locator("label", label, null); },
-    getByPlaceholder(p) { return new Locator("placeholder", p, null); },
-    getByTestId(id) { return new Locator("testId", id, null); },
+      return new Locator("role", role, null, this.#pageId);
+    }
+    getByText(text) { return new Locator("text", text, null, this.#pageId); }
+    getByLabel(label) { return new Locator("label", label, null, this.#pageId); }
+    getByPlaceholder(p) { return new Locator("placeholder", p, null, this.#pageId); }
+    getByTestId(id) { return new Locator("testId", id, null, this.#pageId); }
+    getByAltText(alt) { return new Locator("altText", alt, null, this.#pageId); }
+    getByTitle(title) { return new Locator("title", title, null, this.#pageId); }
+    frameLocator(selector) {
+      const pageId = this.#pageId;
+      return {
+        locator(innerSelector) { return new Locator("frame", JSON.stringify([["css", selector, null], ["css", innerSelector, null]]), null, pageId); },
+        getByRole(role, options) { return new Locator("frame", JSON.stringify([["css", selector, null], ["role", role, options ? JSON.stringify(options) : null]]), null, pageId); },
+        getByText(text) { return new Locator("frame", JSON.stringify([["css", selector, null], ["text", text, null]]), null, pageId); },
+        getByLabel(label) { return new Locator("frame", JSON.stringify([["css", selector, null], ["label", label, null]]), null, pageId); },
+        getByPlaceholder(placeholder) { return new Locator("frame", JSON.stringify([["css", selector, null], ["placeholder", placeholder, null]]), null, pageId); },
+        getByTestId(testId) { return new Locator("frame", JSON.stringify([["css", selector, null], ["testId", testId, null]]), null, pageId); },
+        getByAltText(alt) { return new Locator("frame", JSON.stringify([["css", selector, null], ["altText", alt, null]]), null, pageId); },
+        getByTitle(title) { return new Locator("frame", JSON.stringify([["css", selector, null], ["title", title, null]]), null, pageId); },
+      };
+    }
     async goBack(options) {
-      await __pw_invoke("goBack", [options?.waitUntil || null]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-    },
+      await __pw_invoke("goBack", [options?.waitUntil || null], { pageId: this.#pageId });
+      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
+      if (resolvedUrl) this.#currentUrl = resolvedUrl;
+    }
     async goForward(options) {
-      await __pw_invoke("goForward", [options?.waitUntil || null]);
-      const resolvedUrl = await __pw_invoke("url", []);
-      if (resolvedUrl) __pw_currentUrl = resolvedUrl;
-    },
+      await __pw_invoke("goForward", [options?.waitUntil || null], { pageId: this.#pageId });
+      const resolvedUrl = await __pw_invoke("url", [], { pageId: this.#pageId });
+      if (resolvedUrl) this.#currentUrl = resolvedUrl;
+    }
     async waitForURL(url, options) {
-      return __pw_invoke("waitForURL", [url, options?.timeout || null, options?.waitUntil || null]);
-    },
+      let serializedUrl = url;
+      if (url && typeof url === 'object' && typeof url.source === 'string' && typeof url.flags === 'string') {
+        serializedUrl = { $regex: url.source, $flags: url.flags };
+      }
+      return __pw_invoke("waitForURL", [serializedUrl, options?.timeout || null, options?.waitUntil || null], { pageId: this.#pageId });
+    }
     context() {
+      const contextId = this.#contextId;
+      return new IsolateContext(contextId);
+    }
+    async click(selector) { return this.locator(selector).click(); }
+    async fill(selector, value) { return this.locator(selector).fill(value); }
+    async textContent(selector) { return this.locator(selector).textContent(); }
+    async innerText(selector) { return this.locator(selector).innerText(); }
+    async innerHTML(selector) { return this.locator(selector).innerHTML(); }
+    async getAttribute(selector, name) { return this.locator(selector).getAttribute(name); }
+    async inputValue(selector) { return this.locator(selector).inputValue(); }
+    async isVisible(selector) { return this.locator(selector).isVisible(); }
+    async isEnabled(selector) { return this.locator(selector).isEnabled(); }
+    async isChecked(selector) { return this.locator(selector).isChecked(); }
+    async isHidden(selector) { return this.locator(selector).isHidden(); }
+    async isDisabled(selector) { return this.locator(selector).isDisabled(); }
+    async screenshot(options) { return __pw_invoke("screenshot", [options || {}], { pageId: this.#pageId }); }
+    async setViewportSize(size) { return __pw_invoke("setViewportSize", [size], { pageId: this.#pageId }); }
+    async viewportSize() { return __pw_invoke("viewportSize", [], { pageId: this.#pageId }); }
+    async emulateMedia(options) { return __pw_invoke("emulateMedia", [options], { pageId: this.#pageId }); }
+    async setExtraHTTPHeaders(headers) { return __pw_invoke("setExtraHTTPHeaders", [headers], { pageId: this.#pageId }); }
+    async bringToFront() { return __pw_invoke("bringToFront", [], { pageId: this.#pageId }); }
+    async close() { return __pw_invoke("close", [], { pageId: this.#pageId }); }
+    async isClosed() { return __pw_invoke("isClosed", [], { pageId: this.#pageId }); }
+    async pdf(options) { return __pw_invoke("pdf", [options || {}], { pageId: this.#pageId }); }
+    async pause() { return __pw_invoke("pause", [], { pageId: this.#pageId }); }
+    async frames() { return __pw_invoke("frames", [], { pageId: this.#pageId }); }
+    async mainFrame() { return __pw_invoke("mainFrame", [], { pageId: this.#pageId }); }
+    get keyboard() {
+      const pageId = this.#pageId;
       return {
-        async clearCookies() {
-          return __pw_invoke("clearCookies", []);
-        }
+        async type(text, options) { return __pw_invoke("keyboardType", [text, options], { pageId }); },
+        async press(key, options) { return __pw_invoke("keyboardPress", [key, options], { pageId }); },
+        async down(key) { return __pw_invoke("keyboardDown", [key], { pageId }); },
+        async up(key) { return __pw_invoke("keyboardUp", [key], { pageId }); },
+        async insertText(text) { return __pw_invoke("keyboardInsertText", [text], { pageId }); }
       };
-    },
-    async click(selector) { return this.locator(selector).click(); },
-    async fill(selector, value) { return this.locator(selector).fill(value); },
-    request: {
-      async fetch(url, options) {
-        const result = await __pw_invoke("request", [url, options?.method || "GET", options?.data, options?.headers]);
-        return {
-          status: () => result.status,
-          ok: () => result.ok,
-          headers: () => result.headers,
-          json: async () => result.json,
-          text: async () => result.text,
-          body: async () => result.body,
-        };
-      },
-      async get(url, options) {
-        return this.fetch(url, { ...options, method: "GET" });
-      },
-      async post(url, options) {
-        return this.fetch(url, { ...options, method: "POST" });
-      },
-      async put(url, options) {
-        return this.fetch(url, { ...options, method: "PUT" });
-      },
-      async delete(url, options) {
-        return this.fetch(url, { ...options, method: "DELETE" });
-      },
-    },
+    }
+    get mouse() {
+      const pageId = this.#pageId;
+      return {
+        async move(x, y, options) { return __pw_invoke("mouseMove", [x, y, options], { pageId }); },
+        async click(x, y, options) { return __pw_invoke("mouseClick", [x, y, options], { pageId }); },
+        async down(options) { return __pw_invoke("mouseDown", [options], { pageId }); },
+        async up(options) { return __pw_invoke("mouseUp", [options], { pageId }); },
+        async wheel(deltaX, deltaY) { return __pw_invoke("mouseWheel", [deltaX, deltaY], { pageId }); }
+      };
+    }
+    get request() {
+      const pageId = this.#pageId;
+      return {
+        async fetch(url, options) {
+          const result = await __pw_invoke("request", [url, options?.method || "GET", options?.data, options?.headers], { pageId });
+          return {
+            status: () => result.status,
+            ok: () => result.ok,
+            headers: () => result.headers,
+            json: async () => result.json,
+            text: async () => result.text,
+            body: async () => result.body,
+          };
+        },
+        async get(url, options) { return this.fetch(url, { ...options, method: "GET" }); },
+        async post(url, options) { return this.fetch(url, { ...options, method: "POST" }); },
+        async put(url, options) { return this.fetch(url, { ...options, method: "PUT" }); },
+        async delete(url, options) { return this.fetch(url, { ...options, method: "DELETE" }); },
+      };
+    }
+  }
+  globalThis.IsolatePage = IsolatePage;
+
+  // IsolateContext class - represents a browser context with a specific contextId
+  class IsolateContext {
+    #contextId;
+    constructor(contextId) { this.#contextId = contextId; }
+    get __contextId() { return this.#contextId; }
+
+    async newPage() {
+      const result = await __pw_invoke("newPage", [], { contextId: this.#contextId });
+      return new IsolatePage(result.pageId, this.#contextId);
+    }
+    async close() { return __pw_invoke("closeContext", [], { contextId: this.#contextId }); }
+    async clearCookies() { return __pw_invoke("clearCookies", [], { contextId: this.#contextId }); }
+    async addCookies(cookies) { return __pw_invoke("addCookies", [cookies], { contextId: this.#contextId }); }
+    async cookies(urls) { return __pw_invoke("cookies", [urls], { contextId: this.#contextId }); }
+  }
+  globalThis.IsolateContext = IsolateContext;
+
+  // browser global - for creating new contexts
+  globalThis.browser = {
+    async newContext(options) {
+      const result = await __pw_invoke("newContext", [options || null]);
+      return new IsolateContext(result.contextId);
+    }
   };
+
+  // context global - represents the default context
+  globalThis.context = new IsolateContext("ctx_0");
+
+  // page global - represents the default page
+  globalThis.page = new IsolatePage("page_0", "ctx_0");
 })();
 `);
   context.evalSync(`
 (function() {
+  // Helper to serialize options including RegExp
+  function serializeOptions(options) {
+    if (!options) return null;
+    const serialized = { ...options };
+    if (options.name && typeof options.name === 'object' && typeof options.name.source === 'string' && typeof options.name.flags === 'string') {
+      serialized.name = { $regex: options.name.source, $flags: options.name.flags };
+    }
+    return JSON.stringify(serialized);
+  }
+
   class Locator {
-    #type; #value; #options;
-    constructor(type, value, options) {
+    #type; #value; #options; #pageId;
+    constructor(type, value, options, pageId) {
       this.#type = type;
       this.#value = value;
       this.#options = options;
+      this.#pageId = pageId || "page_0";
     }
 
     _getInfo() { return [this.#type, this.#value, this.#options]; }
+    _getPageId() { return this.#pageId; }
+
+    // Helper to create a chained locator
+    _chain(childType, childValue, childOptions) {
+      const parentInfo = this._getInfo();
+      const childInfo = [childType, childValue, childOptions];
+      return new Locator("chained", JSON.stringify([parentInfo, childInfo]), null, this.#pageId);
+    }
 
     async click() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "click", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "click", null], { pageId: this.#pageId });
     }
     async dblclick() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dblclick", null], { pageId: this.#pageId });
     }
     async fill(text) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "fill", text], { pageId: this.#pageId });
     }
     async type(text) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "type", text], { pageId: this.#pageId });
     }
     async check() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "check", null], { pageId: this.#pageId });
     }
     async uncheck() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "uncheck", null], { pageId: this.#pageId });
     }
     async selectOption(value) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "selectOption", value], { pageId: this.#pageId });
     }
     async clear() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "clear", null], { pageId: this.#pageId });
     }
     async press(key) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "press", key], { pageId: this.#pageId });
     }
     async hover() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "hover", null], { pageId: this.#pageId });
     }
     async focus() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "focus", null], { pageId: this.#pageId });
     }
     async textContent() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getText", null], { pageId: this.#pageId });
     }
     async inputValue() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getValue", null], { pageId: this.#pageId });
     }
     async isVisible() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isVisible", null], { pageId: this.#pageId });
     }
     async isEnabled() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isEnabled", null], { pageId: this.#pageId });
     }
     async isChecked() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isChecked", null], { pageId: this.#pageId });
     }
     async count() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "count", null], { pageId: this.#pageId });
     }
     async getAttribute(name) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "getAttribute", name]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "getAttribute", name], { pageId: this.#pageId });
     }
     async isDisabled() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isDisabled", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isDisabled", null], { pageId: this.#pageId });
     }
     async isHidden() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "isHidden", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "isHidden", null], { pageId: this.#pageId });
     }
     async innerHTML() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "innerHTML", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerHTML", null], { pageId: this.#pageId });
     }
     async innerText() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "innerText", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "innerText", null], { pageId: this.#pageId });
     }
     async allTextContents() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "allTextContents", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allTextContents", null], { pageId: this.#pageId });
     }
     async allInnerTexts() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "allInnerTexts", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "allInnerTexts", null], { pageId: this.#pageId });
     }
     async waitFor(options) {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "waitFor", options || {}]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "waitFor", options || {}], { pageId: this.#pageId });
     }
     async boundingBox() {
-      return __pw_invoke("locatorAction", [...this._getInfo(), "boundingBox", null]);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "boundingBox", null], { pageId: this.#pageId });
     }
-    locator(selector) {
-      const parentSelector = this.#type === 'css' ? this.#value : null;
-      if (parentSelector) {
-        return new Locator("css", parentSelector + " " + selector, this.#options);
+    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)))
+        }));
       }
-      // For non-css locators, use css with the combined approach
-      return new Locator("css", selector, this.#options);
+      return __pw_invoke("locatorAction", [...this._getInfo(), "setInputFiles", serializedFiles], { pageId: this.#pageId });
+    }
+    async screenshot(options) {
+      const base64 = await __pw_invoke("locatorAction", [...this._getInfo(), "screenshot", options || {}], { pageId: this.#pageId });
+      return base64;
+    }
+    async dragTo(target) {
+      const targetInfo = target._getInfo();
+      return __pw_invoke("locatorAction", [...this._getInfo(), "dragTo", targetInfo], { pageId: this.#pageId });
+    }
+    async scrollIntoViewIfNeeded() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "scrollIntoViewIfNeeded", null], { pageId: this.#pageId });
+    }
+    async highlight() {
+      return __pw_invoke("locatorAction", [...this._getInfo(), "highlight", null], { pageId: this.#pageId });
+    }
+    async evaluate(fn, arg) {
+      const fnString = typeof fn === 'function' ? fn.toString() : fn;
+      return __pw_invoke("locatorAction", [...this._getInfo(), "evaluate", [fnString, arg]], { pageId: this.#pageId });
+    }
+    async evaluateAll(fn, arg) {
+      const fnString = typeof fn === 'function' ? fn.toString() : fn;
+      return __pw_invoke("locatorAction", [...this._getInfo(), "evaluateAll", [fnString, arg]], { pageId: this.#pageId });
+    }
+    locator(selector) {
+      return this._chain("css", selector, null);
+    }
+    // Chaining: getBy* methods within a locator
+    getByRole(role, options) {
+      return this._chain("role", role, serializeOptions(options));
+    }
+    getByText(text) {
+      return this._chain("text", text, null);
+    }
+    getByLabel(label) {
+      return this._chain("label", label, null);
+    }
+    getByPlaceholder(placeholder) {
+      return this._chain("placeholder", placeholder, null);
+    }
+    getByTestId(testId) {
+      return this._chain("testId", testId, null);
+    }
+    getByAltText(altText) {
+      return this._chain("altText", altText, null);
+    }
+    getByTitle(title) {
+      return this._chain("title", title, null);
     }
     async all() {
       const n = await this.count();
@@ -799,7 +1595,7 @@ async function setupPlaywright(context, options) {
     }
     nth(index) {
       const existingOpts = this.#options ? JSON.parse(this.#options) : {};
-      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }));
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, nth: index }), this.#pageId);
     }
     first() {
       return this.nth(0);
@@ -810,13 +1606,37 @@ async function setupPlaywright(context, options) {
     filter(options) {
       const existingOpts = this.#options ? JSON.parse(this.#options) : {};
       const serializedFilter = { ...options };
-      if (options.hasText instanceof RegExp) {
-        serializedFilter.hasText = { $regex: options.hasText.source, $flags: options.hasText.flags };
+      // Use duck-typing RegExp detection (instanceof fails across isolated-vm boundary)
+      const hasText = options.hasText;
+      if (hasText && typeof hasText === 'object' && typeof hasText.source === 'string' && typeof hasText.flags === 'string') {
+        serializedFilter.hasText = { $regex: hasText.source, $flags: hasText.flags };
       }
-      if (options.hasNotText instanceof RegExp) {
-        serializedFilter.hasNotText = { $regex: options.hasNotText.source, $flags: options.hasNotText.flags };
+      const hasNotText = options.hasNotText;
+      if (hasNotText && typeof hasNotText === 'object' && typeof hasNotText.source === 'string' && typeof hasNotText.flags === 'string') {
+        serializedFilter.hasNotText = { $regex: hasNotText.source, $flags: hasNotText.flags };
       }
-      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, filter: serializedFilter }));
+      // Serialize has/hasNot locators using duck-typing
+      const has = options.has;
+      if (has && typeof has === 'object' && typeof has._getInfo === 'function') {
+        serializedFilter.has = { $locator: has._getInfo() };
+      }
+      const hasNot = options.hasNot;
+      if (hasNot && typeof hasNot === 'object' && typeof hasNot._getInfo === 'function') {
+        serializedFilter.hasNot = { $locator: hasNot._getInfo() };
+      }
+      return new Locator(this.#type, this.#value, JSON.stringify({ ...existingOpts, filter: serializedFilter }), this.#pageId);
+    }
+    or(other) {
+      // Create a composite locator that matches either this or other
+      const thisInfo = this._getInfo();
+      const otherInfo = other._getInfo();
+      return new Locator("or", JSON.stringify([thisInfo, otherInfo]), null, this.#pageId);
+    }
+    and(other) {
+      // Create a composite locator that matches both this and other
+      const thisInfo = this._getInfo();
+      const otherInfo = other._getInfo();
+      return new Locator("and", JSON.stringify([thisInfo, otherInfo]), null, this.#pageId);
     }
   }
   globalThis.Locator = Locator;
@@ -827,84 +1647,157 @@ async function setupPlaywright(context, options) {
   // Helper to create locator matchers
   function createLocatorMatchers(locator, baseMatchers) {
     const info = locator._getInfo();
+    const pageId = locator._getPageId ? locator._getPageId() : "page_0";
+
+    // Helper for serializing regex values
+    function serializeExpected(expected) {
+      if (expected instanceof RegExp) {
+        return { $regex: expected.source, $flags: expected.flags };
+      }
+      return expected;
+    }
 
     const locatorMatchers = {
       async toBeVisible(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeVisible", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeVisible", null, false, options?.timeout], { pageId });
       },
       async toContainText(expected, options) {
-        const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-        return __pw_invoke("expectLocator", [...info, "toContainText", serialized, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toContainText", serializeExpected(expected), false, options?.timeout], { pageId });
       },
       async toHaveValue(expected, options) {
-        return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, false, options?.timeout], { pageId });
       },
       async toBeEnabled(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, false, options?.timeout], { pageId });
       },
       async toBeChecked(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeChecked", null, false, options?.timeout], { pageId });
       },
       async toHaveAttribute(name, value, options) {
-        return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value }, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, false, options?.timeout], { pageId });
       },
       async toHaveText(expected, options) {
-        const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-        return __pw_invoke("expectLocator", [...info, "toHaveText", serialized, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toHaveText", serializeExpected(expected), false, options?.timeout], { pageId });
       },
       async toHaveCount(count, options) {
-        return __pw_invoke("expectLocator", [...info, "toHaveCount", count, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toHaveCount", count, false, options?.timeout], { pageId });
       },
       async toBeHidden(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeHidden", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeHidden", null, false, options?.timeout], { pageId });
       },
       async toBeDisabled(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, false, options?.timeout], { pageId });
       },
       async toBeFocused(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeFocused", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeFocused", null, false, options?.timeout], { pageId });
       },
       async toBeEmpty(options) {
-        return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, false, options?.timeout]);
+        return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, false, options?.timeout], { pageId });
+      },
+      // New matchers
+      async toBeAttached(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeAttached", null, false, options?.timeout], { pageId });
+      },
+      async toBeEditable(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeEditable", null, false, options?.timeout], { pageId });
+      },
+      async toHaveClass(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveClass", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toContainClass(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toContainClass", expected, false, options?.timeout], { pageId });
+      },
+      async toHaveId(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveId", expected, false, options?.timeout], { pageId });
+      },
+      async toBeInViewport(options) {
+        return __pw_invoke("expectLocator", [...info, "toBeInViewport", null, false, options?.timeout], { pageId });
+      },
+      async toHaveCSS(name, value, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveCSS", { name, value: serializeExpected(value) }, false, options?.timeout], { pageId });
+      },
+      async toHaveJSProperty(name, value, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveJSProperty", { name, value }, false, options?.timeout], { pageId });
+      },
+      async toHaveAccessibleName(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveAccessibleName", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveAccessibleDescription(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveAccessibleDescription", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveRole(expected, options) {
+        return __pw_invoke("expectLocator", [...info, "toHaveRole", expected, false, options?.timeout], { pageId });
       },
       not: {
         async toBeVisible(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeVisible", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeVisible", null, true, options?.timeout], { pageId });
         },
         async toContainText(expected, options) {
-          const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-          return __pw_invoke("expectLocator", [...info, "toContainText", serialized, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toContainText", serializeExpected(expected), true, options?.timeout], { pageId });
         },
         async toHaveValue(expected, options) {
-          return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toHaveValue", expected, true, options?.timeout], { pageId });
         },
         async toBeEnabled(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeEnabled", null, true, options?.timeout], { pageId });
         },
         async toBeChecked(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeChecked", null, true, options?.timeout], { pageId });
         },
         async toHaveAttribute(name, value, options) {
-          return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value }, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toHaveAttribute", { name, value: serializeExpected(value) }, true, options?.timeout], { pageId });
         },
         async toHaveText(expected, options) {
-          const serialized = expected instanceof RegExp ? { $regex: expected.source, $flags: expected.flags } : expected;
-          return __pw_invoke("expectLocator", [...info, "toHaveText", serialized, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toHaveText", serializeExpected(expected), true, options?.timeout], { pageId });
         },
         async toHaveCount(count, options) {
-          return __pw_invoke("expectLocator", [...info, "toHaveCount", count, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toHaveCount", count, true, options?.timeout], { pageId });
         },
         async toBeHidden(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeHidden", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeHidden", null, true, options?.timeout], { pageId });
         },
         async toBeDisabled(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeDisabled", null, true, options?.timeout], { pageId });
         },
         async toBeFocused(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeFocused", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeFocused", null, true, options?.timeout], { pageId });
         },
         async toBeEmpty(options) {
-          return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, true, options?.timeout]);
+          return __pw_invoke("expectLocator", [...info, "toBeEmpty", null, true, options?.timeout], { pageId });
+        },
+        // New negated matchers
+        async toBeAttached(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeAttached", null, true, options?.timeout], { pageId });
+        },
+        async toBeEditable(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeEditable", null, true, options?.timeout], { pageId });
+        },
+        async toHaveClass(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveClass", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toContainClass(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toContainClass", expected, true, options?.timeout], { pageId });
+        },
+        async toHaveId(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveId", expected, true, options?.timeout], { pageId });
+        },
+        async toBeInViewport(options) {
+          return __pw_invoke("expectLocator", [...info, "toBeInViewport", null, true, options?.timeout], { pageId });
+        },
+        async toHaveCSS(name, value, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveCSS", { name, value: serializeExpected(value) }, true, options?.timeout], { pageId });
+        },
+        async toHaveJSProperty(name, value, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveJSProperty", { name, value }, true, options?.timeout], { pageId });
+        },
+        async toHaveAccessibleName(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveAccessibleName", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveAccessibleDescription(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveAccessibleDescription", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveRole(expected, options) {
+          return __pw_invoke("expectLocator", [...info, "toHaveRole", expected, true, options?.timeout], { pageId });
         },
       }
     };
@@ -920,6 +1813,44 @@ async function setupPlaywright(context, options) {
     return locatorMatchers;
   }
 
+  // Helper to create page matchers
+  function createPageMatchers(page, baseMatchers) {
+    const pageId = page.__pageId || "page_0";
+
+    function serializeExpected(expected) {
+      if (expected instanceof RegExp) {
+        return { $regex: expected.source, $flags: expected.flags };
+      }
+      return expected;
+    }
+
+    const pageMatchers = {
+      async toHaveURL(expected, options) {
+        return __pw_invoke("expectPage", ["toHaveURL", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      async toHaveTitle(expected, options) {
+        return __pw_invoke("expectPage", ["toHaveTitle", serializeExpected(expected), false, options?.timeout], { pageId });
+      },
+      not: {
+        async toHaveURL(expected, options) {
+          return __pw_invoke("expectPage", ["toHaveURL", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+        async toHaveTitle(expected, options) {
+          return __pw_invoke("expectPage", ["toHaveTitle", serializeExpected(expected), true, options?.timeout], { pageId });
+        },
+      }
+    };
+
+    if (baseMatchers) {
+      return {
+        ...baseMatchers,
+        ...pageMatchers,
+        not: { ...baseMatchers.not, ...pageMatchers.not }
+      };
+    }
+    return pageMatchers;
+  }
+
   // Only extend expect if test-environment already defined it
   if (typeof globalThis.expect === 'function') {
     const originalExpect = globalThis.expect;
@@ -929,6 +1860,10 @@ async function setupPlaywright(context, options) {
       if (actual && actual.constructor && actual.constructor.name === 'Locator') {
         return createLocatorMatchers(actual, baseMatchers);
       }
+      // If actual is the page object (IsolatePage), add page-specific matchers
+      if (actual && actual.__isPage === true) {
+        return createPageMatchers(actual, baseMatchers);
+      }
       return baseMatchers;
     };
   }
@@ -963,4 +1898,4 @@ async function setupPlaywright(context, options) {
   };
 }
 
-//# debugId=2CC694A6398FE85E64756E2164756E21
+//# debugId=EC7671328EAA005364756E2164756E21