From 39f6d09017440be4adfdd759100a447ea03ca5ac Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 21:47:14 +0100
Subject: [PATCH 01/33] implement clock

---
 scripts/coverage.ts    |   1 +
 src/browser-context.ts |   6 ++
 src/clock.ts           | 124 +++++++++++++++++++++++++++++++++++++++++
 src/index.ts           |   1 +
 src/page.test.ts       |  79 +++++++++++++++++++++++---
 src/page.ts            |   6 ++
 6 files changed, 209 insertions(+), 8 deletions(-)
 create mode 100644 src/clock.ts

diff --git a/scripts/coverage.ts b/scripts/coverage.ts
index 406a9aa..13bbce1 100644
--- a/scripts/coverage.ts
+++ b/scripts/coverage.ts
@@ -20,6 +20,7 @@ const MAPPINGS = [
   { pw: "Dialog", ep: "PlaywrightDialog", type: "class" as const },
   { pw: "FileChooser", ep: "PlaywrightFileChooser", type: "class" as const },
   { pw: "Download", ep: "PlaywrightDownload", type: "class" as const },
+  { pw: "Clock", ep: "PlaywrightClockService", type: "interface" as const },
 ];
 
 const EXCLUDED_METHODS = new Set([
diff --git a/src/browser-context.ts b/src/browser-context.ts
index 4030f02..dd15a99 100644
--- a/src/browser-context.ts
+++ b/src/browser-context.ts
@@ -17,6 +17,7 @@ import {
 } from "./common";
 import type { PlaywrightError } from "./errors";
 import { PlaywrightPage } from "./page";
+import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import type { PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
 
@@ -58,6 +59,10 @@ type BrowserContextWithPatchedEvents = PatchedEvents<
  * @since 0.1.0
  */
 export interface PlaywrightBrowserContextService {
+  /**
+   * Access the clock.
+   */
+  readonly clock: PlaywrightClockService;
   /**
    * Returns the list of all open pages in the browser context.
    *
@@ -122,6 +127,7 @@ export class PlaywrightBrowserContext extends Context.Tag(
   ): PlaywrightBrowserContextService {
     const use = useHelper(context);
     return PlaywrightBrowserContext.of({
+      clock: PlaywrightClock.make(context.clock),
       pages: Effect.sync(() => context.pages().map(PlaywrightPage.make)),
       newPage: use((c) => c.newPage().then(PlaywrightPage.make)),
       close: use((c) => c.close()),
diff --git a/src/clock.ts b/src/clock.ts
new file mode 100644
index 0000000..88ac267
--- /dev/null
+++ b/src/clock.ts
@@ -0,0 +1,124 @@
+import { Context, type Effect } from "effect";
+import type { Clock } from "playwright-core";
+import type { PlaywrightError } from "./errors";
+import { useHelper } from "./utils";
+
+/**
+ * Interface for a Playwright clock.
+ * @category model
+ */
+export interface PlaywrightClockService {
+  /**
+   * Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user
+   * closing the laptop lid for a while and reopening it later, after given time.
+   *
+   * @see {@link Clock.fastForward}
+   * @since 0.1.0
+   */
+  readonly fastForward: (
+    ticks: number | string,
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Install fake implementations for time-related functions.
+   *
+   * @see {@link Clock.install}
+   * @since 0.1.0
+   */
+  readonly install: (options?: {
+    time?: number | string | Date;
+  }) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Advance the clock by jumping forward in time and pause the time.
+   *
+   * @see {@link Clock.pauseAt}
+   * @since 0.1.0
+   */
+  readonly pauseAt: (
+    time: number | string | Date,
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+   *
+   * @see {@link Clock.resume}
+   * @since 0.1.0
+   */
+  readonly resume: Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Advance the clock, firing all the time-related callbacks.
+   *
+   * @see {@link Clock.runFor}
+   * @since 0.1.0
+   */
+  readonly runFor: (
+    ticks: number | string,
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Makes `Date.now` and `new Date()` return fixed fake time at all times, keeps all the timers running.
+   *
+   * @see {@link Clock.setFixedTime}
+   * @since 0.1.0
+   */
+  readonly setFixedTime: (
+    time: number | string | Date,
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Sets system time, but does not trigger any timers.
+   *
+   * @see {@link Clock.setSystemTime}
+   * @since 0.1.0
+   */
+  readonly setSystemTime: (
+    time: number | string | Date,
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * A generic utility to execute any promise-based method on the underlying Playwright `Clock`.
+   * Can be used to access any Clock functionality not directly exposed by this service.
+   *
+   * @param f - A function that takes the Playwright `Clock` and returns a `Promise`.
+   * @returns An effect that wraps the promise and returns its result.
+   * @see {@link Clock}
+   * @since 0.1.0
+   */
+  readonly use: <T>(
+    f: (clock: Clock) => Promise<T>,
+  ) => Effect.Effect<T, PlaywrightError>;
+}
+
+/**
+ * A service that provides a `PlaywrightClock` instance.
+ *
+ * @since 0.1.0
+ * @category tag
+ */
+export class PlaywrightClock extends Context.Tag(
+  "effect-playwright/PlaywrightClock",
+)<PlaywrightClock, PlaywrightClockService>() {
+  /**
+   * Creates a `PlaywrightClock` from a Playwright `Clock` instance.
+   *
+   * @param clock - The Playwright `Clock` instance to wrap.
+   * @since 0.1.0
+   * @category constructor
+   */
+  static make(clock: Clock): typeof PlaywrightClock.Service {
+    const use = useHelper(clock);
+
+    return PlaywrightClock.of({
+      fastForward: (ticks) => use((c) => c.fastForward(ticks)),
+      install: (options) => use((c) => c.install(options)),
+      pauseAt: (time) => use((c) => c.pauseAt(time)),
+      resume: use((c) => c.resume()),
+      runFor: (ticks) => use((c) => c.runFor(ticks)),
+      setFixedTime: (time) => use((c) => c.setFixedTime(time)),
+      setSystemTime: (time) => use((c) => c.setSystemTime(time)),
+      use,
+    });
+  }
+}
diff --git a/src/index.ts b/src/index.ts
index af20ec5..5fd8734 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -26,3 +26,4 @@ export * from "./frame";
 export * from "./locator";
 export * from "./page";
 export * from "./playwright";
+export * from "./clock";
diff --git a/src/page.test.ts b/src/page.test.ts
index 7bbe235..e4ab3c9 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -4,6 +4,12 @@ import { chromium } from "playwright-core";
 import { PlaywrightBrowser } from "./browser";
 import { PlaywrightEnvironment } from "./experimental";
 
+type TestWindow = Window & {
+  timerFired?: boolean;
+  clicked?: boolean;
+  clickCoords?: { x: number; y: number } | null;
+};
+
 layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
   it.scoped("goto should navigate to a URL", () =>
     Effect.gen(function* () {
@@ -35,7 +41,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       const page = yield* browser.newPage();
 
       yield* page.evaluate(() => {
-        const win = window as Window & { clicked?: boolean };
+        const win = window as TestWindow;
         document.body.innerHTML =
           '<button id="mybutton" onclick="window.clicked = true">Click Me</button>';
         win.clicked = false;
@@ -44,7 +50,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       yield* page.click("#mybutton");
 
       const clicked = yield* page.evaluate(
-        () => (window as Window & { clicked?: boolean }).clicked,
+        () => (window as TestWindow).clicked,
       );
       assert(clicked === true);
     }).pipe(PlaywrightEnvironment.withBrowser),
@@ -92,9 +98,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       const page = yield* browser.newPage();
 
       yield* page.evaluate(() => {
-        const win = window as Window & {
-          clickCoords?: { x: number; y: number } | null;
-        };
+        const win = window as TestWindow;
         document.body.innerHTML =
           '<button id="mybutton" style="width: 100px; height: 100px">Click Me</button>';
         win.clickCoords = null;
@@ -107,9 +111,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       yield* page.click("#mybutton", { position: { x: 10, y: 10 } });
 
       const coords = yield* page.evaluate(
-        () =>
-          (window as Window & { clickCoords?: { x: number; y: number } | null })
-            .clickCoords,
+        () => (window as TestWindow).clickCoords,
       );
       assert(coords !== null);
     }).pipe(PlaywrightEnvironment.withBrowser),
@@ -243,4 +245,65 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(page.url(), url2);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("clock should allow fast forwarding time", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      // Install clock
+      yield* page.clock.install({ time: new Date("2024-01-01T00:00:00.000Z") });
+
+      yield* page.evaluate(() => {
+        (window as TestWindow).timerFired = false;
+        setTimeout(() => {
+          (window as TestWindow).timerFired = true;
+        }, 10000);
+      });
+
+      let timerFired = yield* page.evaluate(
+        () => (window as TestWindow).timerFired,
+      );
+      assert.strictEqual(timerFired, false);
+
+      yield* page.clock.fastForward(10000);
+
+      timerFired = yield* page.evaluate(
+        () => (window as TestWindow).timerFired,
+      );
+      assert.strictEqual(timerFired, true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("clock should allow fast forwarding time on context", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const context = yield* browser.newContext();
+      const page = yield* context.newPage;
+
+      // Install clock on context
+      yield* context.clock.install({
+        time: new Date("2024-01-01T00:00:00.000Z"),
+      });
+
+      yield* page.evaluate(() => {
+        (window as TestWindow).timerFired = false;
+        setTimeout(() => {
+          (window as TestWindow).timerFired = true;
+        }, 10000);
+      });
+
+      let timerFired = yield* page.evaluate(
+        () => (window as TestWindow).timerFired,
+      );
+      assert.strictEqual(timerFired, false);
+
+      yield* context.clock.fastForward(10000);
+
+      timerFired = yield* page.evaluate(
+        () => (window as TestWindow).timerFired,
+      );
+      assert.strictEqual(timerFired, true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 08df20c..4405d20 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -24,6 +24,7 @@ import {
 import type { PlaywrightError } from "./errors";
 import { PlaywrightFrame } from "./frame";
 import { PlaywrightLocator } from "./locator";
+import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import type { PageFunction, PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
 
@@ -79,6 +80,10 @@ type PageWithPatchedEvents = PatchedEvents<Page, PageEvents>;
  * @since 0.1.0
  */
 export interface PlaywrightPageService {
+  /**
+   * Access the clock.
+   */
+  readonly clock: PlaywrightClockService;
   /**
    * Navigates the page to the given URL.
    *
@@ -312,6 +317,7 @@ export class PlaywrightPage extends Context.Tag(
     const use = useHelper(page);
 
     return PlaywrightPage.of({
+      clock: PlaywrightClock.make(page.clock),
       goto: (url, options) => use((p) => p.goto(url, options)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>

From 0109e61e586837caedfa6c4145f987727447f4d4 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 22:36:46 +0100
Subject: [PATCH 02/33] add page.addInitScript

---
 src/browser-context.test.ts | 39 +++++++++++++++++++++++++++++++++++++
 src/browser-context.ts      | 15 +++++++++++++-
 src/page.test.ts            | 19 ++++++++++++++++++
 src/page.ts                 | 17 +++++++++++++---
 4 files changed, 86 insertions(+), 4 deletions(-)
 create mode 100644 src/browser-context.test.ts

diff --git a/src/browser-context.test.ts b/src/browser-context.test.ts
new file mode 100644
index 0000000..4a6f78a
--- /dev/null
+++ b/src/browser-context.test.ts
@@ -0,0 +1,39 @@
+import { assert, layer } from "@effect/vitest";
+import { Effect } from "effect";
+import { chromium } from "playwright-core";
+import { PlaywrightBrowser } from "./browser";
+import { PlaywrightEnvironment } from "./experimental";
+
+type TestWindow = Window & {
+  magicValue?: number;
+};
+
+layer(PlaywrightEnvironment.layer(chromium))(
+  "PlaywrightBrowserContext",
+  (it) => {
+    it.scoped("addInitScript should execute script in all new pages", () =>
+      Effect.gen(function* () {
+        const browser = yield* PlaywrightBrowser;
+        const context = yield* browser.newContext();
+
+        yield* context.addInitScript(() => {
+          (window as TestWindow).magicValue = 84;
+        });
+
+        const page1 = yield* context.newPage;
+        yield* page1.goto("about:blank");
+        const magicValue1 = yield* page1.evaluate(
+          () => (window as TestWindow).magicValue,
+        );
+        assert.strictEqual(magicValue1, 84);
+
+        const page2 = yield* context.newPage;
+        yield* page2.goto("about:blank");
+        const magicValue2 = yield* page2.evaluate(
+          () => (window as TestWindow).magicValue,
+        );
+        assert.strictEqual(magicValue2, 84);
+      }).pipe(PlaywrightEnvironment.withBrowser),
+    );
+  },
+);
diff --git a/src/browser-context.ts b/src/browser-context.ts
index dd15a99..d3044ce 100644
--- a/src/browser-context.ts
+++ b/src/browser-context.ts
@@ -9,6 +9,7 @@ import type {
   WebError,
   Worker,
 } from "playwright-core";
+import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import {
   PlaywrightDialog,
   PlaywrightRequest,
@@ -17,7 +18,6 @@ import {
 } from "./common";
 import type { PlaywrightError } from "./errors";
 import { PlaywrightPage } from "./page";
-import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import type { PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
 
@@ -92,6 +92,18 @@ export interface PlaywrightBrowserContextService {
    * @since 0.1.0
    */
   readonly close: Effect.Effect<void, PlaywrightError>;
+  /**
+   * Adds a script which would be evaluated in one of the following scenarios:
+   * - Whenever a page is created in the browser context or is navigated.
+   * - Whenever a child frame is attached or navigated. In this case, the script is evaluated in the context of the newly attached frame.
+   *
+   * @see {@link BrowserContext.addInitScript}
+   * @since 0.2.0
+   */
+  readonly addInitScript: (
+    script: Parameters<BrowserContext["addInitScript"]>[0],
+    arg?: Parameters<BrowserContext["addInitScript"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
 
   /**
    * Creates a stream of the given event from the browser context.
@@ -131,6 +143,7 @@ export class PlaywrightBrowserContext extends Context.Tag(
       pages: Effect.sync(() => context.pages().map(PlaywrightPage.make)),
       newPage: use((c) => c.newPage().then(PlaywrightPage.make)),
       close: use((c) => c.close()),
+      addInitScript: (script, arg) => use((c) => c.addInitScript(script, arg)),
       eventStream: <K extends keyof BrowserContextEvents>(event: K) =>
         Stream.asyncPush<BrowserContextEvents[K]>((emit) =>
           Effect.acquireRelease(
diff --git a/src/page.test.ts b/src/page.test.ts
index e4ab3c9..d46f079 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -8,6 +8,7 @@ type TestWindow = Window & {
   timerFired?: boolean;
   clicked?: boolean;
   clickCoords?: { x: number; y: number } | null;
+  magicValue?: number;
 };
 
 layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
@@ -306,4 +307,22 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(timerFired, true);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("addInitScript should execute script before page load", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.addInitScript(() => {
+        (window as TestWindow).magicValue = 42;
+      });
+
+      yield* page.goto("about:blank");
+
+      const magicValue = yield* page.evaluate(
+        () => (window as TestWindow).magicValue,
+      );
+      assert.strictEqual(magicValue, 42);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 4405d20..e9a31cd 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -11,7 +11,7 @@ import type {
   WebSocket,
   Worker,
 } from "playwright-core";
-
+import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import {
   PlaywrightDialog,
   PlaywrightDownload,
@@ -20,11 +20,9 @@ import {
   PlaywrightResponse,
   PlaywrightWorker,
 } from "./common";
-
 import type { PlaywrightError } from "./errors";
 import { PlaywrightFrame } from "./frame";
 import { PlaywrightLocator } from "./locator";
-import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import type { PageFunction, PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
 
@@ -149,6 +147,18 @@ export interface PlaywrightPageService {
     pageFunction: PageFunction<Arg, R>,
     arg?: Arg,
   ) => Effect.Effect<R, PlaywrightError>;
+  /**
+   * Adds a script which would be evaluated in one of the following scenarios:
+   * - Whenever the page is navigated.
+   * - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the newly attached frame.
+   *
+   * @see {@link Page.addInitScript}
+   * @since 0.2.0
+   */
+  readonly addInitScript: (
+    script: Parameters<Page["addInitScript"]>[0],
+    arg?: Parameters<Page["addInitScript"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
   /**
    * Returns the page title.
    *
@@ -325,6 +335,7 @@ export class PlaywrightPage extends Context.Tag(
       title: use((p) => p.title()),
       evaluate: <R, Arg>(f: PageFunction<Arg, R>, arg?: Arg) =>
         use((p) => p.evaluate<R, Arg>(f, arg as Arg)),
+      addInitScript: (script, arg) => use((p) => p.addInitScript(script, arg)),
       locator: (selector, options) =>
         PlaywrightLocator.make(page.locator(selector, options)),
       getByRole: (role, options) =>

From 7159514f720a7652283320f3f461dbdbf2c58393 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 22:54:02 +0100
Subject: [PATCH 03/33] implement Page.keyboard

---
 src/index.ts     |  3 +-
 src/keyboard.ts  | 83 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/page.test.ts | 19 +++++++++++
 src/page.ts      |  6 ++++
 4 files changed, 110 insertions(+), 1 deletion(-)
 create mode 100644 src/keyboard.ts

diff --git a/src/index.ts b/src/index.ts
index 5fd8734..457b8a1 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -19,11 +19,12 @@ export {
   PlaywrightBrowserContext,
   type PlaywrightBrowserContextService,
 } from "./browser-context";
+export * from "./clock";
 export * from "./common";
 export type { PlaywrightErrorReason } from "./errors";
 export { PlaywrightError } from "./errors";
 export * from "./frame";
+export * from "./keyboard";
 export * from "./locator";
 export * from "./page";
 export * from "./playwright";
-export * from "./clock";
diff --git a/src/keyboard.ts b/src/keyboard.ts
new file mode 100644
index 0000000..e00cbab
--- /dev/null
+++ b/src/keyboard.ts
@@ -0,0 +1,83 @@
+import { Context, type Effect } from "effect";
+import type { Keyboard } from "playwright-core";
+import type { PlaywrightError } from "./errors";
+import { useHelper } from "./utils";
+
+/**
+ * @category model
+ * @since 0.1.0
+ */
+export interface PlaywrightKeyboardService {
+  /**
+   * Dispatches a `keydown` event.
+   *
+   * @see {@link Keyboard.down}
+   * @since 0.1.0
+   */
+  readonly down: (
+    key: Parameters<Keyboard["down"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches only `input` event, does not emit the `keydown`, `keyup` or `keypress` events.
+   *
+   * @see {@link Keyboard.insertText}
+   * @since 0.1.0
+   */
+  readonly insertText: (
+    text: Parameters<Keyboard["insertText"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `keydown` and `keyup` event.
+   *
+   * @see {@link Keyboard.press}
+   * @since 0.1.0
+   */
+  readonly press: (
+    key: Parameters<Keyboard["press"]>[0],
+    options?: Parameters<Keyboard["press"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
+   *
+   * @see {@link Keyboard.type}
+   * @since 0.1.0
+   */
+  readonly type: (
+    text: Parameters<Keyboard["type"]>[0],
+    options?: Parameters<Keyboard["type"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `keyup` event.
+   *
+   * @see {@link Keyboard.up}
+   * @since 0.1.0
+   */
+  readonly up: (
+    key: Parameters<Keyboard["up"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+}
+
+/**
+ * @category tag
+ */
+export class PlaywrightKeyboard extends Context.Tag(
+  "effect-playwright/PlaywrightKeyboard",
+)<PlaywrightKeyboard, PlaywrightKeyboardService>() {
+  /**
+   * Creates a `PlaywrightKeyboard` from a Playwright `Keyboard` instance.
+   *
+   * @param keyboard - The Playwright `Keyboard` instance to wrap.
+   * @since 0.1.0
+   */
+  static make(keyboard: Keyboard): PlaywrightKeyboardService {
+    const use = useHelper(keyboard);
+
+    return PlaywrightKeyboard.of({
+      down: (key) => use((k) => k.down(key)),
+      insertText: (text) => use((k) => k.insertText(text)),
+      press: (key, options) => use((k) => k.press(key, options)),
+      type: (text, options) => use((k) => k.type(text, options)),
+      up: (key) => use((k) => k.up(key)),
+    });
+  }
+}
diff --git a/src/page.test.ts b/src/page.test.ts
index d46f079..7e56086 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -325,4 +325,23 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(magicValue, 42);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("keyboard should allow typing text", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.evaluate(() => {
+        document.body.innerHTML = '<input id="input" />';
+        document.getElementById("input")?.focus();
+      });
+
+      yield* page.keyboard.type("Hello Effect");
+
+      const value = yield* page.evaluate(
+        () => (document.getElementById("input") as HTMLInputElement).value,
+      );
+      assert.strictEqual(value, "Hello Effect");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index e9a31cd..a8a1748 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -22,6 +22,7 @@ import {
 } from "./common";
 import type { PlaywrightError } from "./errors";
 import { PlaywrightFrame } from "./frame";
+import { PlaywrightKeyboard, type PlaywrightKeyboardService } from "./keyboard";
 import { PlaywrightLocator } from "./locator";
 import type { PageFunction, PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
@@ -82,6 +83,10 @@ export interface PlaywrightPageService {
    * Access the clock.
    */
   readonly clock: PlaywrightClockService;
+  /**
+   * Access the keyboard.
+   */
+  readonly keyboard: PlaywrightKeyboardService;
   /**
    * Navigates the page to the given URL.
    *
@@ -328,6 +333,7 @@ export class PlaywrightPage extends Context.Tag(
 
     return PlaywrightPage.of({
       clock: PlaywrightClock.make(page.clock),
+      keyboard: PlaywrightKeyboard.make(page.keyboard),
       goto: (url, options) => use((p) => p.goto(url, options)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>

From 222cfe42017bc2af0cffd9b66cda8033fc2339e1 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 22:54:02 +0100
Subject: [PATCH 04/33] improve implement skill

---
 .../implement-playwright-method/SKILL.md      | 41 ++++++++++++++++---
 1 file changed, 36 insertions(+), 5 deletions(-)

diff --git a/.agents/skills/implement-playwright-method/SKILL.md b/.agents/skills/implement-playwright-method/SKILL.md
index 9026aa9..8bd0e16 100644
--- a/.agents/skills/implement-playwright-method/SKILL.md
+++ b/.agents/skills/implement-playwright-method/SKILL.md
@@ -22,7 +22,7 @@ First, find the implementation of the method in the Playwright codebase to under
 
 ### 2. Analyze the Method
 
-Determine if the method can throw and what it returns. **Do not blindly follow existing patterns in `effect-playwright` if they wrap safe synchronous methods in Effects.**
+Determine if the method can throw and what it returns. **Do not blindly follow existing patterns in `effect-playwright`. Always analyze the original Playwright source code to determine behavior.**
 
 #### Can it throw?
 
@@ -43,7 +43,38 @@ Determine if the method can throw and what it returns. **Do not blindly follow e
 - **`T | null`** -> `Option<T>` (if sync) or `Effect<Option<T>, PlaywrightError>` (if async)
 - **Playwright Object (e.g., `Page`)** -> **Wrapped Object (e.g., `PlaywrightPage`)**
 
-### 3. Define the Interface
+### 3. Handle Sub-APIs / Nested Properties
+
+Some Playwright interfaces expose other classes as properties (e.g., `Page.keyboard`, `Page.mouse`, `BrowserContext.tracing`).
+
+1. **Create a new Wrapper**: Create a new file, Service, and Tag for the sub-API (e.g., `PlaywrightKeyboardService` wrapping `Keyboard`).
+2. **Expose as a Sync Property**: Expose it as a direct, read-only property on the parent service. Do not wrap property access in an `Effect`.
+
+**Example (Interface in Parent):**
+
+```typescript
+export interface PlaywrightPageService {
+  /**
+   * Access the keyboard.
+   * @see {@link Page.keyboard}
+   */
+  readonly keyboard: PlaywrightKeyboardService;
+}
+```
+
+**Example (Implementation in Parent's `make`):**
+
+```typescript
+static make(page: Page): PlaywrightPageService {
+  return PlaywrightPage.of({
+    // Initialize the sub-API wrapper synchronously
+    keyboard: PlaywrightKeyboard.make(page.keyboard),
+    // ...
+  });
+}
+```
+
+### 4. Define the Interface
 
 Add the method to the Service interface in the corresponding `src/X.ts` file (e.g., `PlaywrightPageService` in `src/page.ts`).
 
@@ -93,7 +124,7 @@ readonly url: () => string;
 readonly textContent: Effect.Effect<Option.Option<string>, PlaywrightError>;
 ```
 
-### 4. Implement the Method
+### 5. Implement the Method
 
 Implement the method in the `make` function of the implementation class (e.g., `PlaywrightPage.make`).
 
@@ -135,7 +166,7 @@ Implement the method in the `make` function of the implementation class (e.g., `
   ),
   ```
 
-### 5. Verify
+### 6. Verify
 
 - Ensure types match `PlaywrightXService`.
-- Run `npm run typecheck` (or equivalent) to verify implementation.
+- Run `pnpm run type-check` and `pnpm test` to verify implementation.

From 547cc50db1cbe62f73bde5ced0464dd9c6ed997d Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 23:07:04 +0100
Subject: [PATCH 05/33] lint fixes

---
 src/common.test.ts              | 18 ++++++------------
 src/experimental/environment.ts |  3 ++-
 src/page.test.ts                |  3 +--
 3 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/src/common.test.ts b/src/common.test.ts
index a01b0aa..05d02bb 100644
--- a/src/common.test.ts
+++ b/src/common.test.ts
@@ -12,13 +12,11 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightCommon", (it) => {
 
       const requestFiber = yield* page
         .eventStream("request")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       const responseFiber = yield* page
         .eventStream("response")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.goto("http://example.com");
 
@@ -52,8 +50,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightCommon", (it) => {
 
       const workerFiber = yield* page
         .eventStream("worker")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.evaluate(() => {
         const blob = new Blob(['console.log("worker")'], {
@@ -77,8 +74,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightCommon", (it) => {
 
       const dialogFiber = yield* page
         .eventStream("dialog")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.evaluate(() => {
         setTimeout(() => alert("hello world"), 10);
@@ -104,8 +100,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightCommon", (it) => {
 
       const fileChooserFiber = yield* page
         .eventStream("filechooser")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.locator("#fileinput").click();
 
@@ -130,8 +125,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightCommon", (it) => {
 
       const downloadFiber = yield* page
         .eventStream("download")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.locator("#download").click();
 
diff --git a/src/experimental/environment.ts b/src/experimental/environment.ts
index 7443df4..ad6827c 100644
--- a/src/experimental/environment.ts
+++ b/src/experimental/environment.ts
@@ -63,7 +63,8 @@ export const layer = (browser: BrowserType, launchOptions?: LaunchOptions) => {
           browser: playwright.launchScoped(browser, launchOptions),
         });
       }),
-    ).pipe(Effect.provide(Playwright.layer)),
+      Effect.provide(Playwright.layer),
+    ),
   );
 };
 
diff --git a/src/page.test.ts b/src/page.test.ts
index 7e56086..9f78477 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -205,8 +205,7 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
 
       const fileChooser = yield* page
         .eventStream("filechooser")
-        .pipe(Stream.runHead)
-        .pipe(Effect.fork);
+        .pipe(Stream.runHead, Effect.fork);
 
       yield* page.locator("#fileinput").click();
 

From e8b8f76d4af414a970c8c8477bbab389d1f37435 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Fri, 20 Feb 2026 23:24:13 +0100
Subject: [PATCH 06/33] implement Page.screenshot

---
 src/page.test.ts | 12 ++++++++++++
 src/page.ts      | 16 ++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 9f78477..d1fd751 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -343,4 +343,16 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(value, "Hello Effect");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+  it.scoped("screenshot should capture an image", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("data:text/html,<h1>Screenshot Test</h1>");
+      const buffer = yield* page.screenshot({ type: "png" });
+
+      assert(Buffer.isBuffer(buffer));
+      assert(buffer.length > 0);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index a8a1748..31cde0d 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -243,6 +243,21 @@ export interface PlaywrightPageService {
     testId: Parameters<Page["getByTestId"]>[0],
   ) => typeof PlaywrightLocator.Service;
 
+  /**
+   * Captures a screenshot of the page.
+   *
+   * @example
+   * ```ts
+   * const buffer = yield* page.screenshot({ path: "screenshot.png" });
+   * ```
+   *
+   * @see {@link Page.screenshot}
+   * @since 0.2.0
+   */
+  readonly screenshot: (
+    options?: Parameters<Page["screenshot"]>[0],
+  ) => Effect.Effect<Buffer, PlaywrightError>;
+
   /**
    * Reloads the page.
    *
@@ -355,6 +370,7 @@ export class PlaywrightPage extends Context.Tag(
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),
       close: use((p) => p.close()),
+      screenshot: (options) => use((p) => p.screenshot(options)),
       click: (selector, options) => use((p) => p.click(selector, options)),
       eventStream: <K extends keyof PageEvents>(event: K) =>
         Stream.asyncPush<PageEvents[K]>((emit) =>

From 8990a5796c1dd8c6d64f173e4481be883365b472 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:26:21 +0100
Subject: [PATCH 07/33] implement Page.addScriptTag

---
 src/page.test.ts | 16 ++++++++++++++++
 src/page.ts      | 11 +++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index d1fd751..956a58e 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -355,4 +355,20 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert(buffer.length > 0);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("addScriptTag should add a script tag to the page", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      yield* page.addScriptTag({ content: "window.magicValue = 42;" });
+
+      const magicValue = yield* page.evaluate(
+        () => (window as TestWindow).magicValue,
+      );
+      assert.strictEqual(magicValue, 42);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 31cde0d..8c81856 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -3,6 +3,7 @@ import type {
   ConsoleMessage,
   Dialog,
   Download,
+  ElementHandle,
   FileChooser,
   Frame,
   Page,
@@ -164,6 +165,15 @@ export interface PlaywrightPageService {
     script: Parameters<Page["addInitScript"]>[0],
     arg?: Parameters<Page["addInitScript"]>[1],
   ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Adds a `<script>` tag into the page with the desired url or content.
+   *
+   * @see {@link Page.addScriptTag}
+   * @since 0.2.0
+   */
+  readonly addScriptTag: (
+    options: Parameters<Page["addScriptTag"]>[0],
+  ) => Effect.Effect<ElementHandle, PlaywrightError>;
   /**
    * Returns the page title.
    *
@@ -357,6 +367,7 @@ export class PlaywrightPage extends Context.Tag(
       evaluate: <R, Arg>(f: PageFunction<Arg, R>, arg?: Arg) =>
         use((p) => p.evaluate<R, Arg>(f, arg as Arg)),
       addInitScript: (script, arg) => use((p) => p.addInitScript(script, arg)),
+      addScriptTag: (options) => use((p) => p.addScriptTag(options)),
       locator: (selector, options) =>
         PlaywrightLocator.make(page.locator(selector, options)),
       getByRole: (role, options) =>

From e1c813db3ae616d72cc5ce4f95ffc6cdfb4a0f7f Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:30:32 +0100
Subject: [PATCH 08/33] implement Page.addStyleTag

---
 src/page.test.ts | 23 +++++++++++++++++++++++
 src/page.ts      | 10 ++++++++++
 2 files changed, 33 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 956a58e..cd30598 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -371,4 +371,27 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(magicValue, 42);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("addStyleTag should add a style tag to the page", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      yield* page.evaluate(() => {
+        document.body.innerHTML = '<div id="test-div">Hello</div>';
+      });
+
+      yield* page.addStyleTag({
+        content: "#test-div { color: rgb(255, 0, 0); }",
+      });
+
+      const color = yield* page.evaluate(() => {
+        const el = document.getElementById("test-div");
+        return el ? window.getComputedStyle(el).color : null;
+      });
+      assert.strictEqual(color, "rgb(255, 0, 0)");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 8c81856..7f30d15 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -174,6 +174,15 @@ export interface PlaywrightPageService {
   readonly addScriptTag: (
     options: Parameters<Page["addScriptTag"]>[0],
   ) => Effect.Effect<ElementHandle, PlaywrightError>;
+  /**
+   * Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content.
+   *
+   * @see {@link Page.addStyleTag}
+   * @since 0.2.0
+   */
+  readonly addStyleTag: (
+    options: Parameters<Page["addStyleTag"]>[0],
+  ) => Effect.Effect<ElementHandle, PlaywrightError>;
   /**
    * Returns the page title.
    *
@@ -368,6 +377,7 @@ export class PlaywrightPage extends Context.Tag(
         use((p) => p.evaluate<R, Arg>(f, arg as Arg)),
       addInitScript: (script, arg) => use((p) => p.addInitScript(script, arg)),
       addScriptTag: (options) => use((p) => p.addScriptTag(options)),
+      addStyleTag: (options) => use((p) => p.addStyleTag(options)),
       locator: (selector, options) =>
         PlaywrightLocator.make(page.locator(selector, options)),
       getByRole: (role, options) =>

From dda6c66713f6a845927b47e7115e773207c3c60f Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:34:03 +0100
Subject: [PATCH 09/33] implement Page.bringToFront

---
 src/page.test.ts | 14 ++++++++++++++
 src/page.ts      |  8 ++++++++
 2 files changed, 22 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index cd30598..4318626 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -394,4 +394,18 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(color, "rgb(255, 0, 0)");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+  it.scoped("bringToFront should bring the page to the front", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const context = yield* browser.newContext();
+      const page1 = yield* context.newPage;
+      const page2 = yield* context.newPage;
+
+      yield* page1.bringToFront;
+      yield* page2.bringToFront;
+
+      // Ensure no errors are thrown
+      assert.ok(true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 7f30d15..800f63a 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -284,6 +284,13 @@ export interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly reload: Effect.Effect<void, PlaywrightError>;
+  /**
+   * Brings page to front (activates tab).
+   *
+   * @see {@link Page.bringToFront}
+   * @since 0.3.0
+   */
+  readonly bringToFront: Effect.Effect<void, PlaywrightError>;
   /**
    * Closes the page.
    *
@@ -390,6 +397,7 @@ export class PlaywrightPage extends Context.Tag(
       url: () => page.url(),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),
+      bringToFront: use((p) => p.bringToFront()),
       close: use((p) => p.close()),
       screenshot: (options) => use((p) => p.screenshot(options)),
       click: (selector, options) => use((p) => p.click(selector, options)),

From d9d88afd9d2a670442ff8aa1635ff1968b7b5286 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:37:46 +0100
Subject: [PATCH 10/33] fix @since docstrings

---
 src/page.ts | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/page.ts b/src/page.ts
index 800f63a..e8bb806 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -82,10 +82,14 @@ type PageWithPatchedEvents = PatchedEvents<Page, PageEvents>;
 export interface PlaywrightPageService {
   /**
    * Access the clock.
+   *
+   * @since 0.3.0
    */
   readonly clock: PlaywrightClockService;
   /**
    * Access the keyboard.
+   *
+   * @since 0.3.0
    */
   readonly keyboard: PlaywrightKeyboardService;
   /**
@@ -159,7 +163,7 @@ export interface PlaywrightPageService {
    * - Whenever the child frame is attached or navigated. In this case, the script is evaluated in the context of the newly attached frame.
    *
    * @see {@link Page.addInitScript}
-   * @since 0.2.0
+   * @since 0.3.0
    */
   readonly addInitScript: (
     script: Parameters<Page["addInitScript"]>[0],
@@ -169,7 +173,7 @@ export interface PlaywrightPageService {
    * Adds a `<script>` tag into the page with the desired url or content.
    *
    * @see {@link Page.addScriptTag}
-   * @since 0.2.0
+   * @since 0.3.0
    */
   readonly addScriptTag: (
     options: Parameters<Page["addScriptTag"]>[0],
@@ -178,7 +182,7 @@ export interface PlaywrightPageService {
    * Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content.
    *
    * @see {@link Page.addStyleTag}
-   * @since 0.2.0
+   * @since 0.3.0
    */
   readonly addStyleTag: (
     options: Parameters<Page["addStyleTag"]>[0],
@@ -271,7 +275,7 @@ export interface PlaywrightPageService {
    * ```
    *
    * @see {@link Page.screenshot}
-   * @since 0.2.0
+   * @since 0.3.0
    */
   readonly screenshot: (
     options?: Parameters<Page["screenshot"]>[0],

From 74644bf9f697b731b8b37d3907d9c4e387361b83 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:42:11 +0100
Subject: [PATCH 11/33] implement Page.consoleMessages

---
 src/page.test.ts | 20 ++++++++++++++++++++
 src/page.ts      | 17 +++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 4318626..cbe1b78 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -408,4 +408,24 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.ok(true);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("consoleMessages should return console messages", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      yield* page.evaluate(() => {
+        console.log("Hello from page");
+        console.warn("Warning from page");
+      });
+
+      const messages = yield* page.consoleMessages;
+
+      assert.strictEqual(messages.length, 2);
+      assert.strictEqual(messages[0].text(), "Hello from page");
+      assert.strictEqual(messages[1].text(), "Warning from page");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index e8bb806..1c7c526 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -316,6 +316,22 @@ export interface PlaywrightPageService {
    */
   readonly url: () => string;
 
+  /**
+   * Returns all messages that have been logged to the console.
+   *
+   * @example
+   * ```ts
+   * const consoleMessages = yield* page.consoleMessages;
+   * ```
+   *
+   * @see {@link Page.consoleMessages}
+   * @since 0.3.0
+   */
+  readonly consoleMessages: Effect.Effect<
+    ReadonlyArray<ConsoleMessage>,
+    PlaywrightError
+  >;
+
   /**
    * Returns all frames attached to the page.
    *
@@ -399,6 +415,7 @@ export class PlaywrightPage extends Context.Tag(
         PlaywrightLocator.make(page.getByLabel(label, options)),
       getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
       url: () => page.url(),
+      consoleMessages: use((p) => p.consoleMessages()),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),
       bringToFront: use((p) => p.bringToFront()),

From 3ee03bd7010dc13584dad9e26a9957b63f087913 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:46:01 +0100
Subject: [PATCH 12/33] implement Page.content

---
 src/page.test.ts | 13 +++++++++++++
 src/page.ts      | 13 +++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index cbe1b78..38c8475 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -36,6 +36,19 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("content should return the page content", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto(
+        "data:text/html,<html><head><title>Content</title></head><body><h1>Hello</h1></body></html>",
+      );
+      const content = yield* page.content;
+      assert(content.includes("<h1>Hello</h1>"));
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("click should click an element", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 1c7c526..13edfff 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -199,6 +199,18 @@ export interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly title: Effect.Effect<string, PlaywrightError>;
+  /**
+   * Returns the full HTML contents of the page, including the doctype.
+   *
+   * @example
+   * ```ts
+   * const html = yield* page.content;
+   * ```
+   *
+   * @see {@link Page.content}
+   * @since 0.3.0
+   */
+  readonly content: Effect.Effect<string, PlaywrightError>;
   /**
    * A generic utility to execute any promise-based method on the underlying Playwright `Page`.
    * Can be used to access any Page functionality not directly exposed by this service.
@@ -400,6 +412,7 @@ export class PlaywrightPage extends Context.Tag(
       waitForLoadState: (state, options) =>
         use((p) => p.waitForLoadState(state, options)),
       title: use((p) => p.title()),
+      content: use((p) => p.content()),
       evaluate: <R, Arg>(f: PageFunction<Arg, R>, arg?: Arg) =>
         use((p) => p.evaluate<R, Arg>(f, arg as Arg)),
       addInitScript: (script, arg) => use((p) => p.addInitScript(script, arg)),

From 687314c248c6267859b777c12cd918dddcc782ac Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:51:37 +0100
Subject: [PATCH 13/33] implement Page.context

---
 src/page.test.ts | 15 +++++++++++++++
 src/page.ts      | 13 +++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 38c8475..17a3053 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -441,4 +441,19 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(messages[1].text(), "Warning from page");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("context should return the associated browser context", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const context = yield* browser.newContext();
+      const page = yield* context.newPage;
+
+      const pageContext = page.context();
+
+      // we can't do direct reference equality because they are wrapper objects,
+      // but we can check if it has the right methods and doesn't crash
+      const pages = yield* pageContext.pages;
+      assert.strictEqual(pages.length, 1);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 13edfff..1f5d880 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -12,6 +12,10 @@ import type {
   WebSocket,
   Worker,
 } from "playwright-core";
+import {
+  PlaywrightBrowserContext,
+  type PlaywrightBrowserContextService,
+} from "./browser-context";
 import { PlaywrightClock, type PlaywrightClockService } from "./clock";
 import {
   PlaywrightDialog,
@@ -344,6 +348,14 @@ export interface PlaywrightPageService {
     PlaywrightError
   >;
 
+  /**
+   * Get the browser context that the page belongs to.
+   *
+   * @see {@link Page.context}
+   * @since 0.3.0
+   */
+  readonly context: () => PlaywrightBrowserContextService;
+
   /**
    * Returns all frames attached to the page.
    *
@@ -428,6 +440,7 @@ export class PlaywrightPage extends Context.Tag(
         PlaywrightLocator.make(page.getByLabel(label, options)),
       getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
       url: () => page.url(),
+      context: () => PlaywrightBrowserContext.make(page.context()),
       consoleMessages: use((p) => p.consoleMessages()),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),

From 37236fbbcc1db264e231d71902a660e47f75b062 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:55:19 +0100
Subject: [PATCH 14/33] implement Page.dragAndDrop

---
 src/page.test.ts | 32 +++++++++++++++++++++++++++++
 src/page.ts      | 53 ++++++++++++++++++++++++++++++++----------------
 2 files changed, 68 insertions(+), 17 deletions(-)

diff --git a/src/page.test.ts b/src/page.test.ts
index 17a3053..57f30ff 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -456,4 +456,36 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(pages.length, 1);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("dragAndDrop should drag and drop an element", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.evaluate(() => {
+        document.body.innerHTML = `
+          <div id="source" style="width: 50px; height: 50px; background: red;" draggable="true"></div>
+          <div id="target" style="width: 100px; height: 100px; background: blue; position: absolute; top: 200px; left: 200px;"></div>
+        `;
+
+        const target = document.getElementById("target");
+        if (target) {
+          target.addEventListener("drop", (e) => {
+            e.preventDefault();
+            (window as TestWindow).magicValue = 42;
+          });
+          target.addEventListener("dragover", (e) => {
+            e.preventDefault();
+          });
+        }
+      });
+
+      yield* page.dragAndDrop("#source", "#target");
+
+      const magicValue = yield* page.evaluate(
+        () => (window as TestWindow).magicValue,
+      );
+      assert.strictEqual(magicValue, 42);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 1f5d880..5d41d7f 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -297,6 +297,40 @@ export interface PlaywrightPageService {
     options?: Parameters<Page["screenshot"]>[0],
   ) => Effect.Effect<Buffer, PlaywrightError>;
 
+  /**
+   * Clicks an element matching the given selector.
+   *
+   * @example
+   * ```ts
+   * yield* page.click("button#submit");
+   * ```
+   * @deprecated Use {@link PlaywrightPageService.locator} to create a locator and then call `click` on it instead.
+   * @see {@link Page.click}
+   * @since 0.1.0
+   * @category deprecated
+   */
+  readonly click: (
+    selector: string,
+    options?: Parameters<Page["click"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
+
+  /**
+   * Drags a source element to a target element and drops it.
+   *
+   * @example
+   * ```ts
+   * yield* page.dragAndDrop("#source", "#target");
+   * ```
+   *
+   * @see {@link Page.dragAndDrop}
+   * @since 0.3.0
+   */
+  readonly dragAndDrop: (
+    source: Parameters<Page["dragAndDrop"]>[0],
+    target: Parameters<Page["dragAndDrop"]>[1],
+    options?: Parameters<Page["dragAndDrop"]>[2],
+  ) => Effect.Effect<void, PlaywrightError>;
+
   /**
    * Reloads the page.
    *
@@ -382,23 +416,6 @@ export interface PlaywrightPageService {
   readonly eventStream: <K extends keyof PageEvents>(
     event: K,
   ) => Stream.Stream<ReturnType<(typeof eventMappings)[K]>>;
-
-  /**
-   * Clicks an element matching the given selector.
-   *
-   * @example
-   * ```ts
-   * yield* page.click("button#submit");
-   * ```
-   * @deprecated Use {@link PlaywrightPageService.locator} to create a locator and then call `click` on it instead.
-   * @see {@link Page.click}
-   * @since 0.1.0
-   * @category deprecated
-   */
-  readonly click: (
-    selector: string,
-    options?: Parameters<Page["click"]>[1],
-  ) => Effect.Effect<void, PlaywrightError>;
 }
 
 /**
@@ -447,6 +464,8 @@ export class PlaywrightPage extends Context.Tag(
       bringToFront: use((p) => p.bringToFront()),
       close: use((p) => p.close()),
       screenshot: (options) => use((p) => p.screenshot(options)),
+      dragAndDrop: (source, target, options) =>
+        use((p) => p.dragAndDrop(source, target, options)),
       click: (selector, options) => use((p) => p.click(selector, options)),
       eventStream: <K extends keyof PageEvents>(event: K) =>
         Stream.asyncPush<PageEvents[K]>((emit) =>

From 97cb5231c2cfc06c9eac58d55d0f71a87d6678be Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 10:59:28 +0100
Subject: [PATCH 15/33] implement Page.emulateMedia

---
 src/page.test.ts | 25 +++++++++++++++++++++++++
 src/page.ts      | 18 ++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 57f30ff..8037367 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -488,4 +488,29 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(magicValue, 42);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("emulateMedia should emulate media features", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      // emulate dark mode
+      yield* page.emulateMedia({ colorScheme: "dark" });
+
+      let isDark = yield* page.evaluate(
+        () => window.matchMedia("(prefers-color-scheme: dark)").matches,
+      );
+      assert.strictEqual(isDark, true);
+
+      // emulate light mode
+      yield* page.emulateMedia({ colorScheme: "light" });
+
+      isDark = yield* page.evaluate(
+        () => window.matchMedia("(prefers-color-scheme: dark)").matches,
+      );
+      assert.strictEqual(isDark, false);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 5d41d7f..d0d94f9 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -331,6 +331,23 @@ export interface PlaywrightPageService {
     options?: Parameters<Page["dragAndDrop"]>[2],
   ) => Effect.Effect<void, PlaywrightError>;
 
+  /**
+   * This method changes the CSS media type through the media argument,
+   * and/or the 'prefers-colors-scheme' media feature, using the colorScheme argument.
+   *
+   * @example
+   * ```ts
+   * yield* page.emulateMedia({ colorScheme: "dark" });
+   * yield* page.emulateMedia({ media: "print" });
+   * ```
+   *
+   * @see {@link Page.emulateMedia}
+   * @since 0.3.0
+   */
+  readonly emulateMedia: (
+    options?: Parameters<Page["emulateMedia"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+
   /**
    * Reloads the page.
    *
@@ -467,6 +484,7 @@ export class PlaywrightPage extends Context.Tag(
       dragAndDrop: (source, target, options) =>
         use((p) => p.dragAndDrop(source, target, options)),
       click: (selector, options) => use((p) => p.click(selector, options)),
+      emulateMedia: (options) => use((p) => p.emulateMedia(options)),
       eventStream: <K extends keyof PageEvents>(event: K) =>
         Stream.asyncPush<PageEvents[K]>((emit) =>
           Effect.acquireRelease(

From c20007006d93dad12175cc877d32831d5518e033 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 11:03:21 +0100
Subject: [PATCH 16/33] implement Page.exposeFunction

---
 src/page.test.ts |  72 +++++++++++++++++++++++++-
 src/page.ts      | 131 ++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 201 insertions(+), 2 deletions(-)

diff --git a/src/page.test.ts b/src/page.test.ts
index 8037367..6b551ea 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -1,5 +1,5 @@
 import { assert, layer } from "@effect/vitest";
-import { Effect, Fiber, Stream } from "effect";
+import { Effect, Fiber, Ref, Stream } from "effect";
 import { chromium } from "playwright-core";
 import { PlaywrightBrowser } from "./browser";
 import { PlaywrightEnvironment } from "./experimental";
@@ -513,4 +513,74 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(isDark, false);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped(
+    "exposeFunction should expose an function that runs an effect",
+    () =>
+      Effect.gen(function* () {
+        const browser = yield* PlaywrightBrowser;
+        const page = yield* browser.newPage();
+
+        const ref = yield* Ref.make(0);
+
+        yield* page.exposeFunction("myCustomEffect", () =>
+          Ref.updateAndGet(ref, (n) => n + 1),
+        );
+
+        const result = yield* page.evaluate(async () => {
+          // @ts-expect-error
+          return await window.myCustomEffect();
+        });
+
+        assert.strictEqual(yield* Ref.get(ref), 1, "Ref value is 1");
+        assert.strictEqual(result, 1, "Return value is 1");
+      }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("exposeFunction should work with Effect.fn", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      const ref = yield* Ref.make(0);
+
+      // Effect.fn usage
+      yield* page.exposeFunction(
+        "myCustomEffectFn",
+        Effect.fn(function* (num: number) {
+          return yield* Ref.updateAndGet(ref, (n) => n + num);
+        }),
+      );
+
+      const result = yield* page.evaluate(async () => {
+        // @ts-expect-error
+        return await window.myCustomEffectFn(15);
+      });
+
+      assert.strictEqual(yield* Ref.get(ref), 15, "Ref value is 15");
+      assert.strictEqual(result, 15, "Return value is 15");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("exposeEffect should expose an effect", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      const ref = yield* Ref.make(0);
+
+      yield* page.exposeEffect(
+        "myCustomEffect",
+        Ref.updateAndGet(ref, (n) => n + 1),
+      );
+
+      const result = yield* page.evaluate(async () => {
+        // @ts-expect-error
+        return await window.myCustomEffect();
+      });
+
+      assert.strictEqual(yield* Ref.get(ref), 1, "Ref value is 1");
+      assert.strictEqual(result, 1, "Return value is 1");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index d0d94f9..aed3d2c 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -1,4 +1,4 @@
-import { Context, Effect, identity, Stream } from "effect";
+import { Context, Effect, identity, Runtime, Stream } from "effect";
 import type {
   ConsoleMessage,
   Dialog,
@@ -182,6 +182,114 @@ export interface PlaywrightPageService {
   readonly addScriptTag: (
     options: Parameters<Page["addScriptTag"]>[0],
   ) => Effect.Effect<ElementHandle, PlaywrightError>;
+  /**
+   * Adds a function called `name` on the `window` object of every frame in this page.
+   *
+   * The provided function must return an `Effect` which will be executed using the
+   * current runtime when the function is called from the browser context.
+   *
+   * If you don't require your function to have args you can use {@link exposeEffect} instead.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect } from "effect";
+   * import { PlaywrightBrowser } from "effect-playwright/browser";
+   *
+   * const program = Effect.gen(function* () {
+   *   const browser = yield* PlaywrightBrowser;
+   *   const page = yield* browser.newPage();
+   *
+   *   // Expose an Effect-based function to the browser
+   *   yield* page.exposeFunction("logMessage", (message: string) =>
+   *     Console.log(`Message from browser: ${message}`),
+   *   );
+   *
+   *   yield* page.evaluate(() => {
+   *     // Call the exposed function from the browser context
+   *     // @ts-expect-error
+   *     return window.logMessage("Hello from the other side!");
+   *   });
+   * });
+   * ```
+   *
+   * @example
+   * ```ts
+   * import { Context, Effect } from "effect";
+   * import { PlaywrightBrowser } from "effect-playwright/browser";
+   *
+   * // A custom Database service used in your Effect application
+   * class Database extends Context.Tag("Database")<
+   *   Database,
+   *   { readonly insertProduct: (name: string, price: number) => Effect.Effect<void> }
+   * >() {}
+   *
+   * const program = Effect.gen(function* () {
+   *   const browser = yield* PlaywrightBrowser;
+   *   const page = yield* browser.newPage();
+   *
+   *   // Expose a function that seamlessly accesses Effect Context using Effect.fn
+   *   yield* page.exposeFunction(
+   *     "saveProduct",
+   *     Effect.fn(function* (name: string, price: number) {
+   *       const db = yield* Database;
+   *       yield* db.insertProduct(name, price);
+   *     }),
+   *   );
+   *
+   *   yield* page.evaluate(async () => {
+   *     // Extract data from the page and save it
+   *     const items = document.querySelectorAll(".product");
+   *     for (const item of items) {
+   *       const name = item.querySelector(".name")?.textContent || "Unknown";
+   *       const price = Number(item.querySelector(".price")?.textContent || 0);
+   *
+   *       // Call the Effect function directly from the browser
+   *       // @ts-expect-error
+   *       await window.saveProduct(name, price);
+   *     }
+   *   });
+   * });
+   * ```
+   *
+   *
+   * @see {@link Page.exposeFunction}
+   * @since 0.3.0
+   */
+  readonly exposeFunction: <A, E, R, Args extends unknown[]>(
+    name: Parameters<Page["exposeFunction"]>[0],
+    playwrightFunction: (...args: Args) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<void, PlaywrightError, R>;
+
+  /**
+   * Identical to {@link exposeFunction} but meant to be used with a static `Effect`.
+   * This is useful when the exposed function does not need any arguments and just
+   * runs a pre-defined effect in the application context.
+   *
+   * @example
+   * ```ts
+   * import { Console, Effect } from "effect";
+   * import { PlaywrightBrowser } from "effect-playwright/browser";
+   *
+   * const program = Effect.gen(function* () {
+   *   const browser = yield* PlaywrightBrowser;
+   *   const page = yield* browser.newPage();
+   *
+   *   yield* page.exposeEffect("ping", Console.log("pong"));
+   *
+   *   yield* page.evaluate(async () => {
+   *     // @ts-expect-error
+   *     await window.ping();
+   *   });
+   * });
+   * ```
+   *
+   * @see {@link Page.exposeFunction}
+   * @since 0.3.0
+   */
+  readonly exposeEffect: <A, E, R>(
+    name: Parameters<Page["exposeFunction"]>[0],
+    playwrightFunction: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<void, PlaywrightError, R>;
   /**
    * Adds a `<link rel="stylesheet">` tag into the page with the desired url or a `<style type="text/css">` tag with the content.
    *
@@ -464,6 +572,27 @@ export class PlaywrightPage extends Context.Tag(
       addInitScript: (script, arg) => use((p) => p.addInitScript(script, arg)),
       addScriptTag: (options) => use((p) => p.addScriptTag(options)),
       addStyleTag: (options) => use((p) => p.addStyleTag(options)),
+      exposeFunction: <A, E, R, Args extends unknown[]>(
+        name: string,
+        effectFn: (...args: Args) => Effect.Effect<A, E, R>,
+      ) =>
+        Effect.runtime<R>().pipe(
+          Effect.map((r) => Runtime.runPromise(r)),
+          Effect.flatMap((runPromise) =>
+            use((p) =>
+              p.exposeFunction(name, (...args: Args) =>
+                runPromise(effectFn(...args)),
+              ),
+            ),
+          ),
+        ),
+      exposeEffect: <A, E, R>(name: string, effectFn: Effect.Effect<A, E, R>) =>
+        Effect.runtime<R>().pipe(
+          Effect.map((r) => Runtime.runPromise(r)),
+          Effect.flatMap((runPromise) =>
+            use((p) => p.exposeFunction(name, () => runPromise(effectFn))),
+          ),
+        ),
       locator: (selector, options) =>
         PlaywrightLocator.make(page.locator(selector, options)),
       getByRole: (role, options) =>

From f6f69c0d61418d9a7a9d9447974b72ab3be1059c Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 13:22:22 +0100
Subject: [PATCH 17/33] implement Page.frame

---
 src/page.test.ts | 22 +++++++++++++++++++++-
 src/page.ts      | 21 ++++++++++++++++++++-
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/page.test.ts b/src/page.test.ts
index 6b551ea..58e15e9 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -1,5 +1,5 @@
 import { assert, layer } from "@effect/vitest";
-import { Effect, Fiber, Ref, Stream } from "effect";
+import { Effect, Fiber, Option, Ref, Stream } from "effect";
 import { chromium } from "playwright-core";
 import { PlaywrightBrowser } from "./browser";
 import { PlaywrightEnvironment } from "./experimental";
@@ -583,4 +583,24 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(result, 1, "Return value is 1");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("frame should return an Option of PlaywrightFrame", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.use((p) =>
+        p.setContent('<iframe name="test-frame" id="test-frame"></iframe>'),
+      );
+
+      const frameOpt = page.frame("test-frame");
+      assert(Option.isSome(frameOpt), "Frame should be Some");
+
+      const frameOptByName = page.frame({ name: "test-frame" });
+      assert(Option.isSome(frameOptByName), "Frame should be Some");
+
+      const nonExistentFrame = page.frame("foo");
+      assert(Option.isNone(nonExistentFrame), "Frame should be None");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index aed3d2c..9ed82bb 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -1,4 +1,4 @@
-import { Context, Effect, identity, Runtime, Stream } from "effect";
+import { Context, Effect, identity, Option, Runtime, Stream } from "effect";
 import type {
   ConsoleMessage,
   Dialog,
@@ -515,6 +515,21 @@ export interface PlaywrightPageService {
    */
   readonly context: () => PlaywrightBrowserContextService;
 
+  /**
+   * Returns a frame matching the specified criteria.
+   *
+   * @example
+   * ```ts
+   * const frame = Option.getOrNull(page.frame("frame-name"));
+   * ```
+   *
+   * @see {@link Page.frame}
+   * @since 0.3.0
+   */
+  readonly frame: (
+    frameSelector: Parameters<Page["frame"]>[0],
+  ) => Option.Option<typeof PlaywrightFrame.Service>;
+
   /**
    * Returns all frames attached to the page.
    *
@@ -605,6 +620,10 @@ export class PlaywrightPage extends Context.Tag(
       url: () => page.url(),
       context: () => PlaywrightBrowserContext.make(page.context()),
       consoleMessages: use((p) => p.consoleMessages()),
+      frame: (frameSelector) =>
+        Option.fromNullable(page.frame(frameSelector)).pipe(
+          Option.map(PlaywrightFrame.make),
+        ),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),
       bringToFront: use((p) => p.bringToFront()),

From f3aedcb661bd5879afd8b0f5e5a75d84e23ee41a Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 13:28:16 +0100
Subject: [PATCH 18/33] implement missing Page.getBy* methods

---
 src/page.test.ts | 16 ++++++++++++++++
 src/page.ts      | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 52 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 58e15e9..291c9b2 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -174,6 +174,9 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
           <label for="input">Label Text</label>
           <input id="input" />
           <div data-testid="test-id">Test Content</div>
+          <img alt="Alt Text" src="data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=" />
+          <input placeholder="Placeholder Text" />
+          <div title="Title Text">Hover Me</div>
         `;
       });
 
@@ -188,6 +191,19 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
 
       const byTestId = yield* page.getByTestId("test-id").textContent();
       assert(byTestId === "Test Content");
+
+      const byAltText = yield* page
+        .getByAltText("Alt Text")
+        .getAttribute("alt");
+      assert(byAltText === "Alt Text");
+
+      const byPlaceholder = yield* page
+        .getByPlaceholder("Placeholder Text")
+        .getAttribute("placeholder");
+      assert(byPlaceholder === "Placeholder Text");
+
+      const byTitle = yield* page.getByTitle("Title Text").textContent();
+      assert(byTitle === "Hover Me");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
diff --git a/src/page.ts b/src/page.ts
index 9ed82bb..99effa6 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -389,6 +389,36 @@ export interface PlaywrightPageService {
   readonly getByTestId: (
     testId: Parameters<Page["getByTestId"]>[0],
   ) => typeof PlaywrightLocator.Service;
+  /**
+   * Returns a locator that matches the given alt text.
+   *
+   * @see {@link Page.getByAltText}
+   * @since 0.3.0
+   */
+  readonly getByAltText: (
+    text: Parameters<Page["getByAltText"]>[0],
+    options?: Parameters<Page["getByAltText"]>[1],
+  ) => typeof PlaywrightLocator.Service;
+  /**
+   * Returns a locator that matches the given placeholder.
+   *
+   * @see {@link Page.getByPlaceholder}
+   * @since 0.3.0
+   */
+  readonly getByPlaceholder: (
+    text: Parameters<Page["getByPlaceholder"]>[0],
+    options?: Parameters<Page["getByPlaceholder"]>[1],
+  ) => typeof PlaywrightLocator.Service;
+  /**
+   * Returns a locator that matches the given title.
+   *
+   * @see {@link Page.getByTitle}
+   * @since 0.3.0
+   */
+  readonly getByTitle: (
+    text: Parameters<Page["getByTitle"]>[0],
+    options?: Parameters<Page["getByTitle"]>[1],
+  ) => typeof PlaywrightLocator.Service;
 
   /**
    * Captures a screenshot of the page.
@@ -617,6 +647,12 @@ export class PlaywrightPage extends Context.Tag(
       getByLabel: (label, options) =>
         PlaywrightLocator.make(page.getByLabel(label, options)),
       getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
+      getByAltText: (text, options) =>
+        PlaywrightLocator.make(page.getByAltText(text, options)),
+      getByPlaceholder: (text, options) =>
+        PlaywrightLocator.make(page.getByPlaceholder(text, options)),
+      getByTitle: (text, options) =>
+        PlaywrightLocator.make(page.getByTitle(text, options)),
       url: () => page.url(),
       context: () => PlaywrightBrowserContext.make(page.context()),
       consoleMessages: use((p) => p.consoleMessages()),

From 6a66cb6910d0fbf9705cac721ddc9abfbf6fa381 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 13:36:40 +0100
Subject: [PATCH 19/33] coverage: categorize soft deprecated

---
 scripts/coverage.ts | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/scripts/coverage.ts b/scripts/coverage.ts
index 13bbce1..c4aa577 100644
--- a/scripts/coverage.ts
+++ b/scripts/coverage.ts
@@ -62,11 +62,16 @@ function isRelevantProperty(name: string) {
 }
 
 function isDeprecated(node: JSDocableNode): boolean {
-  return node
-    .getJsDocs()
-    .some((doc) =>
-      doc.getTags().some((tag) => tag.getTagName() === "deprecated"),
-    );
+  return node.getJsDocs().some((doc) => {
+    const hasDeprecatedTag = doc
+      .getTags()
+      .some((tag) => tag.getTagName() === "deprecated");
+    const docText = doc.getText();
+
+    // some methods are "soft-deprecated", i.e. they are still available but discouraged
+    const hasLocatorNote = docText.includes("**NOTE** Use locator-based");
+    return hasDeprecatedTag || hasLocatorNote;
+  });
 }
 
 const runCoverage = Effect.gen(function* () {

From 91c49cc8a6bd865a1ce99b7ba025422df06c59dd Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 13:42:15 +0100
Subject: [PATCH 20/33] implement Page.goBack and Page.goForward

---
 src/page.test.ts | 20 ++++++++++++++++++++
 src/page.ts      | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 291c9b2..6924591 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -275,6 +275,26 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("goBack and goForward should navigate through history", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      const url1 = "data:text/html,<h1>Page 1</h1>";
+      yield* page.goto(url1);
+
+      const url2 = "data:text/html,<h1>Page 2</h1>";
+      yield* page.goto(url2);
+      assert.strictEqual(page.url(), url2, "URL should be updated to url2");
+
+      yield* page.goBack();
+      assert.strictEqual(page.url(), url1, "URL should be updated to url1");
+
+      yield* page.goForward();
+      assert.strictEqual(page.url(), url2, "URL should be updated to url2");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("clock should allow fast forwarding time", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 99effa6..a678983 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -493,6 +493,34 @@ export interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly reload: Effect.Effect<void, PlaywrightError>;
+  /**
+   * Navigate to the previous page in history.
+   *
+   * @example
+   * ```ts
+   * const response = yield* page.goBack();
+   * ```
+   *
+   * @see {@link Page.goBack}
+   * @since 0.3.0
+   */
+  readonly goBack: (
+    options?: Parameters<Page["goBack"]>[0],
+  ) => Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
+  /**
+   * Navigate to the next page in history.
+   *
+   * @example
+   * ```ts
+   * const response = yield* page.goForward();
+   * ```
+   *
+   * @see {@link Page.goForward}
+   * @since 0.3.0
+   */
+  readonly goForward: (
+    options?: Parameters<Page["goForward"]>[0],
+  ) => Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
   /**
    * Brings page to front (activates tab).
    *
@@ -662,6 +690,16 @@ export class PlaywrightPage extends Context.Tag(
         ),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
       reload: use((p) => p.reload()),
+      goBack: (options) =>
+        use((p) => p.goBack(options)).pipe(
+          Effect.map(Option.fromNullable),
+          Effect.map(Option.map(PlaywrightResponse.make)),
+        ),
+      goForward: (options) =>
+        use((p) => p.goForward(options)).pipe(
+          Effect.map(Option.fromNullable),
+          Effect.map(Option.map(PlaywrightResponse.make)),
+        ),
       bringToFront: use((p) => p.bringToFront()),
       close: use((p) => p.close()),
       screenshot: (options) => use((p) => p.screenshot(options)),

From 3e9efacf3924d125e70ae45f32f957ca698464a2 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 14:06:45 +0100
Subject: [PATCH 21/33] implement Page.mouse

---
 src/index.ts     |  1 +
 src/mouse.ts     | 98 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/page.test.ts | 26 +++++++++++++
 src/page.ts      |  8 ++++
 4 files changed, 133 insertions(+)
 create mode 100644 src/mouse.ts

diff --git a/src/index.ts b/src/index.ts
index 457b8a1..2509fd7 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -26,5 +26,6 @@ export { PlaywrightError } from "./errors";
 export * from "./frame";
 export * from "./keyboard";
 export * from "./locator";
+export * from "./mouse";
 export * from "./page";
 export * from "./playwright";
diff --git a/src/mouse.ts b/src/mouse.ts
new file mode 100644
index 0000000..af9843d
--- /dev/null
+++ b/src/mouse.ts
@@ -0,0 +1,98 @@
+import { Context, type Effect } from "effect";
+import type { Mouse } from "playwright-core";
+import type { PlaywrightError } from "./errors";
+import { useHelper } from "./utils";
+
+/**
+ * @category model
+ * @since 0.3.0
+ */
+export interface PlaywrightMouseService {
+  /**
+   * Shortcut for mouse.move, mouse.down, mouse.up.
+   *
+   * @see {@link Mouse.click}
+   * @since 0.3.0
+   */
+  readonly click: (
+    x: Parameters<Mouse["click"]>[0],
+    y: Parameters<Mouse["click"]>[1],
+    options?: Parameters<Mouse["click"]>[2],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Shortcut for mouse.move, mouse.down, mouse.up, mouse.down and mouse.up.
+   *
+   * @see {@link Mouse.dblclick}
+   * @since 0.3.0
+   */
+  readonly dblclick: (
+    x: Parameters<Mouse["dblclick"]>[0],
+    y: Parameters<Mouse["dblclick"]>[1],
+    options?: Parameters<Mouse["dblclick"]>[2],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `mousedown` event.
+   *
+   * @see {@link Mouse.down}
+   * @since 0.3.0
+   */
+  readonly down: (
+    options?: Parameters<Mouse["down"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `mousemove` event.
+   *
+   * @see {@link Mouse.move}
+   * @since 0.3.0
+   */
+  readonly move: (
+    x: Parameters<Mouse["move"]>[0],
+    y: Parameters<Mouse["move"]>[1],
+    options?: Parameters<Mouse["move"]>[2],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `mouseup` event.
+   *
+   * @see {@link Mouse.up}
+   * @since 0.3.0
+   */
+  readonly up: (
+    options?: Parameters<Mouse["up"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Dispatches a `wheel` event.
+   *
+   * @see {@link Mouse.wheel}
+   * @since 0.3.0
+   */
+  readonly wheel: (
+    deltaX: Parameters<Mouse["wheel"]>[0],
+    deltaY: Parameters<Mouse["wheel"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
+}
+
+/**
+ * @category tag
+ */
+export class PlaywrightMouse extends Context.Tag(
+  "effect-playwright/PlaywrightMouse",
+)<PlaywrightMouse, PlaywrightMouseService>() {
+  /**
+   * Creates a `PlaywrightMouse` from a Playwright `Mouse` instance.
+   *
+   * @param mouse - The Playwright `Mouse` instance to wrap.
+   * @since 0.3.0
+   */
+  static make(mouse: Mouse): PlaywrightMouseService {
+    const use = useHelper(mouse);
+
+    return PlaywrightMouse.of({
+      click: (x, y, options) => use((m) => m.click(x, y, options)),
+      dblclick: (x, y, options) => use((m) => m.dblclick(x, y, options)),
+      down: (options) => use((m) => m.down(options)),
+      move: (x, y, options) => use((m) => m.move(x, y, options)),
+      up: (options) => use((m) => m.up(options)),
+      wheel: (deltaX, deltaY) => use((m) => m.wheel(deltaX, deltaY)),
+    });
+  }
+}
diff --git a/src/page.test.ts b/src/page.test.ts
index 6924591..28b4780 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -392,6 +392,32 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(value, "Hello Effect");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("mouse should allow dispatching events", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.evaluate(() => {
+        document.body.innerHTML =
+          '<div id="target" style="width: 100px; height: 100px; background: red;"></div>';
+        const target = document.getElementById("target");
+        if (target) {
+          target.addEventListener("click", () => {
+            (window as TestWindow).clicked = true;
+          });
+        }
+      });
+
+      yield* page.mouse.click(50, 50);
+
+      const clicked = yield* page.evaluate(
+        () => (window as TestWindow).clicked,
+      );
+      assert.strictEqual(clicked, true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("screenshot should capture an image", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index a678983..50a5dad 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -29,6 +29,7 @@ import type { PlaywrightError } from "./errors";
 import { PlaywrightFrame } from "./frame";
 import { PlaywrightKeyboard, type PlaywrightKeyboardService } from "./keyboard";
 import { PlaywrightLocator } from "./locator";
+import { PlaywrightMouse, type PlaywrightMouseService } from "./mouse";
 import type { PageFunction, PatchedEvents } from "./playwright-types";
 import { useHelper } from "./utils";
 
@@ -96,6 +97,12 @@ export interface PlaywrightPageService {
    * @since 0.3.0
    */
   readonly keyboard: PlaywrightKeyboardService;
+  /**
+   * Access the mouse.
+   *
+   * @since 0.3.0
+   */
+  readonly mouse: PlaywrightMouseService;
   /**
    * Navigates the page to the given URL.
    *
@@ -634,6 +641,7 @@ export class PlaywrightPage extends Context.Tag(
     return PlaywrightPage.of({
       clock: PlaywrightClock.make(page.clock),
       keyboard: PlaywrightKeyboard.make(page.keyboard),
+      mouse: PlaywrightMouse.make(page.mouse),
       goto: (url, options) => use((p) => p.goto(url, options)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>

From b10aa0241209f21f4b186122aec855e99e7bb55c Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 14:08:11 +0100
Subject: [PATCH 22/33] improve agent instructions a bit

---
 .agents/skills/implement-playwright-method/SKILL.md | 2 +-
 AGENTS.md                                           | 2 +-
 package.json                                        | 2 +-
 tsconfig.json                                       | 1 +
 4 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.agents/skills/implement-playwright-method/SKILL.md b/.agents/skills/implement-playwright-method/SKILL.md
index 8bd0e16..fa46782 100644
--- a/.agents/skills/implement-playwright-method/SKILL.md
+++ b/.agents/skills/implement-playwright-method/SKILL.md
@@ -169,4 +169,4 @@ Implement the method in the `make` function of the implementation class (e.g., `
 ### 6. Verify
 
 - Ensure types match `PlaywrightXService`.
-- Run `pnpm run type-check` and `pnpm test` to verify implementation.
+- Run `pnpm type-check` and `pnpm test` to verify implementation.
diff --git a/AGENTS.md b/AGENTS.md
index d153158..767ca11 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,7 +11,7 @@ Use `pnpm` for all package management tasks.
 - **Run All Tests:** `pnpm test` (uses `vitest`)
 - **Run Single Test File:** `pnpm test src/path/to/test.ts`
 - **Type Check:** `pnpm type-check` (runs `tsc --noEmit`)
-- **Format:** `pnpm format-fix` (uses `biome format --fix`)
+- **Format:** `pnpm format` (uses `biome format --fix`)
 - **Generate Docs:** `pnpm generate-docs`
 
 ## 2. Code Style & Conventions
diff --git a/package.json b/package.json
index b4e159a..79d943f 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     "type-check": "tsc --noEmit",
     "coverage": "tsx scripts/coverage.ts",
     "generate-docs": "typedoc",
-    "format-fix": "biome format --fix"
+    "format": "biome format --fix"
   },
   "keywords": [
     "effect",
diff --git a/tsconfig.json b/tsconfig.json
index 51dbadb..8ddee38 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "noEmit": true,
     "target": "esnext",
     "lib": ["es2023"],
     "moduleDetection": "force",

From 0b0236fc9937aae2bfcad4c41e9ce06767c0c839 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 17:49:26 +0100
Subject: [PATCH 23/33] implement Page.touchscreen

---
 src/index.ts       |  1 +
 src/page.test.ts   | 36 ++++++++++++++++++++++++++++++++++++
 src/page.ts        | 11 +++++++++++
 src/touchscreen.ts | 44 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 92 insertions(+)
 create mode 100644 src/touchscreen.ts

diff --git a/src/index.ts b/src/index.ts
index 2509fd7..0639c53 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -29,3 +29,4 @@ export * from "./locator";
 export * from "./mouse";
 export * from "./page";
 export * from "./playwright";
+export * from "./touchscreen";
diff --git a/src/page.test.ts b/src/page.test.ts
index 28b4780..0cf28ba 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -418,6 +418,42 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("touchscreen should allow dispatching events", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const context = yield* browser.newContext({ hasTouch: true });
+      const page = yield* context.newPage;
+
+      yield* page.evaluate(() => {
+        document.body.innerHTML =
+          '<div id="target" style="width: 100px; height: 100px; background: red;"></div>';
+        const target = document.getElementById("target");
+        if (target) {
+          target.addEventListener("touchstart", (e) => {
+            const win = window as TestWindow;
+            win.clicked = true;
+            win.clickCoords = {
+              x: e.touches[0].clientX,
+              y: e.touches[0].clientY,
+            };
+          });
+        }
+      });
+
+      yield* page.touchscreen.tap(50, 50);
+
+      const clicked = yield* page.evaluate(
+        () => (window as TestWindow).clicked,
+      );
+      assert.strictEqual(clicked, true);
+
+      const coords = yield* page.evaluate(
+        () => (window as TestWindow).clickCoords,
+      );
+      assert.deepStrictEqual(coords, { x: 50, y: 50 });
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("screenshot should capture an image", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 50a5dad..1dcd7b8 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -31,6 +31,10 @@ import { PlaywrightKeyboard, type PlaywrightKeyboardService } from "./keyboard";
 import { PlaywrightLocator } from "./locator";
 import { PlaywrightMouse, type PlaywrightMouseService } from "./mouse";
 import type { PageFunction, PatchedEvents } from "./playwright-types";
+import {
+  PlaywrightTouchscreen,
+  type PlaywrightTouchscreenService,
+} from "./touchscreen";
 import { useHelper } from "./utils";
 
 interface PageEvents {
@@ -103,6 +107,12 @@ export interface PlaywrightPageService {
    * @since 0.3.0
    */
   readonly mouse: PlaywrightMouseService;
+  /**
+   * Access the touchscreen.
+   *
+   * @since 0.3.0
+   */
+  readonly touchscreen: PlaywrightTouchscreenService;
   /**
    * Navigates the page to the given URL.
    *
@@ -642,6 +652,7 @@ export class PlaywrightPage extends Context.Tag(
       clock: PlaywrightClock.make(page.clock),
       keyboard: PlaywrightKeyboard.make(page.keyboard),
       mouse: PlaywrightMouse.make(page.mouse),
+      touchscreen: PlaywrightTouchscreen.make(page.touchscreen),
       goto: (url, options) => use((p) => p.goto(url, options)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>
diff --git a/src/touchscreen.ts b/src/touchscreen.ts
new file mode 100644
index 0000000..b137bda
--- /dev/null
+++ b/src/touchscreen.ts
@@ -0,0 +1,44 @@
+import { Context, type Effect } from "effect";
+import type { Touchscreen } from "playwright-core";
+import type { PlaywrightError } from "./errors";
+import { useHelper } from "./utils";
+
+/**
+ * @category model
+ * @since 0.3.0
+ */
+export interface PlaywrightTouchscreenService {
+  /**
+   * Dispatches a `touchstart` and `touchend` event with a single touch at the position
+   * ([`x`](https://playwright.dev/docs/api/class-touchscreen#touchscreen-tap-option-x),[`y`](https://playwright.dev/docs/api/class-touchscreen#touchscreen-tap-option-y)).
+   *
+   * @see {@link Touchscreen.tap}
+   * @since 0.3.0
+   */
+  readonly tap: (
+    x: Parameters<Touchscreen["tap"]>[0],
+    y: Parameters<Touchscreen["tap"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
+}
+
+/**
+ * @category tag
+ * @since 0.3.0
+ */
+export class PlaywrightTouchscreen extends Context.Tag(
+  "effect-playwright/PlaywrightTouchscreen",
+)<PlaywrightTouchscreen, PlaywrightTouchscreenService>() {
+  /**
+   * Creates a `PlaywrightTouchscreen` from a Playwright `Touchscreen` instance.
+   *
+   * @param touchscreen - The Playwright `Touchscreen` instance to wrap.
+   * @since 0.3.0
+   */
+  static make(touchscreen: Touchscreen): PlaywrightTouchscreenService {
+    const use = useHelper(touchscreen);
+
+    return PlaywrightTouchscreen.of({
+      tap: (x, y) => use((t) => t.tap(x, y)),
+    });
+  }
+}

From 3c7a86454645605467fff933509645e0cab88ae4 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 17:58:45 +0100
Subject: [PATCH 24/33] implement Page.isClosed

---
 src/page.test.ts | 13 +++++++++++++
 src/page.ts      |  8 ++++++++
 2 files changed, 21 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 0cf28ba..dcf184c 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -701,4 +701,17 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert(Option.isNone(nonExistentFrame), "Frame should be None");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("isClosed should return the closed state of the page", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      assert.strictEqual(page.isClosed(), false);
+
+      yield* page.close;
+
+      assert.strictEqual(page.isClosed(), true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 1dcd7b8..5b8cd9f 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -552,6 +552,13 @@ export interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly close: Effect.Effect<void, PlaywrightError>;
+  /**
+   * Indicates that the page has been closed.
+   *
+   * @see {@link Page.isClosed}
+   * @since 0.3.0
+   */
+  readonly isClosed: () => boolean;
 
   /**
    * Returns the current URL of the page.
@@ -721,6 +728,7 @@ export class PlaywrightPage extends Context.Tag(
         ),
       bringToFront: use((p) => p.bringToFront()),
       close: use((p) => p.close()),
+      isClosed: () => page.isClosed(),
       screenshot: (options) => use((p) => p.screenshot(options)),
       dragAndDrop: (source, target, options) =>
         use((p) => p.dragAndDrop(source, target, options)),

From 6d76bf2770af1151c7798a0121b427da7ec699c5 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:10:23 +0100
Subject: [PATCH 25/33] implement Page.mainFrame and Page.opener

---
 src/page.test.ts | 40 ++++++++++++++++++++++++++++++++++++++++
 src/page.ts      | 26 ++++++++++++++++++++++++--
 2 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/src/page.test.ts b/src/page.test.ts
index dcf184c..82caf97 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -714,4 +714,44 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(page.isClosed(), true);
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("mainFrame should return the main frame", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      const mainFrame = page.mainFrame();
+      assert.ok(mainFrame);
+
+      const url = mainFrame.url();
+      assert.strictEqual(url, "about:blank");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("opener should return the opener page", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      const popupFiber = yield* page
+        .eventStream("popup")
+        .pipe(Stream.runHead, Effect.fork);
+
+      yield* page.evaluate(() => {
+        window.open("about:blank");
+      });
+
+      const popupOpt = yield* Fiber.join(popupFiber);
+      const popup = Option.getOrThrow(popupOpt);
+
+      const openerOpt = yield* popup.opener;
+      assert(Option.isSome(openerOpt), "Opener should be Some");
+
+      const opener = Option.getOrThrow(openerOpt);
+      const url = opener.url();
+      assert.strictEqual(url, "about:blank");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 5b8cd9f..e0f0c5f 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -596,7 +596,18 @@ export interface PlaywrightPageService {
    * @since 0.3.0
    */
   readonly context: () => PlaywrightBrowserContextService;
-
+  /**
+   * Returns the opener for popup pages and `Option.none` for others.
+   *
+   * If the opener has been closed already, returns `Option.none`.
+   *
+   * @see {@link Page.opener}
+   * @since 0.3.0
+   */
+  readonly opener: Effect.Effect<
+    Option.Option<PlaywrightPageService>,
+    PlaywrightError
+  >;
   /**
    * Returns a frame matching the specified criteria.
    *
@@ -622,7 +633,13 @@ export interface PlaywrightPageService {
     ReadonlyArray<typeof PlaywrightFrame.Service>,
     PlaywrightError
   >;
-
+  /**
+   * The page's main frame. Page is guaranteed to have a main frame which persists during navigations.
+   *
+   * @see {@link Page.mainFrame}
+   * @since 0.3.0
+   */
+  readonly mainFrame: () => typeof PlaywrightFrame.Service;
   /**
    * Creates a stream of the given event from the page.
    *
@@ -709,12 +726,17 @@ export class PlaywrightPage extends Context.Tag(
         PlaywrightLocator.make(page.getByTitle(text, options)),
       url: () => page.url(),
       context: () => PlaywrightBrowserContext.make(page.context()),
+      opener: use((p) => p.opener()).pipe(
+        Effect.map(Option.fromNullable),
+        Effect.map(Option.map(PlaywrightPage.make)),
+      ),
       consoleMessages: use((p) => p.consoleMessages()),
       frame: (frameSelector) =>
         Option.fromNullable(page.frame(frameSelector)).pipe(
           Option.map(PlaywrightFrame.make),
         ),
       frames: use((p) => Promise.resolve(p.frames().map(PlaywrightFrame.make))),
+      mainFrame: () => PlaywrightFrame.make(page.mainFrame()),
       reload: use((p) => p.reload()),
       goBack: (options) =>
         use((p) => p.goBack(options)).pipe(

From e35e61d18cfb9d0bc0106370291d660a637ca1b3 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:18:02 +0100
Subject: [PATCH 26/33] implement Page.pageErrors

---
 src/page.test.ts | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/page.ts      | 15 +++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 82caf97..379b894 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -540,6 +540,54 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("pageerror event should work", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      const errorFiber = yield* page
+        .eventStream("pageerror")
+        .pipe(Stream.runHead, Effect.fork);
+
+      yield* page.evaluate(() => {
+        setTimeout(() => {
+          throw new Error("Test Error");
+        }, 0);
+      });
+
+      const errorOpt = yield* Fiber.join(errorFiber);
+      const error = Option.getOrThrow(errorOpt);
+      assert.strictEqual(error.message, "Test Error");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("pageErrors should return all page errors", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("about:blank");
+
+      const errorFiber = yield* page
+        .eventStream("pageerror")
+        .pipe(Stream.runHead, Effect.fork);
+
+      yield* page.evaluate(() => {
+        setTimeout(() => {
+          throw new Error("Test Error");
+        }, 0);
+      });
+
+      yield* Fiber.join(errorFiber);
+
+      const errors = yield* page.pageErrors;
+      assert.ok(errors.length >= 1);
+      assert.strictEqual(errors[0].message, "Test Error");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("context should return the associated browser context", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index e0f0c5f..3f038f1 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -589,6 +589,19 @@ export interface PlaywrightPageService {
     PlaywrightError
   >;
 
+  /**
+   * Returns all errors that have been thrown in the page.
+   *
+   * @example
+   * ```ts
+   * const pageErrors = yield* page.pageErrors;
+   * ```
+   *
+   * @see {@link Page.pageErrors}
+   * @since 0.3.0
+   */
+  readonly pageErrors: Effect.Effect<ReadonlyArray<Error>, PlaywrightError>;
+
   /**
    * Get the browser context that the page belongs to.
    *
@@ -731,6 +744,8 @@ export class PlaywrightPage extends Context.Tag(
         Effect.map(Option.map(PlaywrightPage.make)),
       ),
       consoleMessages: use((p) => p.consoleMessages()),
+      pageErrors: use((p) => p.pageErrors()),
+
       frame: (frameSelector) =>
         Option.fromNullable(page.frame(frameSelector)).pipe(
           Option.map(PlaywrightFrame.make),

From 04c1b8c9c807eb3f9eff4abf9814bbda8ece0d74 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:19:47 +0100
Subject: [PATCH 27/33] implement Page.pause

---
 src/page.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/page.ts b/src/page.ts
index 3f038f1..fdd036e 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -545,6 +545,13 @@ export interface PlaywrightPageService {
    * @since 0.3.0
    */
   readonly bringToFront: Effect.Effect<void, PlaywrightError>;
+  /**
+   * Pauses the script execution.
+   *
+   * @see {@link Page.pause}
+   * @since 0.3.0
+   */
+  readonly pause: Effect.Effect<void, PlaywrightError>;
   /**
    * Closes the page.
    *
@@ -764,6 +771,7 @@ export class PlaywrightPage extends Context.Tag(
           Effect.map(Option.map(PlaywrightResponse.make)),
         ),
       bringToFront: use((p) => p.bringToFront()),
+      pause: use((p) => p.pause()),
       close: use((p) => p.close()),
       isClosed: () => page.isClosed(),
       screenshot: (options) => use((p) => p.screenshot(options)),

From 4550e27a345c4d493771e55e311242b45e6df1be Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:26:06 +0100
Subject: [PATCH 28/33] implement Page.pdf

---
 src/page.test.ts | 13 +++++++++++++
 src/page.ts      | 14 ++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 379b894..5ebfebf 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -467,6 +467,19 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("pdf should capture a PDF", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.goto("data:text/html,<h1>PDF Test</h1>");
+      const buffer = yield* page.pdf();
+
+      assert(Buffer.isBuffer(buffer));
+      assert(buffer.length > 0);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("addScriptTag should add a script tag to the page", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index fdd036e..5669f12 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -452,6 +452,19 @@ export interface PlaywrightPageService {
     options?: Parameters<Page["screenshot"]>[0],
   ) => Effect.Effect<Buffer, PlaywrightError>;
 
+  /**
+   * Returns the PDF buffer.
+   *
+   * `page.pdf()` generates a pdf of the page with `print` css media. To generate a pdf with `screen` media, call
+   * {@link PlaywrightPageService.emulateMedia} before calling `page.pdf()`.
+   *
+   * @see {@link Page.pdf}
+   * @since 0.3.0
+   */
+  readonly pdf: (
+    options?: Parameters<Page["pdf"]>[0],
+  ) => Effect.Effect<Buffer, PlaywrightError>;
+
   /**
    * Clicks an element matching the given selector.
    *
@@ -775,6 +788,7 @@ export class PlaywrightPage extends Context.Tag(
       close: use((p) => p.close()),
       isClosed: () => page.isClosed(),
       screenshot: (options) => use((p) => p.screenshot(options)),
+      pdf: (options) => use((p) => p.pdf(options)),
       dragAndDrop: (source, target, options) =>
         use((p) => p.dragAndDrop(source, target, options)),
       click: (selector, options) => use((p) => p.click(selector, options)),

From 26bc3cb95a95a954d1566fb06f4fc06923d326f9 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:30:13 +0100
Subject: [PATCH 29/33] implement page.requestGC

---
 src/page.test.ts | 10 ++++++++++
 src/page.ts      |  9 +++++++++
 2 files changed, 19 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 5ebfebf..aa7baad 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -295,6 +295,16 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("requestGC should execute without error", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.requestGC;
+      assert.ok(true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("clock should allow fast forwarding time", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 5669f12..78d5931 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -551,6 +551,14 @@ export interface PlaywrightPageService {
   readonly goForward: (
     options?: Parameters<Page["goForward"]>[0],
   ) => Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
+  /**
+   * Request the page to perform garbage collection. Note that there is no guarantee that all unreachable objects will
+   * be collected.
+   *
+   * @see {@link Page.requestGC}
+   * @since 0.3.0
+   */
+  readonly requestGC: Effect.Effect<void, PlaywrightError>;
   /**
    * Brings page to front (activates tab).
    *
@@ -783,6 +791,7 @@ export class PlaywrightPage extends Context.Tag(
           Effect.map(Option.fromNullable),
           Effect.map(Option.map(PlaywrightResponse.make)),
         ),
+      requestGC: use((p) => p.requestGC()),
       bringToFront: use((p) => p.bringToFront()),
       pause: use((p) => p.pause()),
       close: use((p) => p.close()),

From 38532703b6856dcb08353de0fb9dda7f4a142b89 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:31:24 +0100
Subject: [PATCH 30/33] implement page.setContent

---
 src/page.test.ts | 11 +++++++++++
 src/page.ts      | 12 ++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index aa7baad..b1f2e8c 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -25,6 +25,17 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("setContent should set the page content", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setContent("<h1>Hello World</h1>");
+      const content = yield* page.content;
+      assert(content.includes("<h1>Hello World</h1>"));
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("title should return the page title", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 78d5931..0a2ab23 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -128,6 +128,17 @@ export interface PlaywrightPageService {
     url: string,
     options?: Parameters<Page["goto"]>[1],
   ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * This method internally calls [document.write()](https://developer.mozilla.org/en-US/docs/Web/API/Document/write),
+   * inheriting all its specific characteristics and behaviors.
+   *
+   * @see {@link Page.setContent}
+   * @since 0.3.0
+   */
+  readonly setContent: (
+    html: string,
+    options?: Parameters<Page["setContent"]>[1],
+  ) => Effect.Effect<void, PlaywrightError>;
   /**
    * Waits for the page to navigate to the given URL.
    *
@@ -719,6 +730,7 @@ export class PlaywrightPage extends Context.Tag(
       mouse: PlaywrightMouse.make(page.mouse),
       touchscreen: PlaywrightTouchscreen.make(page.touchscreen),
       goto: (url, options) => use((p) => p.goto(url, options)),
+      setContent: (html, options) => use((p) => p.setContent(html, options)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>
         use((p) => p.waitForLoadState(state, options)),

From ea418b0b88596df53bea98cd42a7d197c2edd1e7 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 18:37:22 +0100
Subject: [PATCH 31/33] implement remaining Page.set* methods

---
 src/page.test.ts | 52 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/page.ts      | 50 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index b1f2e8c..7e97b18 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -836,4 +836,56 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(url, "about:blank");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("setViewportSize should update viewport dimensions", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setViewportSize({ width: 600, height: 400 });
+      const size = yield* page.evaluate(() => ({
+        width: window.innerWidth,
+        height: window.innerHeight,
+      }));
+
+      assert.strictEqual(size.width, 600);
+      assert.strictEqual(size.height, 400);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("setExtraHTTPHeaders should not crash", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setExtraHTTPHeaders({ "x-custom-header": "test-value" });
+      assert.ok(true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("setDefaultNavigationTimeout should not crash", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setDefaultNavigationTimeout(1000);
+      assert.ok(true);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
+  it.scoped("setDefaultTimeout should influence timeouts", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setDefaultTimeout(1);
+
+      const result = yield* page
+        .locator("#non-existent")
+        .click()
+        .pipe(Effect.flip);
+
+      assert.strictEqual(result._tag, "PlaywrightError");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index 0a2ab23..52f86f4 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -139,6 +139,48 @@ export interface PlaywrightPageService {
     html: string,
     options?: Parameters<Page["setContent"]>[1],
   ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * This setting will change the default maximum navigation time for the following methods:
+   * - {@link PlaywrightPageService.goBack}
+   * - {@link PlaywrightPageService.goForward}
+   * - {@link PlaywrightPageService.goto}
+   * - {@link PlaywrightPageService.reload}
+   * - {@link PlaywrightPageService.setContent}
+   * - {@link PlaywrightPageService.waitForURL}
+   *
+   * @see {@link Page.setDefaultNavigationTimeout}
+   * @since 0.3.0
+   */
+  readonly setDefaultNavigationTimeout: (
+    timeout: Parameters<Page["setDefaultNavigationTimeout"]>[0],
+  ) => Effect.Effect<void>;
+  /**
+   * This setting will change the default maximum time for all the methods accepting `timeout` option.
+   *
+   * @see {@link Page.setDefaultTimeout}
+   * @since 0.3.0
+   */
+  readonly setDefaultTimeout: (
+    timeout: Parameters<Page["setDefaultTimeout"]>[0],
+  ) => Effect.Effect<void>;
+  /**
+   * The extra HTTP headers will be sent with every request the page initiates.
+   *
+   * @see {@link Page.setExtraHTTPHeaders}
+   * @since 0.3.0
+   */
+  readonly setExtraHTTPHeaders: (
+    headers: Parameters<Page["setExtraHTTPHeaders"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Sets the viewport size for the page.
+   *
+   * @see {@link Page.setViewportSize}
+   * @since 0.3.0
+   */
+  readonly setViewportSize: (
+    viewportSize: Parameters<Page["setViewportSize"]>[0],
+  ) => Effect.Effect<void, PlaywrightError>;
   /**
    * Waits for the page to navigate to the given URL.
    *
@@ -731,6 +773,14 @@ export class PlaywrightPage extends Context.Tag(
       touchscreen: PlaywrightTouchscreen.make(page.touchscreen),
       goto: (url, options) => use((p) => p.goto(url, options)),
       setContent: (html, options) => use((p) => p.setContent(html, options)),
+      setDefaultNavigationTimeout: (timeout) =>
+        Effect.sync(() => page.setDefaultNavigationTimeout(timeout)),
+      setDefaultTimeout: (timeout) =>
+        Effect.sync(() => page.setDefaultTimeout(timeout)),
+      setExtraHTTPHeaders: (headers) =>
+        use((p) => p.setExtraHTTPHeaders(headers)),
+      setViewportSize: (viewportSize) =>
+        use((p) => p.setViewportSize(viewportSize)),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>
         use((p) => p.waitForLoadState(state, options)),

From e7d7629fc1c82f02e749d86e87f5e0ba32335a70 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 19:34:21 +0100
Subject: [PATCH 32/33] implement remaining Page.viewpowerSize

---
 src/page.test.ts | 15 +++++++++++++++
 src/page.ts      |  8 ++++++++
 2 files changed, 23 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 7e97b18..109dce1 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -853,6 +853,21 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
 
+  it.scoped("viewportSize should return the current viewport size", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      yield* page.setViewportSize({ width: 600, height: 400 });
+      const sizeOpt = page.viewportSize();
+      assert(Option.isSome(sizeOpt));
+      const size = Option.getOrThrow(sizeOpt);
+
+      assert.strictEqual(size.width, 600);
+      assert.strictEqual(size.height, 400);
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
+
   it.scoped("setExtraHTTPHeaders should not crash", () =>
     Effect.gen(function* () {
       const browser = yield* PlaywrightBrowser;
diff --git a/src/page.ts b/src/page.ts
index 52f86f4..f1e65c0 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -181,6 +181,13 @@ export interface PlaywrightPageService {
   readonly setViewportSize: (
     viewportSize: Parameters<Page["setViewportSize"]>[0],
   ) => Effect.Effect<void, PlaywrightError>;
+  /**
+   * Returns the viewport size.
+   *
+   * @see {@link Page.viewportSize}
+   * @since 0.3.0
+   */
+  readonly viewportSize: () => Option.Option<{ width: number; height: number }>;
   /**
    * Waits for the page to navigate to the given URL.
    *
@@ -781,6 +788,7 @@ export class PlaywrightPage extends Context.Tag(
         use((p) => p.setExtraHTTPHeaders(headers)),
       setViewportSize: (viewportSize) =>
         use((p) => p.setViewportSize(viewportSize)),
+      viewportSize: () => Option.fromNullable(page.viewportSize()),
       waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
       waitForLoadState: (state, options) =>
         use((p) => p.waitForLoadState(state, options)),

From 7dc0ed3a924f9a28a73f5b578fa7bf127b78b015 Mon Sep 17 00:00:00 2001
From: Filip Weiss <me@fiws.net>
Date: Sat, 21 Feb 2026 19:35:59 +0100
Subject: [PATCH 33/33] implement remaining Page.workers

---
 src/page.test.ts | 21 +++++++++++++++++++++
 src/page.ts      |  8 ++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/page.test.ts b/src/page.test.ts
index 109dce1..c4ea75c 100644
--- a/src/page.test.ts
+++ b/src/page.test.ts
@@ -903,4 +903,25 @@ layer(PlaywrightEnvironment.layer(chromium))("PlaywrightPage", (it) => {
       assert.strictEqual(result._tag, "PlaywrightError");
     }).pipe(PlaywrightEnvironment.withBrowser),
   );
+
+  it.scoped("workers should return the list of workers", () =>
+    Effect.gen(function* () {
+      const browser = yield* PlaywrightBrowser;
+      const page = yield* browser.newPage();
+
+      const workerFiber = yield* page
+        .eventStream("worker")
+        .pipe(Stream.runHead, Effect.fork);
+
+      yield* page.goto(
+        "data:text/html,<script>new Worker(URL.createObjectURL(new Blob(['console.log(\"worker\")'], {type: 'application/javascript'})));</script>",
+      );
+
+      yield* Fiber.join(workerFiber);
+
+      const workers = page.workers();
+      assert(workers.length >= 1);
+      assert.strictEqual(typeof workers[0].url(), "string");
+    }).pipe(PlaywrightEnvironment.withBrowser),
+  );
 });
diff --git a/src/page.ts b/src/page.ts
index f1e65c0..69f4e5a 100644
--- a/src/page.ts
+++ b/src/page.ts
@@ -689,6 +689,13 @@ export interface PlaywrightPageService {
    * @since 0.3.0
    */
   readonly pageErrors: Effect.Effect<ReadonlyArray<Error>, PlaywrightError>;
+  /**
+   * Returns all workers.
+   *
+   * @see {@link Page.workers}
+   * @since 0.3.0
+   */
+  readonly workers: () => ReadonlyArray<PlaywrightWorker>;
 
   /**
    * Get the browser context that the page belongs to.
@@ -843,6 +850,7 @@ export class PlaywrightPage extends Context.Tag(
       ),
       consoleMessages: use((p) => p.consoleMessages()),
       pageErrors: use((p) => p.pageErrors()),
+      workers: () => page.workers().map(PlaywrightWorker.make),
 
       frame: (frameSelector) =>
         Option.fromNullable(page.frame(frameSelector)).pipe(