effect-playwright 0.1.0 → 0.1.1

package/README.md

@@ -1,10 +1,14 @@
 # effect-playwright
 
+[![NPM Version](https://img.shields.io/npm/v/effect-playwright)](https://www.npmjs.com/package/effect-playwright)
 [![GitHub License](https://img.shields.io/github/license/Jobflow-io/effect-playwright)](https://github.com/Jobflow-io/effect-playwright/blob/main/LICENSE)
 [![Effect: yes](https://img.shields.io/badge/effect-yes-blue)](https://effect.website/)
 
 A Playwright wrapper for the Effect ecosystem. This library provides a set of services and layers to interact with Playwright in a type-safe way using Effect.
 
+> [!NOTE]
+> This library is currently focused on using Playwright for **automation** and **scraping**. It does not provide a wrapper for `@playwright/test` (the test runner).
+
 ## Installation
 
 ```bash
@@ -17,6 +21,8 @@ or
 npm install effect-playwright playwright-core
 ```
 
+You can also install `playwright` instead of `playwright-core` if you want the post-build auto install of the browsers.
+
 ## Quick Start
 
 ```ts
@@ -49,6 +55,36 @@ const program = Effect.gen(function* () {
 }).pipe(Effect.scoped);
 ```
 
+## Connecting via CDP
+
+You can connect to an existing browser instance using the Chrome DevTools Protocol (CDP).
+
+```ts
+const program = Effect.gen(function* () {
+  const playwright = yield* Playwright;
+
+  // Use connectCDPScoped to automatically close the CONNECTION when the scope ends
+  // Note: This does NOT close the browser process itself, only the CDP connection.
+  const browser = yield* playwright.connectCDPScoped("http://localhost:9222");
+
+  const page = yield* browser.newPage();
+  // ...
+}).pipe(Effect.scoped);
+```
+
+If you need to manage the connection lifecycle manually, use `connectCDP`:
+
+```ts
+const program = Effect.gen(function* () {
+  const playwright = yield* Playwright;
+  const browser = yield* playwright.connectCDP("http://localhost:9222");
+
+  // ... use browser ...
+
+  yield* browser.close;
+});
+```
+
 ## PlaywrightEnvironment (Experimental)
 
 The `PlaywrightEnvironment` simplifies setup by allowing you to configure the browser type and launch options once and reuse them across your application.
@@ -75,6 +111,20 @@ const program = Effect.gen(function* () {
 await Effect.runPromise(program.pipe(Effect.provide(liveLayer)));
 ```
 
+### `PlaywrightEnvironment.withBrowser`
+
+The `withBrowser` utility provides the `PlaywrightBrowser` service to your effect. It internally manages a `Scope`, which means the browser will be launched when the effect starts and closed automatically when the effect finishes (including on failure or interruption).
+
+```ts
+const program = Effect.gen(function* () {
+  const browser = yield* PlaywrightBrowser; // Now available in context
+  const page = yield* browser.newPage();
+
+  // ...
+  // Browser close is ensured
+}).pipe(PlaywrightEnvironment.withBrowser);
+```
+
 ## Accessing Native Playwright
 
 If you need to access functionality from the underlying Playwright objects that isn't directly exposed, you can use the `use` method available on most services/objects (browsers, pages, locators).

package/dist/experimental/index.d.mts

@@ -1,4 +1,4 @@
-import { d as PlaywrightError, o as PlaywrightBrowser } from "../index-aR0Fa_4Y.mjs";
+import { d as PlaywrightError, o as PlaywrightBrowser } from "../index-DnbVDccF.mjs";
 import { Context, Effect, Layer } from "effect";
 import { BrowserType, LaunchOptions } from "playwright-core";
 import { Scope as Scope$1 } from "effect/Scope";
@@ -35,10 +35,11 @@ declare class PlaywrightEnvironment extends PlaywrightEnvironment_base {}
  *
  * // use the layer
  * const program = Effect.gen(function* () {
- *   const browser = yield* PlaywrightEnvironment.browser;
+ *   const playwright = yield* PlaywrightEnvironment;
+ *   const browser = yield* playwright.browser;
  *   const page = yield* browser.newPage();
  *   yield* page.goto("https://example.com");
- * }).pipe(PlaywrightEnvironment.withBrowser, Effect.provide(playwrightEnv));
+ * }).pipe(Effect.scoped, Effect.provide(playwrightEnv));
  * ```
  *
  * @param browser - The Playwright BrowserType implementation (e.g. `chromium`, `firefox`, `webkit`).
@@ -59,12 +60,13 @@ declare const layer: (browser: BrowserType, launchOptions?: LaunchOptions) => La
  * import { PlaywrightEnvironment } from "effect-playwright/experimental";
  * import { chromium } from "playwright-core";
  *
- * const layer = PlaywrightEnvironment.layer(chromium);
+ * const env = PlaywrightEnvironment.layer(chromium);
+ *
  * const program = Effect.gen(function* () {
  *     const browser = yield* PlaywrightBrowser;
  *     const page = yield* browser.newPage();
  *     yield* page.goto("https://example.com");
- * }).pipe(PlaywrightEnvironment.withBrowser);
+ * }).pipe(PlaywrightEnvironment.withBrowser, Effect.provide(env));
  * ```
  *
  * @since 0.1.0

package/dist/experimental/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../chunk-BiucMVzj.mjs";
-import { n as PlaywrightBrowser, t as Playwright } from "../src-DveiwW4g.mjs";
+import { n as PlaywrightBrowser, t as Playwright } from "../src-BGGNNney.mjs";
 import { Context, Effect, Layer } from "effect";
 
 //#region src/experimental/environment.ts
@@ -33,10 +33,11 @@ var PlaywrightEnvironment = class extends Context.Tag("effect-playwright/experim
 *
 * // use the layer
 * const program = Effect.gen(function* () {
-*   const browser = yield* PlaywrightEnvironment.browser;
+*   const playwright = yield* PlaywrightEnvironment;
+*   const browser = yield* playwright.browser;
 *   const page = yield* browser.newPage();
 *   yield* page.goto("https://example.com");
-* }).pipe(PlaywrightEnvironment.withBrowser, Effect.provide(playwrightEnv));
+* }).pipe(Effect.scoped, Effect.provide(playwrightEnv));
 * ```
 *
 * @param browser - The Playwright BrowserType implementation (e.g. `chromium`, `firefox`, `webkit`).
@@ -61,12 +62,13 @@ const layer = (browser, launchOptions) => {
 * import { PlaywrightEnvironment } from "effect-playwright/experimental";
 * import { chromium } from "playwright-core";
 *
-* const layer = PlaywrightEnvironment.layer(chromium);
+* const env = PlaywrightEnvironment.layer(chromium);
+*
 * const program = Effect.gen(function* () {
 *     const browser = yield* PlaywrightBrowser;
 *     const page = yield* browser.newPage();
 *     yield* page.goto("https://example.com");
-* }).pipe(PlaywrightEnvironment.withBrowser);
+* }).pipe(PlaywrightEnvironment.withBrowser, Effect.provide(env));
 * ```
 *
 * @since 0.1.0

package/dist/{index-aR0Fa_4Y.d.mts → index-DnbVDccF.d.mts}

@@ -1,5 +1,5 @@
-import { Context, Effect, Layer, Scope, Stream } from "effect";
-import { Browser, BrowserContext, BrowserType, ConnectOverCDPOptions, ConsoleMessage, Dialog, Download, ElementHandle, FileChooser, Frame, JSHandle, Locator, Page, Request, Response, WebSocket, Worker, chromium } from "playwright-core";
+import { Context, Effect, Layer, Option, Scope, Stream } from "effect";
+import { Browser, BrowserContext, BrowserType, ConnectOverCDPOptions, ConsoleMessage, Dialog, Download, ElementHandle, FileChooser, Frame, JSHandle, Locator, Page, Request as Request$1, Response as Response$1, WebSocket, Worker as Worker$1, 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";
@@ -23,6 +23,117 @@ type NoHandles<Arg> = Arg extends JSHandle ? never : Arg extends object ? { [Key
 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>);
 //#endregion
+//#region src/common.d.ts
+declare const PlaywrightFrame_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: "PlaywrightFrame";
+};
+declare class PlaywrightFrame extends PlaywrightFrame_base<{
+  use: <A>(f: (frame: Frame) => Promise<A>) => Effect.Effect<A, PlaywrightError>;
+}> {
+  static make(frame: Frame): PlaywrightFrame;
+}
+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";
+};
+declare class PlaywrightRequest extends PlaywrightRequest_base<{
+  allHeaders: Effect.Effect<Awaited<ReturnType<Request$1["allHeaders"]>>, PlaywrightError>;
+  failure: () => Option.Option<NonNullable<ReturnType<Request$1["failure"]>>>;
+  frame: Effect.Effect<PlaywrightFrame>;
+  headerValue: (name: string) => Effect.Effect<Option.Option<string>, PlaywrightError>;
+  headers: Effect.Effect<ReturnType<Request$1["headers"]>>;
+  headersArray: Effect.Effect<Awaited<ReturnType<Request$1["headersArray"]>>, PlaywrightError>;
+  isNavigationRequest: Effect.Effect<boolean>;
+  method: Effect.Effect<string>;
+  postData: () => Option.Option<string>;
+  postDataBuffer: () => Option.Option<NonNullable<ReturnType<Request$1["postDataBuffer"]>>>;
+  postDataJSON: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Request$1["postDataJSON"]>>>>, PlaywrightError>;
+  redirectedFrom: () => Option.Option<PlaywrightRequest>;
+  redirectedTo: () => Option.Option<PlaywrightRequest>;
+  resourceType: Effect.Effect<ReturnType<Request$1["resourceType"]>>;
+  response: Effect.Effect<Option.Option<PlaywrightResponse>, PlaywrightError>;
+  serviceWorker: () => Option.Option<PlaywrightWorker>;
+  sizes: Effect.Effect<Awaited<ReturnType<Request$1["sizes"]>>, PlaywrightError>;
+  timing: Effect.Effect<ReturnType<Request$1["timing"]>>;
+  url: Effect.Effect<string>;
+}> {
+  static make(request: Request$1): 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";
+};
+declare class PlaywrightResponse extends PlaywrightResponse_base<{
+  allHeaders: Effect.Effect<Awaited<ReturnType<Response$1["allHeaders"]>>, PlaywrightError>;
+  body: Effect.Effect<Awaited<ReturnType<Response$1["body"]>>, PlaywrightError>;
+  finished: Effect.Effect<Awaited<ReturnType<Response$1["finished"]>>, PlaywrightError>;
+  frame: Effect.Effect<PlaywrightFrame>;
+  fromServiceWorker: Effect.Effect<boolean>;
+  headers: Effect.Effect<ReturnType<Response$1["headers"]>>;
+  headersArray: Effect.Effect<Awaited<ReturnType<Response$1["headersArray"]>>, PlaywrightError>;
+  headerValue: (name: string) => Effect.Effect<Option.Option<string>, PlaywrightError>;
+  headerValues: (name: string) => Effect.Effect<Awaited<ReturnType<Response$1["headerValues"]>>, PlaywrightError>;
+  json: Effect.Effect<Awaited<ReturnType<Response$1["json"]>>, PlaywrightError>;
+  ok: Effect.Effect<boolean>;
+  request: () => PlaywrightRequest;
+  securityDetails: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Response$1["securityDetails"]>>>>, PlaywrightError>;
+  serverAddr: Effect.Effect<Option.Option<NonNullable<Awaited<ReturnType<Response$1["serverAddr"]>>>>, PlaywrightError>;
+  status: Effect.Effect<number>;
+  statusText: Effect.Effect<string>;
+  text: Effect.Effect<Awaited<ReturnType<Response$1["text"]>>, PlaywrightError>;
+  url: Effect.Effect<string>;
+}> {
+  static make(response: Response$1): 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";
+};
+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$1): 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";
+};
+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";
+};
+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";
+};
+declare class PlaywrightDownload extends PlaywrightDownload_base<{
+  cancel: Effect.Effect<void, PlaywrightError>;
+  createReadStream: 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/locator.d.ts
 /**
  * Interface for a Playwright locator.
@@ -171,27 +282,6 @@ declare class PlaywrightLocator extends PlaywrightLocator_base {
 }
 //#endregion
 //#region src/page.d.ts
-interface PlaywrightPageEvents {
-  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;
-}
 interface PlaywrightPageService {
   /**
    * Navigates the page to the given URL.
@@ -329,7 +419,7 @@ interface PlaywrightPageService {
    * @see {@link Page.on}
    * @since 0.1.0
    */
-  readonly eventStream: <K extends keyof PlaywrightPageEvents>(event: K) => Stream.Stream<PlaywrightPageEvents[K]>;
+  readonly eventStream: <K extends keyof typeof eventMappings>(event: K) => Stream.Stream<ReturnType<(typeof eventMappings)[K]>>;
   /**
    * Clicks an element matching the given selector.
    *
@@ -355,7 +445,60 @@ declare class PlaywrightPage extends PlaywrightPage_base {
    * @param page - The Playwright `Page` instance to wrap.
    * @since 0.1.0
    */
-  static make(page: Page): PlaywrightPageService;
+  static make(page: PageWithPatchedEvents): PlaywrightPageService;
+}
+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;
+}
+type PageEvent = keyof PageEvents;
+declare const eventMappings: {
+  readonly close: typeof PlaywrightPage.make;
+  readonly console: (a: ConsoleMessage) => ConsoleMessage;
+  readonly crash: typeof PlaywrightPage.make;
+  readonly dialog: typeof PlaywrightDialog.make;
+  readonly domcontentloaded: typeof PlaywrightPage.make;
+  readonly download: typeof PlaywrightDownload.make;
+  readonly filechooser: typeof PlaywrightFileChooser.make;
+  readonly frameattached: typeof PlaywrightFrame.make;
+  readonly framedetached: typeof PlaywrightFrame.make;
+  readonly framenavigated: typeof PlaywrightFrame.make;
+  readonly load: typeof PlaywrightPage.make;
+  readonly pageerror: (a: Error) => Error;
+  readonly popup: typeof PlaywrightPage.make;
+  readonly request: typeof PlaywrightRequest.make;
+  readonly requestfailed: typeof PlaywrightRequest.make;
+  readonly requestfinished: typeof PlaywrightRequest.make;
+  readonly response: typeof PlaywrightResponse.make;
+  readonly websocket: (a: WebSocket) => WebSocket;
+  readonly worker: typeof PlaywrightWorker.make;
+};
+/**
+ * Page interface with generic on/off methods.
+ * Playwright's Page uses overloads for on/off, making generic event handling impossible.
+ * This interface provides a unified signature for our event map.
+ * @internal
+ */
+interface PageWithPatchedEvents extends Page {
+  on<K extends PageEvent>(event: K, listener: (arg: PageEvents[K]) => void): this;
+  off<K extends PageEvent>(event: K, listener: (arg: PageEvents[K]) => void): this;
 }
 //#endregion
 //#region src/browser-context.d.ts
@@ -549,18 +692,19 @@ interface PlaywrightService {
   /**
    * Connects to a browser instance via Chrome DevTools Protocol (CDP).
    *
-   * Unlike {@link launchScoped}, this method does **not** close the browser when the
-   * scope is closed. It is the caller's responsibility to manage the browser's
+   * 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 browser using a scope simply add a finalizer:
+   * 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 browser = yield* Playwright.connectCDP(cdpUrl);
+   *   const playwright = yield* Playwright;
+   *   const browser = yield* playwright.connectCDP(cdpUrl);
    *   yield* Effect.addFinalizer(() => browser.close.pipe(Effect.ignore));
    * });
    *
@@ -572,6 +716,32 @@ interface PlaywrightService {
    * @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>;
 declare class Playwright extends Playwright_base {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { a as NewPageOptions, c as PlaywrightPageService, i as NewContextOptions, l as PlaywrightLocator, n as PlaywrightService, o as PlaywrightBrowser, r as LaunchOptions, s as PlaywrightPage, t as Playwright, u as PlaywrightLocatorService } from "./index-aR0Fa_4Y.mjs";
+import { a as NewPageOptions, c as PlaywrightPageService, i as NewContextOptions, l as PlaywrightLocator, n as PlaywrightService, o as PlaywrightBrowser, r as LaunchOptions, s as PlaywrightPage, t as Playwright, u as PlaywrightLocatorService } from "./index-DnbVDccF.mjs";
 export { LaunchOptions, NewContextOptions, NewPageOptions, Playwright, PlaywrightBrowser, PlaywrightLocator, PlaywrightLocatorService, PlaywrightPage, PlaywrightPageService, PlaywrightService };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { i as PlaywrightLocator, n as PlaywrightBrowser, r as PlaywrightPage, t as Playwright } from "./src-DveiwW4g.mjs";
+import { i as PlaywrightLocator, n as PlaywrightBrowser, r as PlaywrightPage, t as Playwright } from "./src-BGGNNney.mjs";
 
 export { Playwright, PlaywrightBrowser, PlaywrightLocator, PlaywrightPage };

package/dist/src-BGGNNney.mjs

@@ -0,0 +1,310 @@
+import { Context, Data, Effect, Layer, Option, Stream, identity } from "effect";
+import { chromium, errors } from "playwright-core";
+
+//#region src/errors.ts
+var PlaywrightError = class extends Data.TaggedError("PlaywrightError") {};
+function wrapError(error) {
+	if (error instanceof errors.TimeoutError) return new PlaywrightError({
+		reason: "Timeout",
+		cause: error
+	});
+	else return new PlaywrightError({
+		reason: "Unknown",
+		cause: error
+	});
+}
+
+//#endregion
+//#region src/utils.ts
+/** @internal */
+const useHelper = (api) => (userFunction) => Effect.tryPromise(() => userFunction(api)).pipe(Effect.mapError(wrapError));
+
+//#endregion
+//#region src/common.ts
+var PlaywrightFrame = class PlaywrightFrame extends Data.TaggedClass("PlaywrightFrame") {
+	static make(frame) {
+		return new PlaywrightFrame({ use: useHelper(frame) });
+	}
+};
+var PlaywrightRequest = class PlaywrightRequest extends Data.TaggedClass("PlaywrightRequest") {
+	static make(request) {
+		const use = useHelper(request);
+		return new PlaywrightRequest({
+			allHeaders: use(() => request.allHeaders()),
+			failure: Option.liftNullable(request.failure),
+			frame: Effect.sync(() => PlaywrightFrame.make(request.frame())),
+			headerValue: (name) => use(() => request.headerValue(name)).pipe(Effect.map(Option.fromNullable)),
+			headers: Effect.sync(() => request.headers()),
+			headersArray: use(() => request.headersArray()),
+			isNavigationRequest: Effect.sync(() => request.isNavigationRequest()),
+			method: Effect.sync(() => request.method()),
+			postData: Option.liftNullable(request.postData),
+			postDataBuffer: Option.liftNullable(request.postDataBuffer),
+			postDataJSON: use(() => request.postDataJSON()).pipe(Effect.map(Option.fromNullable)),
+			redirectedFrom: () => Option.fromNullable(request.redirectedFrom()).pipe(Option.map(PlaywrightRequest.make)),
+			redirectedTo: () => Option.fromNullable(request.redirectedTo()).pipe(Option.map(PlaywrightRequest.make)),
+			resourceType: Effect.sync(() => request.resourceType()),
+			response: use(() => request.response()).pipe(Effect.map(Option.fromNullable), Effect.map(Option.map(PlaywrightResponse.make))),
+			serviceWorker: () => Option.fromNullable(request.serviceWorker()).pipe(Option.map(PlaywrightWorker.make)),
+			sizes: use(() => request.sizes()),
+			timing: Effect.sync(() => request.timing()),
+			url: Effect.sync(() => request.url())
+		});
+	}
+};
+var PlaywrightResponse = class PlaywrightResponse extends Data.TaggedClass("PlaywrightResponse") {
+	static make(response) {
+		const use = useHelper(response);
+		return new PlaywrightResponse({
+			allHeaders: use(() => response.allHeaders()),
+			body: use(() => response.body()),
+			finished: use(() => response.finished()),
+			frame: Effect.sync(() => PlaywrightFrame.make(response.frame())),
+			fromServiceWorker: Effect.sync(() => response.fromServiceWorker()),
+			headers: Effect.sync(() => response.headers()),
+			headersArray: use(() => response.headersArray()),
+			headerValue: (name) => use(() => response.headerValue(name)).pipe(Effect.map(Option.fromNullable)),
+			headerValues: (name) => use(() => response.headerValues(name)),
+			json: use(() => response.json()),
+			ok: Effect.sync(() => response.ok()),
+			request: () => PlaywrightRequest.make(response.request()),
+			securityDetails: use(() => response.securityDetails()).pipe(Effect.map(Option.fromNullable)),
+			serverAddr: use(() => response.serverAddr()).pipe(Effect.map(Option.fromNullable)),
+			status: Effect.sync(() => response.status()),
+			statusText: Effect.sync(() => response.statusText()),
+			text: use(() => response.text()),
+			url: Effect.sync(() => response.url())
+		});
+	}
+};
+var PlaywrightWorker = class PlaywrightWorker extends Data.TaggedClass("PlaywrightWorker") {
+	static make(worker) {
+		const use = useHelper(worker);
+		return new PlaywrightWorker({
+			evaluate: (f, arg) => use((w) => w.evaluate(f, arg)),
+			url: Effect.sync(() => worker.url())
+		});
+	}
+};
+var PlaywrightDialog = class PlaywrightDialog extends Data.TaggedClass("PlaywrightDialog") {
+	static make(dialog) {
+		const use = useHelper(dialog);
+		return new PlaywrightDialog({
+			accept: (promptText) => use(() => dialog.accept(promptText)),
+			defaultValue: Effect.sync(() => dialog.defaultValue()),
+			dismiss: use(() => dialog.dismiss()),
+			message: Effect.sync(() => dialog.message()),
+			page: () => Option.fromNullable(dialog.page()).pipe(Option.map(PlaywrightPage.make)),
+			type: Effect.sync(() => dialog.type())
+		});
+	}
+};
+var PlaywrightFileChooser = class PlaywrightFileChooser extends Data.TaggedClass("PlaywrightFileChooser") {
+	static make(fileChooser) {
+		const use = useHelper(fileChooser);
+		return new PlaywrightFileChooser({
+			element: () => fileChooser.element(),
+			isMultiple: Effect.sync(() => fileChooser.isMultiple()),
+			page: () => PlaywrightPage.make(fileChooser.page()),
+			setFiles: (files, options) => use(() => fileChooser.setFiles(files, options))
+		});
+	}
+};
+var PlaywrightDownload = class PlaywrightDownload extends Data.TaggedClass("PlaywrightDownload") {
+	static make(download) {
+		const use = useHelper(download);
+		return new PlaywrightDownload({
+			cancel: use(() => download.cancel()),
+			createReadStream: Stream.empty,
+			delete: use(() => download.delete()),
+			failure: use(() => download.failure()).pipe(Effect.map(Option.fromNullable)),
+			page: () => PlaywrightPage.make(download.page()),
+			path: use(() => download.path()).pipe(Effect.map(Option.fromNullable)),
+			saveAs: (path) => use(() => download.saveAs(path)),
+			suggestedFilename: Effect.sync(() => download.suggestedFilename()),
+			url: Effect.sync(() => download.url()),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/locator.ts
+/**
+* A service that provides a `PlaywrightLocator` instance.
+*
+* @since 0.1.0
+* @category tag
+*/
+var PlaywrightLocator = class PlaywrightLocator extends Context.Tag("effect-playwright/PlaywrightLocator")() {
+	/**
+	* 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) {
+		const use = useHelper(locator);
+		return PlaywrightLocator.of({
+			click: (options) => use((l) => l.click(options)),
+			fill: (value, options) => use((l) => l.fill(value, options)),
+			getAttribute: (name, options) => use((l) => l.getAttribute(name, options)),
+			innerText: (options) => use((l) => l.innerText(options)),
+			innerHTML: (options) => use((l) => l.innerHTML(options)),
+			inputValue: (options) => use((l) => l.inputValue(options)),
+			textContent: (options) => use((l) => l.textContent(options)),
+			count: use((l) => l.count()),
+			first: () => PlaywrightLocator.make(locator.first()),
+			last: () => PlaywrightLocator.make(locator.last()),
+			nth: (index) => PlaywrightLocator.make(locator.nth(index)),
+			evaluate: (pageFunction, arg, options) => use((l) => l.evaluate(pageFunction, arg, options)),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/page.ts
+/**
+* @category tag
+*/
+var PlaywrightPage = class PlaywrightPage extends Context.Tag("effect-playwright/PlaywrightPage")() {
+	/**
+	* Creates a `PlaywrightPage` from a Playwright `Page` instance.
+	*
+	* @param page - The Playwright `Page` instance to wrap.
+	* @since 0.1.0
+	*/
+	static make(page) {
+		const use = useHelper(page);
+		return PlaywrightPage.of({
+			goto: (url, options) => use((p) => p.goto(url, options)),
+			waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
+			title: use((p) => p.title()),
+			evaluate: (f, arg) => use((p) => p.evaluate(f, arg)),
+			locator: (selector, options) => PlaywrightLocator.make(page.locator(selector, options)),
+			getByRole: (role, options) => PlaywrightLocator.make(page.getByRole(role, options)),
+			getByText: (text, options) => PlaywrightLocator.make(page.getByText(text, options)),
+			getByLabel: (label, options) => PlaywrightLocator.make(page.getByLabel(label, options)),
+			getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
+			url: Effect.sync(() => page.url()),
+			reload: use((p) => p.reload()),
+			close: use((p) => p.close()),
+			click: (selector, options) => use((p) => p.click(selector, options)),
+			eventStream: (event) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => {
+				const callback = emit.single;
+				const closeCallback = emit.end;
+				page.on(event, callback);
+				page.once("close", closeCallback);
+				return {
+					callback,
+					closeCallback
+				};
+			}), ({ callback, closeCallback }) => Effect.sync(() => {
+				page.off(event, callback);
+				page.off("close", closeCallback);
+			}))).pipe(Stream.map((e) => {
+				const mapper = eventMappings[event];
+				return mapper(e);
+			})),
+			use
+		});
+	}
+};
+const eventMappings = {
+	close: PlaywrightPage.make,
+	console: identity,
+	crash: PlaywrightPage.make,
+	dialog: PlaywrightDialog.make,
+	domcontentloaded: PlaywrightPage.make,
+	download: PlaywrightDownload.make,
+	filechooser: PlaywrightFileChooser.make,
+	frameattached: PlaywrightFrame.make,
+	framedetached: PlaywrightFrame.make,
+	framenavigated: PlaywrightFrame.make,
+	load: PlaywrightPage.make,
+	pageerror: identity,
+	popup: PlaywrightPage.make,
+	request: PlaywrightRequest.make,
+	requestfailed: PlaywrightRequest.make,
+	requestfinished: PlaywrightRequest.make,
+	response: PlaywrightResponse.make,
+	websocket: identity,
+	worker: PlaywrightWorker.make
+};
+
+//#endregion
+//#region src/browser-context.ts
+var PlaywrightBrowserContext = class PlaywrightBrowserContext extends Context.Tag("cehs/backend/lib/playwright/PlaywrightBrowserContext")() {
+	static make(context) {
+		const use = useHelper(context);
+		return PlaywrightBrowserContext.of({
+			pages: Effect.sync(() => context.pages().map(PlaywrightPage.make)),
+			newPage: use((c) => c.newPage().then(PlaywrightPage.make)),
+			close: use((c) => c.close())
+		});
+	}
+};
+
+//#endregion
+//#region src/browser.ts
+/**
+* @category tag
+*/
+var PlaywrightBrowser = class PlaywrightBrowser extends Context.Tag("cehs/backend/lib/playwright/PlaywrightBrowser")() {
+	/**
+	* @category constructor
+	*/
+	static make(browser) {
+		const use = useHelper(browser);
+		return PlaywrightBrowser.of({
+			newPage: (options) => use((browser$1) => browser$1.newPage(options).then(PlaywrightPage.make)),
+			close: use((browser$1) => browser$1.close()),
+			contexts: Effect.sync(() => browser.contexts().map(PlaywrightBrowserContext.make)),
+			newContext: (options) => Effect.acquireRelease(use((browser$1) => browser$1.newContext(options).then(PlaywrightBrowserContext.make)), (context) => context.close.pipe(Effect.ignoreLogged)),
+			browserType: Effect.sync(() => browser.browserType()),
+			version: Effect.sync(() => browser.version()),
+			isConnected: Effect.sync(() => browser.isConnected()),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/playwright.ts
+const launch = Effect.fn(function* (browserType, options) {
+	const rawBrowser = yield* Effect.tryPromise({
+		try: () => browserType.launch(options),
+		catch: wrapError
+	});
+	return PlaywrightBrowser.make(rawBrowser);
+});
+const connectCDP = Effect.fn(function* (cdpUrl, options) {
+	const browser = yield* Effect.tryPromise({
+		try: () => chromium.connectOverCDP(cdpUrl, options),
+		catch: wrapError
+	});
+	return PlaywrightBrowser.make(browser);
+});
+var Playwright = class Playwright extends Context.Tag("effect-playwright/index/Playwright")() {
+	/**
+	* @category layer
+	*/
+	static layer = Layer.succeed(Playwright, {
+		launch,
+		launchScoped: (browserType, options) => Effect.acquireRelease(launch(browserType, options), (browser) => browser.close.pipe(Effect.ignore)),
+		connectCDP,
+		connectCDPScoped: (cdpUrl, options) => Effect.acquireRelease(connectCDP(cdpUrl, options), (browser) => browser.close.pipe(Effect.ignore))
+	});
+};
+
+//#endregion
+export { PlaywrightLocator as i, PlaywrightBrowser as n, PlaywrightPage as r, Playwright as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "effect-playwright",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "An Effect-based Playwright library.",
   "author": "Jobflow GmbH",
   "license": "ISC",
@@ -37,16 +37,17 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
-    "@effect/language-service": "^0.64.1",
+    "@effect/language-service": "^0.65.0",
     "@effect/platform": "^0.94.1",
     "@effect/platform-node": "^0.104.0",
     "@effect/vitest": "^0.27.0",
+    "@types/node": "^25.0.8",
     "effect": "^3.19.14",
     "playwright": "^1.57.0",
-    "tsdown": "^0.19.0",
+    "tsdown": "0.20.0-beta.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "types": "./dist/index.d.mts",
   "scripts": {

package/dist/src-DveiwW4g.mjs

@@ -1,167 +0,0 @@
-import { Context, Data, Effect, Layer, Stream } from "effect";
-import { chromium, errors } from "playwright-core";
-
-//#region src/errors.ts
-var PlaywrightError = class extends Data.TaggedError("PlaywrightError") {};
-function wrapError(error) {
-	if (error instanceof errors.TimeoutError) return new PlaywrightError({
-		reason: "Timeout",
-		cause: error
-	});
-	else return new PlaywrightError({
-		reason: "Unknown",
-		cause: error
-	});
-}
-
-//#endregion
-//#region src/utils.ts
-/** @internal */
-const useHelper = (api) => (userFunction) => Effect.tryPromise(() => userFunction(api)).pipe(Effect.mapError(wrapError));
-
-//#endregion
-//#region src/locator.ts
-/**
-* A service that provides a `PlaywrightLocator` instance.
-*
-* @since 0.1.0
-* @category tag
-*/
-var PlaywrightLocator = class PlaywrightLocator extends Context.Tag("effect-playwright/PlaywrightLocator")() {
-	/**
-	* 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) {
-		const use = useHelper(locator);
-		return PlaywrightLocator.of({
-			click: (options) => use((l) => l.click(options)),
-			fill: (value, options) => use((l) => l.fill(value, options)),
-			getAttribute: (name, options) => use((l) => l.getAttribute(name, options)),
-			innerText: (options) => use((l) => l.innerText(options)),
-			innerHTML: (options) => use((l) => l.innerHTML(options)),
-			inputValue: (options) => use((l) => l.inputValue(options)),
-			textContent: (options) => use((l) => l.textContent(options)),
-			count: use((l) => l.count()),
-			first: () => PlaywrightLocator.make(locator.first()),
-			last: () => PlaywrightLocator.make(locator.last()),
-			nth: (index) => PlaywrightLocator.make(locator.nth(index)),
-			evaluate: (pageFunction, arg, options) => use((l) => l.evaluate(pageFunction, arg, options)),
-			use
-		});
-	}
-};
-
-//#endregion
-//#region src/page.ts
-/**
-* @category tag
-*/
-var PlaywrightPage = class PlaywrightPage extends Context.Tag("effect-playwright/PlaywrightPage")() {
-	/**
-	* Creates a `PlaywrightPage` from a Playwright `Page` instance.
-	*
-	* @param page - The Playwright `Page` instance to wrap.
-	* @since 0.1.0
-	*/
-	static make(page) {
-		const use = useHelper(page);
-		return PlaywrightPage.of({
-			goto: (url, options) => use((p) => p.goto(url, options)),
-			waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
-			title: use((p) => p.title()),
-			evaluate: (f, arg) => use((p) => p.evaluate(f, arg)),
-			locator: (selector, options) => PlaywrightLocator.make(page.locator(selector, options)),
-			getByRole: (role, options) => PlaywrightLocator.make(page.getByRole(role, options)),
-			getByText: (text, options) => PlaywrightLocator.make(page.getByText(text, options)),
-			getByLabel: (label, options) => PlaywrightLocator.make(page.getByLabel(label, options)),
-			getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
-			url: Effect.sync(() => page.url()),
-			reload: use((p) => p.reload()),
-			close: use((p) => p.close()),
-			click: (selector, options) => use((p) => p.click(selector, options)),
-			eventStream: (event) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => page.on(event, emit.single)), () => Effect.sync(() => page.off(event, emit.single)))),
-			use
-		});
-	}
-};
-
-//#endregion
-//#region src/browser-context.ts
-var PlaywrightBrowserContext = class PlaywrightBrowserContext extends Context.Tag("cehs/backend/lib/playwright/PlaywrightBrowserContext")() {
-	static make(context) {
-		const use = useHelper(context);
-		return PlaywrightBrowserContext.of({
-			pages: Effect.sync(() => context.pages().map(PlaywrightPage.make)),
-			newPage: use((c) => c.newPage().then(PlaywrightPage.make)),
-			close: use((c) => c.close())
-		});
-	}
-};
-
-//#endregion
-//#region src/browser.ts
-/**
-* @category tag
-*/
-var PlaywrightBrowser = class PlaywrightBrowser extends Context.Tag("cehs/backend/lib/playwright/PlaywrightBrowser")() {
-	/**
-	* @category constructor
-	*/
-	static make(browser) {
-		const use = useHelper(browser);
-		return PlaywrightBrowser.of({
-			newPage: (options) => use((browser$1) => browser$1.newPage(options).then(PlaywrightPage.make)),
-			close: use((browser$1) => browser$1.close()),
-			contexts: Effect.sync(() => browser.contexts().map(PlaywrightBrowserContext.make)),
-			newContext: (options) => Effect.acquireRelease(use((browser$1) => browser$1.newContext(options).then(PlaywrightBrowserContext.make)), (context) => context.close.pipe(Effect.ignoreLogged)),
-			browserType: Effect.sync(() => browser.browserType()),
-			version: Effect.sync(() => browser.version()),
-			isConnected: Effect.sync(() => browser.isConnected()),
-			use
-		});
-	}
-};
-
-//#endregion
-//#region src/playwright.ts
-const launch = Effect.fn(function* (browserType, options) {
-	const rawBrowser = yield* Effect.tryPromise({
-		try: () => browserType.launch(options),
-		catch: wrapError
-	});
-	return PlaywrightBrowser.make(rawBrowser);
-});
-var Playwright = class Playwright extends Context.Tag("effect-playwright/index/Playwright")() {
-	/**
-	* @category layer
-	*/
-	static layer = Layer.succeed(Playwright, {
-		launch,
-		launchScoped: Effect.fn(function* (browserType, options) {
-			const browser = yield* launch(browserType, options);
-			yield* Effect.addFinalizer(() => browser.close.pipe(Effect.ignore));
-			return browser;
-		}),
-		connectCDP: Effect.fn(function* (cdpUrl, options) {
-			const browser = yield* Effect.tryPromise({
-				try: () => chromium.connectOverCDP(cdpUrl, options),
-				catch: wrapError
-			});
-			return PlaywrightBrowser.make(browser);
-		})
-	});
-};
-
-//#endregion
-export { PlaywrightLocator as i, PlaywrightBrowser as n, PlaywrightPage as r, Playwright as t };