effect-playwright 0.1.1 → 0.2.0

package/dist/index-K6LNMeXC.d.mts

@@ -0,0 +1,1004 @@
+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 { Scope as Scope$1 } from "effect/Scope";
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/errors.d.ts
+/**
+ * Playwright does not provide detailed error information but there is
+ * a distinction between timeout and other errors.
+ *
+ * @category error
+ * @since 0.1.0
+ */
+type PlaywrightErrorReason = "Timeout" | "Unknown";
+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>;
+/**
+ * Error type that is returned when a Playwright error occurs.
+ * Reason can either be "Timeout" or "Unknown".
+ *
+ * Timeout errors occur when a timeout is reached. All other errors are
+ * grouped under "Unknown".
+ *
+ * @category error
+ * @since 0.1.0
+ */
+declare class PlaywrightError extends PlaywrightError_base<{
+  reason: PlaywrightErrorReason;
+  cause: unknown;
+}> {}
+//#endregion
+//#region src/playwright-types.d.ts
+/**
+ * Extracted from `playwright-core/types/structs.d.ts` because it is not exported over the package boundary.
+ * These types are necessary to correctly type `evaluate` functions that unwrap handles.
+ */
+type NoHandles<Arg> = Arg extends JSHandle ? never : Arg extends object ? { [Key in keyof Arg]: NoHandles<Arg[Key]> } : Arg;
+type Unboxed<Arg> = Arg extends ElementHandle<infer T> ? T : Arg extends JSHandle<infer T> ? T : Arg extends NoHandles<Arg> ? Arg : Arg extends [infer A0] ? [Unboxed<A0>] : Arg extends [infer A0, infer A1] ? [Unboxed<A0>, Unboxed<A1>] : Arg extends [infer A0, infer A1, infer A2] ? [Unboxed<A0>, Unboxed<A1>, Unboxed<A2>] : Arg extends [infer A0, infer A1, infer A2, infer A3] ? [Unboxed<A0>, Unboxed<A1>, Unboxed<A2>, Unboxed<A3>] : Arg extends Array<infer T> ? Array<Unboxed<T>> : Arg extends object ? { [Key in keyof Arg]: Unboxed<Arg[Key]> } : Arg;
+type PageFunction<Arg, R> = string | ((arg: Unboxed<Arg>) => R | Promise<R>);
+/**
+ * A type helper to patch the `on`, `off`, and `once` methods of a Playwright object
+ * to support a specific set of events with correctly typed listeners.
+ *
+ * This is useful because Playwright's event methods are often overloaded,
+ * making them difficult to use in generic contexts or with custom event maps.
+ *
+ * @internal
+ */
+type PatchedEvents<Original, Events> = Original & {
+  on<K extends keyof Events>(event: K, listener: (arg: Events[K]) => void): PatchedEvents<Original, Events>;
+  off<K extends keyof Events>(event: K, listener: (arg: Events[K]) => void): PatchedEvents<Original, Events>;
+  once<K extends keyof Events>(event: K, listener: (arg: Events[K]) => void): PatchedEvents<Original, Events>;
+};
+//#endregion
+//#region src/locator.d.ts
+/**
+ * Interface for a Playwright locator.
+ * @category model
+ */
+interface PlaywrightLocatorService {
+  /**
+       * Clicks the element.
+       *
+       * @see {@link Locator.click}
+       * @since 0.1.0
+       */
+  readonly click: (options?: Parameters<Locator["click"]>[0]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Fills the input field.
+       *
+       * @see {@link Locator.fill}
+       * @since 0.1.0
+       */
+  readonly fill: (value: string, options?: Parameters<Locator["fill"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Gets an attribute value.
+       *
+       * @see {@link Locator.getAttribute}
+       * @since 0.1.0
+       */
+  readonly getAttribute: (name: string, options?: Parameters<Locator["getAttribute"]>[1]) => Effect.Effect<string | null, PlaywrightError>;
+  /**
+       * Gets the inner text.
+       *
+       * @see {@link Locator.innerText}
+       * @since 0.1.0
+       */
+  readonly innerText: (options?: Parameters<Locator["innerText"]>[0]) => Effect.Effect<string, PlaywrightError>;
+  /**
+       * Gets the inner HTML.
+       *
+       * @see {@link Locator.innerHTML}
+       * @since 0.1.0
+       */
+  readonly innerHTML: (options?: Parameters<Locator["innerHTML"]>[0]) => Effect.Effect<string, PlaywrightError>;
+  /**
+       * Gets the input value.
+       *
+       * @see {@link Locator.inputValue}
+       * @since 0.1.0
+       */
+  readonly inputValue: (options?: Parameters<Locator["inputValue"]>[0]) => Effect.Effect<string, PlaywrightError>;
+  /**
+       * Gets the text content.
+       *
+       * @see {@link Locator.textContent}
+       * @since 0.1.0
+       */
+  readonly textContent: (options?: Parameters<Locator["textContent"]>[0]) => Effect.Effect<string | null, PlaywrightError>;
+  /**
+       * Counts the number of matched elements.
+       *
+       * @see {@link Locator.count}
+       * @since 0.1.0
+       */
+  readonly count: Effect.Effect<number, PlaywrightError>;
+  /**
+       * Returns a locator that points to the first matched element.
+       * @see {@link Locator.first}
+       * @since 0.1.0
+       */
+  readonly first: () => PlaywrightLocatorService;
+  /**
+       * Returns a locator that points to the last matched element.
+       *
+       * @see {@link Locator.last}
+       * @since 0.1.0
+       */
+  readonly last: () => PlaywrightLocatorService;
+  /**
+       * Returns a locator that points to the nth matched element.
+       *
+       * @see {@link Locator.nth}
+       * @since 0.1.0
+       */
+  readonly nth: (index: number) => PlaywrightLocatorService;
+  /**
+       * Evaluates a function on the matched element.
+       *
+       * @example
+       * ```ts
+       * import { PlaywrightBrowser } from "effect-playwright";
+       * import { PlaywrightEnvironment } from "effect-playwright/experimental";
+       * import { chromium } from "@playwright/test";
+       * import { Effect } from "effect";
+       *
+       * const program = Effect.gen(function* () {
+       *   const browser = yield* PlaywrightBrowser;
+       *   const page = yield* browser.newPage();
+       *   const locator = yield* page.locator("button");
+       *   const buttonContent = yield* locator.evaluate((button) => button.textContent());
+       * }).pipe(PlaywrightEnvironment.provideBrowser, Effect.provide(PlaywrightEnvironment.layer(chromium)));
+       * ```
+       *
+       * @see {@link Locator.evaluate}
+       * @since 0.1.0
+       */
+  readonly evaluate: <R, Arg = void, E extends SVGElement | HTMLElement = SVGElement | HTMLElement>(pageFunction: (element: E, arg: Unboxed<Arg>) => R | Promise<R>, arg?: Arg, options?: {
+    timeout?: number;
+  }) => Effect.Effect<R, PlaywrightError>;
+  /**
+       * A generic utility to execute any promise-based method on the underlying Playwright `Locator`.
+       * Can be used to access any Locator functionality not directly exposed by this service.
+       *
+       * @example
+       * ```typescript
+       * const isVisible = yield* locator.use((l) => l.isVisible());
+       * ```
+       *
+       * @param f - A function that takes the Playwright `Locator` and returns a `Promise`.
+       * @returns An effect that wraps the promise and returns its result.
+       * @see {@link Locator}
+       * @since 0.1.0
+       */
+  readonly use: <T>(f: (locator: Locator) => Promise<T>) => Effect.Effect<T, PlaywrightError>;
+}
+declare const PlaywrightLocator_base: Context.TagClass<PlaywrightLocator, "effect-playwright/PlaywrightLocator", PlaywrightLocatorService>;
+/**
+ * A service that provides a `PlaywrightLocator` instance.
+ *
+ * @since 0.1.0
+ * @category tag
+ */
+declare class PlaywrightLocator extends PlaywrightLocator_base {
+  /**
+       * Creates a `PlaywrightLocator` from a Playwright `Locator` instance. This is mostly for internal use.
+       * But you could use this if you have used `use` or similar to wrap the locator.
+       *
+       * @example
+       * ```ts
+       * const playwrightNativeLocator = yield* page.use((p) => p.locator("button"));
+       * const locator = PlaywrightLocator.make(playwrightNativeLocator);
+       * ```
+       *
+       * @param locator - The Playwright `Locator` instance to wrap.
+       * @since 0.1.0
+       * @category constructor
+       */
+  static make(locator: Locator): typeof PlaywrightLocator.Service;
+}
+//#endregion
+//#region src/frame.d.ts
+/**
+ * @category model
+ * @since 0.1.2
+ */
+interface PlaywrightFrameService {
+  /**
+       * Navigates the frame to the given URL.
+       *
+       * @see {@link Frame.goto}
+       * @since 0.1.3
+       */
+  readonly goto: (url: string, options?: Parameters<Frame["goto"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Waits for the frame to navigate to the given URL.
+       *
+       * @see {@link Frame.waitForURL}
+       * @since 0.1.3
+       */
+  readonly waitForURL: (url: Parameters<Frame["waitForURL"]>[0], options?: Parameters<Frame["waitForURL"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Waits for the frame to reach the given load state.
+       *
+       * @see {@link Frame.waitForLoadState}
+       * @since 0.2.0
+       */
+  readonly waitForLoadState: (state?: Parameters<Frame["waitForLoadState"]>[0], options?: Parameters<Frame["waitForLoadState"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Evaluates a function in the context of the frame.
+       *
+       * @see {@link Frame.evaluate}
+       * @since 0.1.3
+       */
+  readonly evaluate: <R, Arg = void>(pageFunction: PageFunction<Arg, R>, arg?: Arg) => Effect.Effect<R, PlaywrightError>;
+  /**
+       * Returns the frame title.
+       *
+       * @see {@link Frame.title}
+       * @since 0.1.3
+       */
+  readonly title: Effect.Effect<string, PlaywrightError>;
+  /**
+       * A generic utility to execute any promise-based method on the underlying Playwright `Frame`.
+       * Can be used to access any Frame functionality not directly exposed by this service.
+       *
+       * @see {@link Frame}
+       * @since 0.1.2
+       */
+  readonly use: <T>(f: (frame: Frame) => Promise<T>) => Effect.Effect<T, PlaywrightError>;
+  /**
+       * Returns a locator for the given selector.
+       *
+       * @see {@link Frame.locator}
+       * @since 0.1.3
+       */
+  readonly locator: (selector: string, options?: Parameters<Frame["locator"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given role.
+       *
+       * @see {@link Frame.getByRole}
+       * @since 0.1.3
+       */
+  readonly getByRole: (role: Parameters<Frame["getByRole"]>[0], options?: Parameters<Frame["getByRole"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given text.
+       *
+       * @see {@link Frame.getByText}
+       * @since 0.1.3
+       */
+  readonly getByText: (text: Parameters<Frame["getByText"]>[0], options?: Parameters<Frame["getByText"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given label.
+       *
+       * @see {@link Frame.getByLabel}
+       * @since 0.1.3
+       */
+  readonly getByLabel: (label: Parameters<Frame["getByLabel"]>[0], options?: Parameters<Frame["getByLabel"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given test id.
+       *
+       * @see {@link Frame.getByTestId}
+       * @since 0.1.3
+       */
+  readonly getByTestId: (testId: Parameters<Frame["getByTestId"]>[0]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns the current URL of the frame.
+       *
+       * @see {@link Frame.url}
+       * @since 0.1.3
+       */
+  readonly url: Effect.Effect<string, PlaywrightError>;
+  /**
+       * Returns the full HTML contents of the frame, including the doctype.
+       *
+       * @see {@link Frame.content}
+       * @since 0.1.3
+       */
+  readonly content: Effect.Effect<string, PlaywrightError>;
+  /**
+       * Returns the frame name.
+       *
+       * @see {@link Frame.name}
+       * @since 0.1.3
+       */
+  readonly name: Effect.Effect<string>;
+  /**
+       * Clicks an element matching the given selector.
+       *
+       * @deprecated Use {@link PlaywrightFrameService.locator} to create a locator and then call `click` on it instead.
+       * @see {@link Frame.click}
+       * @since 0.1.3
+       * @category deprecated
+       */
+  readonly click: (selector: string, options?: Parameters<Frame["click"]>[1]) => Effect.Effect<void, PlaywrightError>;
+}
+declare const PlaywrightFrame_base: Context.TagClass<PlaywrightFrame, "effect-playwright/PlaywrightFrame", PlaywrightFrameService>;
+/**
+ * @category tag
+ * @since 0.1.2
+ */
+declare class PlaywrightFrame extends PlaywrightFrame_base {
+  /**
+       * Creates a `PlaywrightFrame` from a Playwright `Frame` instance.
+       *
+       * @param frame - The Playwright `Frame` instance to wrap.
+       * @since 0.1.2
+       */
+  static make(frame: Frame): PlaywrightFrameService;
+}
+//#endregion
+//#region src/common.d.ts
+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";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightRequest extends PlaywrightRequest_base<{
+  allHeaders: Effect.Effect<Awaited<ReturnType<Request["allHeaders"]>>, PlaywrightError>;
+  failure: () => Option.Option<NonNullable<ReturnType<Request["failure"]>>>;
+  frame: Effect.Effect<PlaywrightFrameService>;
+  headerValue: (name: string) => Effect.Effect<Option.Option<string>, PlaywrightError>;
+  headers: Effect.Effect<ReturnType<Request["headers"]>>;
+  headersArray: Effect.Effect<Awaited<ReturnType<Request["headersArray"]>>, PlaywrightError>;
+  isNavigationRequest: Effect.Effect<boolean>;
+  method: Effect.Effect<string>;
+  postData: () => Option.Option<string>;
+  postDataBuffer: () => Option.Option<NonNullable<ReturnType<Request["postDataBuffer"]>>>;
+  postDataJSON: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Request["postDataJSON"]>>>>, PlaywrightError>;
+  redirectedFrom: () => Option.Option<PlaywrightRequest>;
+  redirectedTo: () => Option.Option<PlaywrightRequest>;
+  resourceType: Effect.Effect<ReturnType<Request["resourceType"]>>;
+  response: Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
+  serviceWorker: () => Option.Option<PlaywrightWorker>;
+  sizes: Effect.Effect<Awaited<ReturnType<Request["sizes"]>>, PlaywrightError>;
+  timing: Effect.Effect<ReturnType<Request["timing"]>>;
+  url: Effect.Effect<string>;
+}> {
+  static make(request: Request): PlaywrightRequest;
+}
+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";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightResponse extends PlaywrightResponse_base<{
+  allHeaders: Effect.Effect<Awaited<ReturnType<Response["allHeaders"]>>, PlaywrightError>;
+  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"]>>;
+  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>;
+  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>;
+  text: Effect.Effect<Awaited<ReturnType<Response["text"]>>, PlaywrightError>;
+  url: Effect.Effect<string>;
+}> {
+  static make(response: Response): PlaywrightResponse;
+}
+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";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightWorker extends PlaywrightWorker_base<{
+  evaluate: <R, Arg = void>(pageFunction: PageFunction<Arg, R>, arg?: Arg) => Effect.Effect<R, PlaywrightError>;
+  url: Effect.Effect<string>;
+}> {
+  static make(worker: Worker): PlaywrightWorker;
+}
+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";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightDialog extends PlaywrightDialog_base<{
+  accept: (promptText?: string) => Effect.Effect<void, PlaywrightError>;
+  defaultValue: Effect.Effect<string>;
+  dismiss: Effect.Effect<void, PlaywrightError>;
+  message: Effect.Effect<string>;
+  page: () => Option.Option<PlaywrightPageService>;
+  type: Effect.Effect<string>;
+}> {
+  static make(dialog: Dialog): PlaywrightDialog;
+}
+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";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightFileChooser extends PlaywrightFileChooser_base<{
+  element: () => ElementHandle;
+  isMultiple: Effect.Effect<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_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Readonly<A> & {
+  readonly _tag: "PlaywrightDownload";
+};
+/**
+ * @category model
+ * @since 0.1.2
+ */
+declare class PlaywrightDownload extends PlaywrightDownload_base<{
+  cancel: Effect.Effect<void, PlaywrightError>;
+  /**
+       * Creates a stream of the download data.
+       * @category custom
+       * @since 0.2.0
+       */
+  stream: Stream.Stream<Uint8Array, PlaywrightError>;
+  delete: Effect.Effect<void, PlaywrightError>;
+  failure: Effect.Effect<Option.Option<string | null>, PlaywrightError>;
+  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>;
+  use: <R>(f: (download: Download) => Promise<R>) => Effect.Effect<R, PlaywrightError>;
+}> {
+  static make(download: Download): PlaywrightDownload;
+}
+//#endregion
+//#region src/page.d.ts
+interface PageEvents {
+  close: Page;
+  console: ConsoleMessage;
+  crash: Page;
+  dialog: Dialog;
+  domcontentloaded: Page;
+  download: Download;
+  filechooser: FileChooser;
+  frameattached: Frame;
+  framedetached: Frame;
+  framenavigated: Frame;
+  load: Page;
+  pageerror: Error;
+  popup: Page;
+  request: Request;
+  requestfailed: Request;
+  requestfinished: Request;
+  response: Response;
+  websocket: WebSocket;
+  worker: Worker;
+}
+declare const eventMappings$2: {
+  readonly close: (page: Page) => PlaywrightPageService;
+  readonly console: (a: ConsoleMessage) => ConsoleMessage;
+  readonly crash: (page: Page) => PlaywrightPageService;
+  readonly dialog: (dialog: Dialog) => PlaywrightDialog;
+  readonly domcontentloaded: (page: Page) => PlaywrightPageService;
+  readonly download: (download: Download) => PlaywrightDownload;
+  readonly filechooser: (fileChooser: FileChooser) => PlaywrightFileChooser;
+  readonly frameattached: (frame: Frame) => PlaywrightFrameService;
+  readonly framedetached: (frame: Frame) => PlaywrightFrameService;
+  readonly framenavigated: (frame: Frame) => PlaywrightFrameService;
+  readonly load: (page: Page) => PlaywrightPageService;
+  readonly pageerror: (a: Error) => Error;
+  readonly popup: (page: Page) => PlaywrightPageService;
+  readonly request: (request: Request) => PlaywrightRequest;
+  readonly requestfailed: (request: Request) => PlaywrightRequest;
+  readonly requestfinished: (request: Request) => PlaywrightRequest;
+  readonly response: (response: Response) => PlaywrightResponse;
+  readonly websocket: (a: WebSocket) => WebSocket;
+  readonly worker: (worker: Worker) => PlaywrightWorker;
+};
+type PageWithPatchedEvents = PatchedEvents<Page, PageEvents>;
+/**
+ * @category model
+ * @since 0.1.0
+ */
+interface PlaywrightPageService {
+  /**
+       * Navigates the page to the given URL.
+       *
+       * @example
+       * ```ts
+       * yield* page.goto("https://google.com");
+       * ```
+       *
+       * @see {@link Page.goto}
+       * @since 0.1.0
+       */
+  readonly goto: (url: string, options?: Parameters<Page["goto"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Waits for the page to navigate to the given URL.
+       *
+       * @example
+       * ```ts
+       * yield* page.waitForURL("https://google.com");
+       * ```
+       *
+       * @see {@link Page.waitForURL}
+       * @since 0.1.0
+       */
+  readonly waitForURL: (url: Parameters<Page["waitForURL"]>[0], options?: Parameters<Page["waitForURL"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Waits for the page to reach the given load state.
+       *
+       * NOTE: Most of the time, this method is not needed because Playwright auto-waits before every action.
+       *
+       * @example
+       * ```ts
+       * yield* page.waitForLoadState("domcontentloaded");
+       * ```
+       *
+       * @see {@link Page.waitForLoadState}
+       * @since 0.2.0
+       */
+  readonly waitForLoadState: (state?: Parameters<Page["waitForLoadState"]>[0], options?: Parameters<Page["waitForLoadState"]>[1]) => Effect.Effect<void, PlaywrightError>;
+  /**
+       * Evaluates a function in the context of the page.
+       *
+       * @example
+       * ```ts
+       * const dimensions = yield* page.evaluate(() => ({
+       *   width: document.documentElement.clientWidth,
+       *   height: document.documentElement.clientHeight
+       * }));
+       * ```
+       *
+       * @see {@link Page.evaluate}
+       * @since 0.1.0
+       */
+  readonly evaluate: <R, Arg = void>(pageFunction: PageFunction<Arg, R>, arg?: Arg) => Effect.Effect<R, PlaywrightError>;
+  /**
+       * Returns the page title.
+       *
+       * @example
+       * ```ts
+       * const title = yield* page.title;
+       * ```
+       *
+       * @see {@link Page.title}
+       * @since 0.1.0
+       */
+  readonly title: 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.
+       *
+       * @example
+       * ```ts
+       * const title = yield* page.use((p) => p.title());
+       * ```
+       *
+       * @see {@link Page}
+       * @since 0.1.0
+       */
+  readonly use: <T>(f: (page: Page) => Promise<T>) => Effect.Effect<T, PlaywrightError>;
+  /**
+       * Returns a locator for the given selector.
+       *
+       * @see {@link Page.locator}
+       * @since 0.1.0
+       */
+  readonly locator: (selector: string, options?: Parameters<Page["locator"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given role.
+       *
+       * @see {@link Page.getByRole}
+       * @since 0.1.0
+       */
+  readonly getByRole: (role: Parameters<Page["getByRole"]>[0], options?: Parameters<Page["getByRole"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given text.
+       *
+       * @see {@link Page.getByText}
+       * @since 0.1.0
+       */
+  readonly getByText: (text: Parameters<Page["getByText"]>[0], options?: Parameters<Page["getByText"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given label.
+       *
+       * @see {@link Page.getByLabel}
+       * @since 0.1.0
+       */
+  readonly getByLabel: (label: Parameters<Page["getByLabel"]>[0], options?: Parameters<Page["getByLabel"]>[1]) => typeof PlaywrightLocator.Service;
+  /**
+       * Returns a locator that matches the given test id.
+       *
+       * @see {@link Page.getByTestId}
+       * @since 0.1.0
+       */
+  readonly getByTestId: (testId: Parameters<Page["getByTestId"]>[0]) => typeof PlaywrightLocator.Service;
+  /**
+       * Reloads the page.
+       *
+       * @see {@link Page.reload}
+       * @since 0.1.0
+       */
+  readonly reload: Effect.Effect<void, PlaywrightError>;
+  /**
+       * Closes the page.
+       *
+       * @see {@link Page.close}
+       * @since 0.1.0
+       */
+  readonly close: Effect.Effect<void, PlaywrightError>;
+  /**
+       * Returns the current URL of the page.
+       *
+       * @example
+       * ```ts
+       * const url = yield* page.url;
+       * ```
+       *
+       * @see {@link Page.url}
+       * @since 0.1.0
+       */
+  readonly url: Effect.Effect<string, PlaywrightError>;
+  /**
+       * Returns all frames attached to the page.
+       *
+       * @see {@link Page.frames}
+       * @since 0.2.0
+       */
+  readonly frames: Effect.Effect<ReadonlyArray<typeof PlaywrightFrame.Service>, PlaywrightError>;
+  /**
+       * Creates a stream of the given event from the page.
+       *
+       * @example
+       * ```ts
+       * const consoleStream = page.eventStream("console");
+       * ```
+       *
+       * @category custom
+       * @see {@link Page.on}
+       * @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>;
+/**
+ * @category tag
+ */
+declare class PlaywrightPage extends PlaywrightPage_base {
+  /**
+       * Creates a `PlaywrightPage` from a Playwright `Page` instance.
+       *
+       * @param page - The Playwright `Page` instance to wrap.
+       * @since 0.1.0
+       */
+  static make(page: PageWithPatchedEvents): PlaywrightPageService;
+}
+//#endregion
+//#region src/browser-context.d.ts
+interface BrowserContextEvents {
+  backgroundpage: Page;
+  close: BrowserContext;
+  console: ConsoleMessage;
+  dialog: Dialog;
+  page: Page;
+  request: Request;
+  requestfailed: Request;
+  requestfinished: Request;
+  response: Response;
+  serviceworker: Worker;
+  weberror: WebError;
+}
+declare const eventMappings$1: {
+  readonly backgroundpage: (page: Page) => PlaywrightPageService;
+  readonly close: (context: BrowserContext) => PlaywrightBrowserContextService;
+  readonly console: (a: ConsoleMessage) => ConsoleMessage;
+  readonly dialog: (dialog: Dialog) => PlaywrightDialog;
+  readonly page: (page: Page) => PlaywrightPageService;
+  readonly request: (request: Request) => PlaywrightRequest;
+  readonly requestfailed: (request: Request) => PlaywrightRequest;
+  readonly requestfinished: (request: Request) => PlaywrightRequest;
+  readonly response: (response: Response) => PlaywrightResponse;
+  readonly serviceworker: (worker: Worker) => PlaywrightWorker;
+  readonly weberror: (a: WebError) => WebError;
+};
+type BrowserContextWithPatchedEvents = PatchedEvents<BrowserContext, BrowserContextEvents>;
+/**
+ * @category model
+ * @since 0.1.0
+ */
+interface PlaywrightBrowserContextService {
+  /**
+       * Returns the list of all open pages in the browser context.
+       *
+       * @see {@link BrowserContext.pages}
+       * @since 0.1.0
+       */
+  readonly pages: Effect.Effect<Array<typeof PlaywrightPage.Service>>;
+  /**
+       * Opens a new page in the browser context.
+       *
+       * @example
+       * ```ts
+       * const page = yield* context.newPage;
+       * ```
+       *
+       * @see {@link BrowserContext.newPage}
+       * @since 0.1.0
+       */
+  readonly newPage: Effect.Effect<typeof PlaywrightPage.Service, PlaywrightError>;
+  /**
+       * Closes the browser context.
+       *
+       * @see {@link BrowserContext.close}
+       * @since 0.1.0
+       */
+  readonly close: Effect.Effect<void, PlaywrightError>;
+  /**
+       * Creates a stream of the given event from the browser context.
+       *
+       * @example
+       * ```ts
+       * const pageStream = context.eventStream("page");
+       * ```
+       *
+       * @category custom
+       * @see {@link BrowserContext.on}
+       * @since 0.1.2
+       */
+  readonly eventStream: <K extends keyof typeof eventMappings$1>(event: K) => Stream.Stream<ReturnType<(typeof eventMappings$1)[K]>>;
+}
+declare const PlaywrightBrowserContext_base: Context.TagClass<PlaywrightBrowserContext, "effect-playwright/PlaywrightBrowserContext", PlaywrightBrowserContextService>;
+/**
+ * @category tag
+ */
+declare class PlaywrightBrowserContext extends PlaywrightBrowserContext_base {
+  /**
+       * Creates a `PlaywrightBrowserContext` from a Playwright `BrowserContext` instance.
+       *
+       * @param context - The Playwright `BrowserContext` instance to wrap.
+       * @since 0.1.0
+       */
+  static make(context: BrowserContextWithPatchedEvents): PlaywrightBrowserContextService;
+}
+//#endregion
+//#region src/browser.d.ts
+type LaunchOptions$1 = Parameters<typeof chromium.launch>[0];
+type NewPageOptions = Parameters<Browser["newPage"]>[0];
+type NewContextOptions = Parameters<Browser["newContext"]>[0];
+interface BrowserEvents {
+  disconnected: Browser;
+}
+declare const eventMappings: {
+  readonly disconnected: (browser: Browser) => PlaywrightBrowserService;
+};
+type BrowserWithPatchedEvents = PatchedEvents<Browser, BrowserEvents>;
+/**
+ * @category model
+ * @since 0.1.0
+ */
+interface PlaywrightBrowserService {
+  /**
+       * Opens a new page in the browser.
+       *
+       * @example
+       * ```typescript
+       * const page = yield* browser.newPage();
+       * ```
+       *
+       * @param options - Optional options for creating the new page.
+       * @returns An effect that resolves to a `PlaywrightPage` service.
+       * @see {@link Browser.newPage}
+       */
+  readonly newPage: (options?: NewPageOptions) => Effect.Effect<typeof PlaywrightPage.Service, PlaywrightError>;
+  /**
+       * A generic utility to execute any promise-based method on the underlying Playwright `Browser`.
+       * Can be used to access any Browser functionality not directly exposed by this service.
+       *
+       * @example
+       * ```typescript
+       * const contexts = yield* browser.use((b) => b.contexts());
+       * ```
+       *
+       * @param f - A function that takes the Playwright `Browser` and returns a `Promise`.
+       * @returns An effect that wraps the promise and returns its result.
+       * @see {@link Browser}
+       */
+  readonly use: <T>(f: (browser: Browser) => Promise<T>) => Effect.Effect<T, PlaywrightError>;
+  /**
+       * An Effect that closes the browser and all of its pages.
+       * @see {@link Browser.close}
+       */
+  readonly close: Effect.Effect<void, PlaywrightError>;
+  /**
+       * An Effect that returns the list of all open browser contexts.
+       * @see {@link Browser.contexts}
+       */
+  readonly contexts: Effect.Effect<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>;
+  /**
+       * An Effect that returns the version of the browser.
+       * @see {@link Browser.version}
+       */
+  readonly version: Effect.Effect<string>;
+  /**
+       * An Effect that returns whether the browser is connected.
+       * @see {@link Browser.isConnected}
+       */
+  readonly isConnected: Effect.Effect<boolean>;
+  /**
+       * Creates a stream of the given event from the browser.
+       *
+       * @example
+       * ```ts
+       * const disconnectedStream = browser.eventStream("disconnected");
+       * ```
+       *
+       * @category custom
+       * @see {@link Browser.on}
+       * @since 0.1.2
+       */
+  readonly eventStream: <K extends keyof typeof eventMappings>(event: K) => Stream.Stream<ReturnType<(typeof eventMappings)[K]>>;
+}
+declare const PlaywrightBrowser_base: Context.TagClass<PlaywrightBrowser, "effect-playwright/PlaywrightBrowser", PlaywrightBrowserService>;
+/**
+ * @category tag
+ */
+declare class PlaywrightBrowser extends PlaywrightBrowser_base {
+  /**
+       * @category constructor
+       */
+  static make(browser: BrowserWithPatchedEvents): PlaywrightBrowserService;
+}
+//#endregion
+//#region src/playwright.d.ts
+/**
+ * @category model
+ * @since 0.1.0
+ */
+interface PlaywrightService {
+  /**
+       * Launches a new browser instance.
+       *
+       * It is the caller's responsibility to manage the browser's lifecycle and close
+       * it when no longer needed. For automatic scope-based management, use
+       * {@link launchScoped} instead.
+       *
+       * ```ts
+       * import { Effect } from "effect";
+       * import { Playwright } from "effect-playwright";
+       * import { chromium } from "playwright-core";
+       *
+       * const program = Effect.gen(function* () {
+       *   const browser = yield* Playwright.launch(chromium);
+       *   // ... use browser ...
+       *   yield* browser.close;
+       * });
+       *
+       * await Effect.runPromise(program);
+       * ```
+       *
+       * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+       * @param options - Optional launch options.
+       * @since 0.1.0
+       */
+  launch: (browserType: BrowserType, options?: LaunchOptions$1) => Effect.Effect<typeof PlaywrightBrowser.Service, PlaywrightError>;
+  /**
+       * Launches a new browser instance managed by a Scope.
+       *
+       * This method automatically closes the browser 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 browser = yield* Playwright.launchScoped(chromium);
+       *   // Browser will be closed automatically when scope closes
+       * });
+       *
+       * await Effect.runPromise(program);
+       * ```
+       *
+       * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+       * @param options - Optional launch options.
+       * @since 0.1.0
+       */
+  launchScoped: (browserType: BrowserType, options?: LaunchOptions$1) => Effect.Effect<typeof PlaywrightBrowser.Service, PlaywrightError, Scope.Scope>;
+  /**
+       * Connects to a browser instance via Chrome DevTools Protocol (CDP).
+       *
+       * Unlike {@link connectCDPScoped}, this method does **not** close the connection when the
+       * scope is closed. It is the caller's responsibility to manage the connection's
+       * lifecycle.
+       *
+       * If you want to close the connection using a scope simply add a finalizer:
+       *
+       * ```ts
+       * import { Effect } from "effect";
+       * import { Playwright } from "effect-playwright";
+       *
+       * const program = Effect.gen(function* () {
+       *   const playwright = yield* Playwright;
+       *   const browser = yield* playwright.connectCDP(cdpUrl);
+       *   yield* Effect.addFinalizer(() => browser.close.pipe(Effect.ignore));
+       * });
+       *
+       * await Effect.runPromise(program);
+       * ```
+       *
+       * @param cdpUrl - The CDP URL to connect to.
+       * @param options - Optional options for connecting to the CDP URL.
+       * @since 0.1.0
+       */
+  connectCDP: (cdpUrl: string, options?: ConnectOverCDPOptions) => Effect.Effect<typeof PlaywrightBrowser.Service, PlaywrightError>;
+  /**
+       * Connects to a browser instance via Chrome DevTools Protocol (CDP) managed by a Scope.
+       *
+       * This method automatically closes the connection when the scope is closed.
+       *
+       * Note that closing a CDP connection does **not** close the browser instance itself,
+       * only the CDP connection.
+       *
+       * ```ts
+       * import { Effect } from "effect";
+       * import { Playwright } from "effect-playwright";
+       *
+       * const program = Effect.gen(function* () {
+       *   const playwright = yield* Playwright;
+       *   const browser = yield* playwright.connectCDPScoped(cdpUrl);
+       *   // Connection will be closed automatically when scope closes
+       * });
+       *
+       * await Effect.runPromise(program);
+       * ```
+       *
+       * @param cdpUrl - The CDP URL to connect to.
+       * @param options - Optional options for connecting to the CDP URL.
+       * @since 0.1.1
+       */
+  connectCDPScoped: (cdpUrl: string, options?: ConnectOverCDPOptions) => Effect.Effect<typeof PlaywrightBrowser.Service, PlaywrightError, Scope.Scope>;
+}
+declare const Playwright_base: Context.TagClass<Playwright, "effect-playwright/index/Playwright", PlaywrightService>;
+/**
+ * @category tag
+ * @since 0.1.0
+ */
+declare class Playwright extends Playwright_base {
+  /**
+       * @category layer
+       */
+  static readonly layer: Layer.Layer<Playwright, never, never>;
+}
+//#endregion
+export { PlaywrightErrorReason as S, PlaywrightWorker as _, NewPageOptions as a, PlaywrightLocatorService 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, PlaywrightFrameService as v, PlaywrightError as x, PlaywrightLocator as y };