effect-browser 0.2.0-beta.0 → 0.2.0-beta.1

package/dist/BrowserRuntime-Coz-5DYb.d.mts

@@ -0,0 +1,143 @@
+import { BrowserError, InitializationError } from "./Errors.mjs";
+import { O as Observation, a as BrowserPolicy, b as InlineFile, c as ClickRequest, et as Viewport, n as AutomationOptions, t as ActionResult } from "./BrowserData-CRuxEZcn.mjs";
+import { BrowserSession, OpenOptions } from "./Browser.mjs";
+import { Crypto, Effect, Option, Redacted, Schema, Scope } from "effect";
+//#region src/internal/browser/ConnectionCleanup.d.ts
+/** Evidence about this connection, independent of the lifetime of its browser process. */
+type ConnectionState = "closed" | "failed" | "not-connected" | "pending";
+/** Captured teardown operations supplied to the lifetime which owns this connection. */
+interface ConnectionCleanup {
+  readonly fence: Effect.Effect<void>;
+  readonly capture: Effect.Effect<void, BrowserError>;
+  readonly initialization: Effect.Effect<void, BrowserError | InitializationError>;
+  readonly disconnect: Effect.Effect<ConnectionState, BrowserError>;
+}
+declare const noConnection: ConnectionCleanup;
+type CleanupStep<A> = {
+  readonly _tag: "Success";
+  readonly value: A;
+} | {
+  readonly _tag: "Failure";
+  readonly reason: "timeout" | "interrupted" | "failed";
+};
+/** Every step settles independently, so one failure never suppresses subsequent teardown. */
+declare const cleanupStep: <A, E, R>(action: Effect.Effect<A, E, R>, timeoutMillis: number) => Effect.Effect<CleanupStep<A>, never, R>;
+/** Bounded host notification; reporting cannot change the cleanup evidence it describes. */
+declare const reported: <A, E>(effect: Effect.Effect<A, E>) => Effect.Effect<void>;
+//#endregion
+//#region src/BrowserRuntime.d.ts
+/** Opaque engine configuration. Only this constructor's issued values can acquire a runtime. */
+interface BrowserBinding {
+  readonly _tag: "BrowserBinding";
+}
+interface PlaywrightOptions {
+  /** A trusted integration validates its own endpoint authority before routing the connection. */
+  readonly resolveEndpoint?: (connection: {
+    readonly url: Redacted.Redacted<string>;
+  }) => Effect.Effect<string, BrowserError>;
+  /** Trusted instrumentation of the existing native connection, before the owner starts using it. */
+  readonly onConnected?: (connection: {
+    readonly native: unknown;
+    readonly endpoint: string;
+  }) => void;
+}
+/** A maintained Playwright connection, loaded lazily. No driver or protocol capability is returned. */
+declare const playwright: (options?: PlaywrightOptions) => BrowserBinding;
+/**
+ * An integration owns endpoint authority and the meaning of release. Its source must register
+ * release in the supplied Scope before returning; the runtime owns only the connection below it.
+ */
+interface Lifetime {
+  readonly reference: unknown;
+  readonly connection: (remainingMillis: number) => Effect.Effect<Redacted.Redacted<string>, BrowserError>;
+  readonly release: Effect.Effect<unknown>;
+  readonly cleanupResult: Effect.Effect<Option.Option<unknown>>;
+  readonly closeChecked: Effect.Effect<void, BrowserError>;
+  /**
+   * Memory-only evidence that canonical owned cleanup terminated native browser control.
+   * Omission is unknown. Borrowed disconnection alone never establishes this fact.
+   */
+  readonly controlRetired?: Effect.Effect<boolean>;
+  readonly verifyReconnect?: Effect.Effect<void, BrowserError>;
+}
+type Source<L extends Lifetime, E, R = never> = (cleanup: ConnectionCleanup, lifetimeDeadline: number) => Effect.Effect<L, E, R | Scope.Scope>;
+interface RuntimeOptions {
+  readonly implementation: string;
+  readonly binding?: BrowserBinding;
+  readonly automation?: AutomationOptions;
+  readonly viewport?: Viewport;
+  readonly preserveViewport?: boolean;
+  readonly keepAlive?: boolean;
+}
+interface AcquireOptions<E = never, R = never> extends OpenOptions<E, R> {
+  /** Attach to an existing page without creating a tab or changing its viewport. */
+  readonly existingTarget?: {
+    readonly targetId?: string;
+  };
+}
+/**
+ * Resolved host input for an integration constructing its own runtime. Stored paths must already
+ * have been authorized by that integration; a session cannot recover these operations afterwards.
+ */
+type ResolvedFileSelection = {
+  readonly _tag: "Inline";
+  readonly files: ReadonlyArray<InlineFile>;
+} | {
+  readonly _tag: "Stored";
+  readonly paths: ReadonlyArray<string>;
+};
+interface FileRequest {
+  readonly selector: string;
+  readonly selection: ResolvedFileSelection;
+}
+declare const DownloadEvent_base: Schema.Class<DownloadEvent, Schema.Struct<{
+  readonly downloadId: Schema.NonEmptyString;
+  readonly filename: Schema.NonEmptyString;
+  readonly state: Schema.Literals<readonly ["completed", "failed"]>;
+}>, {}>;
+declare class DownloadEvent extends DownloadEvent_base {}
+/**
+ * Modeled host operations for the integration creating this connection. Native authority stays
+ * inside the owner; the integration adds only the capabilities its public session supports.
+ */
+interface Integration<Reference> {
+  readonly clickForDownload: (request: ClickRequest) => Effect.Effect<DownloadEvent, BrowserError>;
+  readonly selectFiles: (request: FileRequest) => Effect.Effect<ActionResult, BrowserError>;
+  readonly clickForFileSelection: (request: FileRequest) => Effect.Effect<ActionResult, BrowserError>;
+  readonly liveView: <A>(issue: Effect.Effect<A, BrowserError>) => Effect.Effect<A, BrowserError>;
+  readonly beginHandoff: <A>(issue: Effect.Effect<A, BrowserError>) => Effect.Effect<{
+    readonly token: Redacted.Redacted<string>;
+    readonly view: A;
+  }, BrowserError>;
+  readonly resume: (token: Redacted.Redacted<string>, operatorReleasedControl: boolean) => Effect.Effect<Observation, BrowserError>;
+  readonly detach: Effect.Effect<{
+    readonly reference: Reference;
+    readonly targetId: string;
+  }, BrowserError>;
+  readonly reconnect: (operatorReleasedControl: boolean) => Effect.Effect<Observation, BrowserError | InitializationError>;
+}
+interface Connection<Reference, E = never> {
+  /** Preserve this object's identity when adding an integration's public capabilities. */
+  readonly session: BrowserSession<E>;
+  readonly operations: Integration<Reference>;
+}
+interface Acquisition<L extends Lifetime, E = never> {
+  readonly reference: L["reference"];
+  readonly lifetime: L;
+  readonly failure: Effect.Effect<never, E | InitializationError>;
+  readonly close: L["release"];
+  readonly connect: Effect.Effect<Connection<L["reference"], E>, BrowserError | InitializationError | E>;
+}
+interface Runtime {
+  readonly acquire: <L extends Lifetime, AE, AR, E = never, R = never>(policy: BrowserPolicy, source: Source<L, AE, AR>, request?: AcquireOptions<E, R>) => Effect.Effect<Acquisition<L, E>, AE | BrowserError, Scope.Scope | AR | Exclude<R, Scope.Scope>>;
+}
+/**
+ * Validate immutable connection configuration without loading a peer or acquiring a lifetime.
+ * Connection ids and handoff tokens come from the `Crypto` service captured here, so a Layer
+ * built on this runtime requires `Crypto` once and its operations never do.
+ */
+declare const make: (options: RuntimeOptions) => Effect.Effect<Runtime, BrowserError, Crypto.Crypto>;
+//#endregion
+export { ConnectionCleanup as _, DownloadEvent as a, noConnection as b, Lifetime as c, Runtime as d, RuntimeOptions as f, CleanupStep as g, playwright as h, Connection as i, PlaywrightOptions as l, make as m, Acquisition as n, FileRequest as o, Source as p, BrowserBinding as r, Integration as s, AcquireOptions as t, ResolvedFileSelection as u, ConnectionState as v, reported as x, cleanupStep as y };
+export {};
+//# sourceMappingURL=BrowserRuntime-Coz-5DYb.d.mts.map