effect-playwright 0.2.3 → 0.3.0

package/dist/{index-xKVXY-Ra.d.mts → index-CA1jsZ4o.d.mts}

@@ -1,7 +1,7 @@
 import { Context, Effect, Layer, Option, Scope, Stream } from "effect";
-import { Browser, BrowserContext, BrowserType, ConnectOverCDPOptions, ConsoleMessage, Dialog, Download, ElementHandle, FileChooser, Frame, JSHandle, Locator, Page, Request, Response, WebError, WebSocket, Worker, chromium } from "playwright-core";
+import { Browser, BrowserContext, BrowserType, Clock, ConnectOverCDPOptions, ConsoleMessage, Dialog, Download, ElementHandle, FileChooser, Frame, JSHandle, Keyboard, Locator, Mouse, Page, Request, Response, Touchscreen, WebError, WebSocket, Worker, chromium } from "playwright-core";
 import { Scope as Scope$1 } from "effect/Scope";
-import * as effect_Types5 from "effect/Types";
+import * as effect_Types0 from "effect/Types";
 import * as effect_Cause0 from "effect/Cause";
 
 //#region src/errors.d.ts
@@ -13,7 +13,7 @@ import * as effect_Cause0 from "effect/Cause";
  * @since 0.1.0
  */
 type PlaywrightErrorReason = "Timeout" | "Unknown";
-declare const PlaywrightError_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+declare const PlaywrightError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
   readonly _tag: "PlaywrightError";
 } & Readonly<A>;
 /**
@@ -253,6 +253,8 @@ interface PlaywrightFrameService {
   /**
    * Returns a locator for the given selector.
    *
+   * NOTE: This method will cause a defect if `options.has` or `options.hasNot` are provided and belong to a different frame.
+   *
    * @see {@link Frame.locator}
    * @since 0.1.3
    */
@@ -291,7 +293,7 @@ interface PlaywrightFrameService {
    * @see {@link Frame.url}
    * @since 0.1.3
    */
-  readonly url: Effect.Effect<string, PlaywrightError>;
+  readonly url: () => string;
   /**
    * Returns the full HTML contents of the frame, including the doctype.
    *
@@ -305,7 +307,7 @@ interface PlaywrightFrameService {
    * @see {@link Frame.name}
    * @since 0.1.3
    */
-  readonly name: Effect.Effect<string>;
+  readonly name: () => string;
   /**
    * Clicks an element matching the given selector.
    *
@@ -331,8 +333,95 @@ declare class PlaywrightFrame extends PlaywrightFrame_base {
   static make(frame: Frame): PlaywrightFrameService;
 }
 //#endregion
+//#region src/clock.d.ts
+/**
+ * Interface for a Playwright clock.
+ * @category model
+ */
+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>;
+}
+declare const PlaywrightClock_base: Context.TagClass<PlaywrightClock, "effect-playwright/PlaywrightClock", PlaywrightClockService>;
+/**
+ * A service that provides a `PlaywrightClock` instance.
+ *
+ * @since 0.1.0
+ * @category tag
+ */
+declare class PlaywrightClock extends PlaywrightClock_base {
+  /**
+   * 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;
+}
+//#endregion
 //#region src/common.d.ts
-declare const PlaywrightRequest_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightRequest_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightRequest";
 };
 /**
@@ -340,29 +429,105 @@ declare const PlaywrightRequest_base: new <A extends Record<string, any> = {}>(a
  * @since 0.1.2
  */
 declare class PlaywrightRequest extends PlaywrightRequest_base<{
+  /**
+   * An object with all the request HTTP headers associated with this request. The header names are lower-cased.
+   * @see {@link Request.allHeaders}
+   */
   allHeaders: Effect.Effect<Awaited<ReturnType<Request["allHeaders"]>>, PlaywrightError>;
+  /**
+   * The method returns null unless this request was a failed one.
+   * @see {@link Request.failure}
+   */
   failure: () => Option.Option<NonNullable<ReturnType<Request["failure"]>>>;
+  /**
+   * Returns the Frame that initiated this request.
+   * @see {@link Request.frame}
+   */
   frame: Effect.Effect<PlaywrightFrameService>;
+  /**
+   * Returns the value of the header matching the name. The name is case insensitive.
+   * @see {@link Request.headerValue}
+   */
   headerValue: (name: string) => Effect.Effect<Option.Option<string>, PlaywrightError>;
-  headers: Effect.Effect<ReturnType<Request["headers"]>>;
+  /**
+   * An object with the request HTTP headers. The header names are lower-cased.
+   * @see {@link Request.headers}
+   */
+  headers: () => ReturnType<Request["headers"]>;
+  /**
+   * An array with all the request HTTP headers associated with this request.
+   * @see {@link Request.headersArray}
+   */
   headersArray: Effect.Effect<Awaited<ReturnType<Request["headersArray"]>>, PlaywrightError>;
-  isNavigationRequest: Effect.Effect<boolean>;
-  method: Effect.Effect<string>;
+  /**
+   * Whether this request is driving frame's navigation.
+   * @see {@link Request.isNavigationRequest}
+   */
+  isNavigationRequest: () => boolean;
+  /**
+   * Request's method (GET, POST, etc.)
+   * @see {@link Request.method}
+   */
+  method: () => string;
+  /**
+   * Request's post body, if any.
+   * @see {@link Request.postData}
+   */
   postData: () => Option.Option<string>;
+  /**
+   * Request's post body in a binary form, if any.
+   * @see {@link Request.postDataBuffer}
+   */
   postDataBuffer: () => Option.Option<NonNullable<ReturnType<Request["postDataBuffer"]>>>;
+  /**
+   * Returns parsed request's body for form-urlencoded and JSON requests.
+   * @see {@link Request.postDataJSON}
+   */
   postDataJSON: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Request["postDataJSON"]>>>>, PlaywrightError>;
+  /**
+   * Request that was redirected by the server to this one, if any.
+   * @see {@link Request.redirectedFrom}
+   */
   redirectedFrom: () => Option.Option<PlaywrightRequest>;
+  /**
+   * New request issued by the browser if the server responded with redirect.
+   * @see {@link Request.redirectedTo}
+   */
   redirectedTo: () => Option.Option<PlaywrightRequest>;
-  resourceType: Effect.Effect<ReturnType<Request["resourceType"]>>;
+  /**
+   * Contains the request's resource type as it was perceived by the rendering engine.
+   * @see {@link Request.resourceType}
+   */
+  resourceType: () => string;
+  /**
+   * Returns the matching Response object, or null if the response was not received due to error.
+   * @see {@link Request.response}
+   */
   response: Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
+  /**
+   * Returns the ServiceWorker that initiated this request.
+   * @see {@link Request.serviceWorker}
+   */
   serviceWorker: () => Option.Option<PlaywrightWorker>;
+  /**
+   * Returns resource size information for given request.
+   * @see {@link Request.sizes}
+   */
   sizes: Effect.Effect<Awaited<ReturnType<Request["sizes"]>>, PlaywrightError>;
-  timing: Effect.Effect<ReturnType<Request["timing"]>>;
-  url: Effect.Effect<string>;
+  /**
+   * Returns resource timing information for given request.
+   * @see {@link Request.timing}
+   */
+  timing: () => ReturnType<Request["timing"]>;
+  /**
+   * URL of the request.
+   * @see {@link Request.url}
+   */
+  url: () => string;
 }> {
   static make(request: Request): PlaywrightRequest;
 }
-declare const PlaywrightResponse_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightResponse_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightResponse";
 };
 /**
@@ -374,24 +539,24 @@ declare class PlaywrightResponse extends PlaywrightResponse_base<{
   body: Effect.Effect<Awaited<ReturnType<Response["body"]>>, PlaywrightError>;
   finished: Effect.Effect<Awaited<ReturnType<Response["finished"]>>, PlaywrightError>;
   frame: Effect.Effect<PlaywrightFrameService>;
-  fromServiceWorker: Effect.Effect<boolean>;
-  headers: Effect.Effect<ReturnType<Response["headers"]>>;
+  fromServiceWorker: () => boolean;
+  headers: () => ReturnType<Response["headers"]>;
   headersArray: Effect.Effect<Awaited<ReturnType<Response["headersArray"]>>, PlaywrightError>;
   headerValue: (name: string) => Effect.Effect<Option.Option<string>, PlaywrightError>;
   headerValues: (name: string) => Effect.Effect<Awaited<ReturnType<Response["headerValues"]>>, PlaywrightError>;
   json: Effect.Effect<Awaited<ReturnType<Response["json"]>>, PlaywrightError>;
-  ok: Effect.Effect<boolean>;
+  ok: () => boolean;
   request: () => PlaywrightRequest;
   securityDetails: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Response["securityDetails"]>>>>, PlaywrightError>;
   serverAddr: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Response["serverAddr"]>>>>, PlaywrightError>;
-  status: Effect.Effect<number>;
-  statusText: Effect.Effect<string>;
+  status: () => number;
+  statusText: () => string;
   text: Effect.Effect<Awaited<ReturnType<Response["text"]>>, PlaywrightError>;
-  url: Effect.Effect<string>;
+  url: () => string;
 }> {
   static make(response: Response): PlaywrightResponse;
 }
-declare const PlaywrightWorker_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightWorker_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightWorker";
 };
 /**
@@ -400,11 +565,11 @@ declare const PlaywrightWorker_base: new <A extends Record<string, any> = {}>(ar
  */
 declare class PlaywrightWorker extends PlaywrightWorker_base<{
   evaluate: <R, Arg = void>(pageFunction: PageFunction<Arg, R>, arg?: Arg) => Effect.Effect<R, PlaywrightError>;
-  url: Effect.Effect<string>;
+  url: () => string;
 }> {
   static make(worker: Worker): PlaywrightWorker;
 }
-declare const PlaywrightDialog_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightDialog_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightDialog";
 };
 /**
@@ -413,15 +578,15 @@ declare const PlaywrightDialog_base: new <A extends Record<string, any> = {}>(ar
  */
 declare class PlaywrightDialog extends PlaywrightDialog_base<{
   accept: (promptText?: string) => Effect.Effect<void, PlaywrightError>;
-  defaultValue: Effect.Effect<string>;
+  defaultValue: () => string;
   dismiss: Effect.Effect<void, PlaywrightError>;
-  message: Effect.Effect<string>;
+  message: () => string;
   page: () => Option.Option<PlaywrightPageService>;
-  type: Effect.Effect<string>;
+  type: () => string;
 }> {
   static make(dialog: Dialog): PlaywrightDialog;
 }
-declare const PlaywrightFileChooser_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightFileChooser_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightFileChooser";
 };
 /**
@@ -430,13 +595,13 @@ declare const PlaywrightFileChooser_base: new <A extends Record<string, any> = {
  */
 declare class PlaywrightFileChooser extends PlaywrightFileChooser_base<{
   element: () => ElementHandle;
-  isMultiple: Effect.Effect<boolean>;
+  isMultiple: () => boolean;
   page: () => PlaywrightPageService;
   setFiles: (files: Parameters<FileChooser["setFiles"]>[0], options?: Parameters<FileChooser["setFiles"]>[1]) => Effect.Effect<void, PlaywrightError>;
 }> {
   static make(fileChooser: FileChooser): PlaywrightFileChooser;
 }
-declare const PlaywrightDownload_base: new <A extends Record<string, any> = {}>(args: effect_Types5.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+declare const PlaywrightDownload_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
   readonly _tag: "PlaywrightDownload";
 };
 /**
@@ -456,13 +621,162 @@ declare class PlaywrightDownload extends PlaywrightDownload_base<{
   page: () => PlaywrightPageService;
   path: Effect.Effect<Option.Option<string | null>, PlaywrightError>;
   saveAs: (path: string) => Effect.Effect<void, PlaywrightError>;
-  suggestedFilename: Effect.Effect<string>;
-  url: Effect.Effect<string>;
+  suggestedFilename: () => string;
+  url: () => string;
   use: <R>(f: (download: Download) => Promise<R>) => Effect.Effect<R, PlaywrightError>;
 }> {
   static make(download: Download): PlaywrightDownload;
 }
 //#endregion
+//#region src/keyboard.d.ts
+/**
+ * @category model
+ * @since 0.1.0
+ */
+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>;
+}
+declare const PlaywrightKeyboard_base: Context.TagClass<PlaywrightKeyboard, "effect-playwright/PlaywrightKeyboard", PlaywrightKeyboardService>;
+/**
+ * @category tag
+ */
+declare class PlaywrightKeyboard extends PlaywrightKeyboard_base {
+  /**
+   * 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;
+}
+//#endregion
+//#region src/mouse.d.ts
+/**
+ * @category model
+ * @since 0.3.0
+ */
+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>;
+}
+declare const PlaywrightMouse_base: Context.TagClass<PlaywrightMouse, "effect-playwright/PlaywrightMouse", PlaywrightMouseService>;
+/**
+ * @category tag
+ */
+declare class PlaywrightMouse extends PlaywrightMouse_base {
+  /**
+   * 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;
+}
+//#endregion
+//#region src/touchscreen.d.ts
+/**
+ * @category model
+ * @since 0.3.0
+ */
+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>;
+}
+declare const PlaywrightTouchscreen_base: Context.TagClass<PlaywrightTouchscreen, "effect-playwright/PlaywrightTouchscreen", PlaywrightTouchscreenService>;
+/**
+ * @category tag
+ * @since 0.3.0
+ */
+declare class PlaywrightTouchscreen extends PlaywrightTouchscreen_base {
+  /**
+   * 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;
+}
+//#endregion
 //#region src/page.d.ts
 interface PageEvents {
   close: Page;
@@ -512,6 +826,30 @@ type PageWithPatchedEvents = PatchedEvents<Page, PageEvents>;
  * @since 0.1.0
  */
 interface PlaywrightPageService {
+  /**
+   * Access the clock.
+   *
+   * @since 0.3.0
+   */
+  readonly clock: PlaywrightClockService;
+  /**
+   * Access the keyboard.
+   *
+   * @since 0.3.0
+   */
+  readonly keyboard: PlaywrightKeyboardService;
+  /**
+   * Access the mouse.
+   *
+   * @since 0.3.0
+   */
+  readonly mouse: PlaywrightMouseService;
+  /**
+   * Access the touchscreen.
+   *
+   * @since 0.3.0
+   */
+  readonly touchscreen: PlaywrightTouchscreenService;
   /**
    * Navigates the page to the given URL.
    *
@@ -524,6 +862,58 @@ interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly goto: (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>;
+  /**
+   * 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>;
+  /**
+   * 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.
    *
@@ -565,6 +955,130 @@ interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly evaluate: <R, Arg = void>(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.3.0
+   */
+  readonly addInitScript: (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.3.0
+   */
+  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.
+   *
+   * @see {@link Page.addStyleTag}
+   * @since 0.3.0
+   */
+  readonly addStyleTag: (options: Parameters<Page["addStyleTag"]>[0]) => Effect.Effect<ElementHandle, PlaywrightError>;
   /**
    * Returns the page title.
    *
@@ -577,6 +1091,18 @@ 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.
@@ -593,6 +1119,8 @@ interface PlaywrightPageService {
   /**
    * Returns a locator for the given selector.
    *
+   * NOTE: This method will cause a defect if `options.has` or `options.hasNot` are provided and belong to a different frame.
+   *
    * @see {@link Page.locator}
    * @since 0.1.0
    */
@@ -625,6 +1153,88 @@ interface PlaywrightPageService {
    * @since 0.1.0
    */
   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.
+   *
+   * @example
+   * ```ts
+   * const buffer = yield* page.screenshot({ path: "screenshot.png" });
+   * ```
+   *
+   * @see {@link Page.screenshot}
+   * @since 0.3.0
+   */
+  readonly screenshot: (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.
+   *
+   * @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>;
+  /**
+   * 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.
    *
@@ -632,6 +1242,52 @@ 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>;
+  /**
+   * 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).
+   *
+   * @see {@link Page.bringToFront}
+   * @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.
    *
@@ -639,18 +1295,84 @@ 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.
    *
    * @example
    * ```ts
-   * const url = yield* page.url;
+   * const url = page.url();
    * ```
    *
    * @see {@link Page.url}
    * @since 0.1.0
    */
-  readonly url: Effect.Effect<string, PlaywrightError>;
+  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 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>;
+  /**
+   * Returns all workers.
+   *
+   * @see {@link Page.workers}
+   * @since 0.3.0
+   */
+  readonly workers: () => ReadonlyArray<PlaywrightWorker>;
+  /**
+   * Get the browser context that the page belongs to.
+   *
+   * @see {@link Page.context}
+   * @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.
+   *
+   * @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.
    *
@@ -658,6 +1380,13 @@ interface PlaywrightPageService {
    * @since 0.2.0
    */
   readonly frames: Effect.Effect<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.
    *
@@ -671,19 +1400,6 @@ interface PlaywrightPageService {
    * @since 0.1.0
    */
   readonly eventStream: <K extends keyof PageEvents>(event: K) => Stream.Stream<ReturnType<(typeof eventMappings$2)[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>;
 }
 declare const PlaywrightPage_base: Context.TagClass<PlaywrightPage, "effect-playwright/PlaywrightPage", PlaywrightPageService>;
 /**
@@ -732,6 +1448,10 @@ type BrowserContextWithPatchedEvents = PatchedEvents<BrowserContext, BrowserCont
  * @since 0.1.0
  */
 interface PlaywrightBrowserContextService {
+  /**
+   * Access the clock.
+   */
+  readonly clock: PlaywrightClockService;
   /**
    * Returns the list of all open pages in the browser context.
    *
@@ -758,6 +1478,15 @@ 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.
    *
@@ -838,23 +1567,23 @@ interface PlaywrightBrowserService {
    * An Effect that returns the list of all open browser contexts.
    * @see {@link Browser.contexts}
    */
-  readonly contexts: Effect.Effect<Array<typeof PlaywrightBrowserContext.Service>>;
+  readonly contexts: () => Array<typeof PlaywrightBrowserContext.Service>;
   readonly newContext: (options?: NewContextOptions) => Effect.Effect<typeof PlaywrightBrowserContext.Service, PlaywrightError, Scope$1>;
   /**
    * An Effect that returns the browser type (chromium, firefox or webkit) that the browser belongs to.
    * @see {@link Browser.browserType}
    */
-  readonly browserType: Effect.Effect<BrowserType>;
+  readonly browserType: () => BrowserType;
   /**
    * An Effect that returns the version of the browser.
    * @see {@link Browser.version}
    */
-  readonly version: Effect.Effect<string>;
+  readonly version: () => string;
   /**
    * An Effect that returns whether the browser is connected.
    * @see {@link Browser.isConnected}
    */
-  readonly isConnected: Effect.Effect<boolean>;
+  readonly isConnected: () => boolean;
   /**
    * Creates a stream of the given event from the browser.
    *
@@ -881,6 +1610,7 @@ declare class PlaywrightBrowser extends PlaywrightBrowser_base {
 }
 //#endregion
 //#region src/playwright.d.ts
+type LaunchPersistentContextOptions = Parameters<BrowserType["launchPersistentContext"]>[1];
 /**
  * @category model
  * @since 0.1.0
@@ -935,6 +1665,93 @@ interface PlaywrightService {
    * @since 0.1.0
    */
   launchScoped: (browserType: BrowserType, options?: LaunchOptions$1) => Effect.Effect<typeof PlaywrightBrowser.Service, PlaywrightError, Scope.Scope>;
+  /**
+   * Launches a persistent browser context.
+   *
+   * Unlike {@link launchPersistentContextScoped}, this method does **not** close the
+   * context automatically when scope is closed. You are responsible for closing it.
+   *
+   * This launches a browser with a persistent profile under `userDataDir` and returns
+   * the single persistent context for that browser.
+   *
+   * Closing this context also closes the underlying browser process.
+   *
+   * ```ts
+   * import { Effect } from "effect";
+   * import { Playwright } from "effect-playwright";
+   * import { chromium } from "playwright-core";
+   *
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContext(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   const page = yield* context.newPage;
+   *   yield* page.goto("https://example.com");
+   *
+   *   // Closes the persistent context and browser process.
+   *   yield* context.close;
+   * });
+   *
+   * await Effect.runPromise(program);
+   * ```
+   *
+   * If you call this non-scoped variant inside a scope, add a finalizer for cleanup:
+   *
+   * ```ts
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContext(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   yield* Effect.addFinalizer(() => context.close.pipe(Effect.ignore));
+   * });
+   *
+   * await Effect.runPromise(program.pipe(Effect.scoped));
+   * ```
+   *
+   * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+   * @param userDataDir - Directory used for persistent browser profile data. Pass `""` for a temporary profile directory.
+   * @param options - Optional persistent context launch options.
+   * @since 0.2.4
+   */
+  launchPersistentContext: (browserType: BrowserType, userDataDir: string, options?: LaunchPersistentContextOptions) => Effect.Effect<typeof PlaywrightBrowserContext.Service, PlaywrightError>;
+  /**
+   * Launches a persistent browser context managed by a Scope.
+   *
+   * This automatically closes the persistent context (and therefore the browser process)
+   * when the scope is closed.
+   *
+   * ```ts
+   * import { Effect } from "effect";
+   * import { Playwright } from "effect-playwright";
+   * import { chromium } from "playwright-core";
+   *
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContextScoped(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   const page = yield* context.newPage;
+   *   yield* page.goto("https://example.com");
+   *   // Context/browser cleanup is automatic when scope closes.
+   * }).pipe(Effect.scoped);
+   *
+   * await Effect.runPromise(program);
+   * ```
+   *
+   * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+   * @param userDataDir - Directory used for persistent browser profile data. Pass `""` for a temporary profile directory.
+   * @param options - Optional persistent context launch options.
+   * @since 0.2.4
+   */
+  launchPersistentContextScoped: (browserType: BrowserType, userDataDir: string, options?: LaunchPersistentContextOptions) => Effect.Effect<typeof PlaywrightBrowserContext.Service, PlaywrightError, Scope.Scope>;
   /**
    * Connects to a browser instance via Chrome DevTools Protocol (CDP).
    *
@@ -1001,4 +1818,4 @@ declare class Playwright extends Playwright_base {
   static readonly layer: Layer.Layer<Playwright, never, never>;
 }
 //#endregion
-export { PlaywrightErrorReason as C, PlaywrightError as S, PlaywrightWorker as _, NewPageOptions as a, PlaywrightLocator as b, PlaywrightBrowserContext as c, PlaywrightPageService as d, PlaywrightDialog as f, PlaywrightResponse as g, PlaywrightRequest as h, NewContextOptions as i, PlaywrightBrowserContextService as l, PlaywrightFileChooser as m, PlaywrightService as n, PlaywrightBrowser as o, PlaywrightDownload as p, LaunchOptions$1 as r, PlaywrightBrowserService as s, Playwright as t, PlaywrightPage as u, PlaywrightFrame as v, PlaywrightLocatorService as x, PlaywrightFrameService as y };
+export { PlaywrightError as A, PlaywrightWorker as C, PlaywrightFrameService as D, PlaywrightFrame as E, PlaywrightLocator as O, PlaywrightResponse as S, PlaywrightClockService as T, PlaywrightKeyboardService as _, NewPageOptions as a, PlaywrightFileChooser as b, PlaywrightBrowserContext as c, PlaywrightPageService as d, PlaywrightTouchscreen as f, PlaywrightKeyboard as g, PlaywrightMouseService as h, NewContextOptions as i, PlaywrightErrorReason as j, PlaywrightLocatorService as k, PlaywrightBrowserContextService as l, PlaywrightMouse as m, PlaywrightService as n, PlaywrightBrowser as o, PlaywrightTouchscreenService as p, LaunchOptions$1 as r, PlaywrightBrowserService as s, Playwright as t, PlaywrightPage as u, PlaywrightDialog as v, PlaywrightClock as w, PlaywrightRequest as x, PlaywrightDownload as y };