effect-browser 0.2.0-beta.9 → 0.3.0-beta.10

package/dist/Supervisor-CYWFK3vM.d.mts

@@ -0,0 +1,280 @@
+import { c as DisconnectCause } from "./BrowserEvent-BRu2juEz.mjs";
+import { Service, t as Browser_d_exports } from "./Browser.mjs";
+import { Cause, Duration, Effect, Schedule, Schema, Scope, Stream } from "effect";
+declare namespace lifecycle_d_exports {
+  export { Closed, Command, Down, Drain, Draining, GenerationState, Held, Input, Kept, Live, Lost, Open, Opening, Released, Reopening, Resolution, Settled, State, Step, Unconfirmed, lookup, resolve, start, transition };
+}
+declare const Settled_base: Schema.Class<Settled, Schema.TaggedStruct<"Settled", {}>, {}>;
+/** The provider confirmed that the generation's browser ended. */
+declare class Settled extends Settled_base {}
+declare const Unconfirmed_base: Schema.Class<Unconfirmed, Schema.TaggedStruct<"Unconfirmed", {
+  readonly detail: Schema.String;
+}>, {}>;
+/** The provider could not confirm the end by its deadline, so the browser may still run, and bill. */
+declare class Unconfirmed extends Unconfirmed_base {}
+declare const Released: Schema.Union<readonly [typeof Settled, typeof Unconfirmed]>;
+type Released = typeof Released.Type;
+declare const Opening_base: Schema.Class<Opening, Schema.TaggedStruct<"Opening", {}>, {}>;
+/** Opening, but not after a loss: the first generation, a rotation, or the one after `Down`. */
+declare class Opening extends Opening_base {}
+declare const Reopening_base: Schema.Class<Reopening, Schema.TaggedStruct<"Reopening", {}>, {}>;
+/** Opening after the generation before it was lost. */
+declare class Reopening extends Reopening_base {}
+declare const Open_base: Schema.Class<Open, Schema.TaggedStruct<"Open", {}>, {}>;
+/** Open: `browser` gives this generation until the next one opens. */
+declare class Open extends Open_base {}
+declare const Draining_base: Schema.Class<Draining, Schema.TaggedStruct<"Draining", {
+  readonly reason: Schema.Literals<readonly ["rotated", "lost", "retired"]>;
+  readonly revokeAt: Schema.Finite;
+}>, {}>;
+/** No longer serving; holds end at this host-monotonic deadline or when their owners let go. */
+declare class Draining extends Draining_base {}
+declare const Lost_base: Schema.Class<Lost, Schema.TaggedStruct<"Lost", {
+  readonly cause: Schema.Literals<readonly ["connection", "session", "released"]>;
+}>, {}>;
+/** Lost: its connection dropped, or its provider ended its session, as `cause` says. */
+declare class Lost extends Lost_base {}
+declare const Down_base: Schema.Class<Down, Schema.TaggedStruct<"Down", {
+  readonly detail: Schema.String;
+  readonly cause: Schema.Defect;
+}>, {}>;
+/**
+ * It never opened: its last try failed with `cause`, which the provider deems definite, or after
+ * which the reopen schedule gave up.
+ */
+declare class Down extends Down_base {}
+declare const Closed_base: Schema.Class<Closed, Schema.TaggedStruct<"Closed", {
+  readonly released: Schema.optional<Schema.Union<readonly [typeof Settled, typeof Unconfirmed]>>;
+}>, {}>;
+/** It ended. `released` says how its release went; one retired while opening has none. */
+declare class Closed extends Closed_base {}
+declare const Kept_base: Schema.Class<Kept, Schema.TaggedStruct<"Kept", {}>, {}>;
+/**
+ * It was serving as the supervisor's scope closed, and was left running, not released: its scope
+ * closed, and its provider runs it on, and bills, until something adopts and releases it.
+ */
+declare class Kept extends Kept_base {}
+declare const GenerationState: Schema.Union<readonly [typeof Opening, typeof Reopening, typeof Open, typeof Draining, typeof Lost, typeof Down, typeof Closed, typeof Kept]>;
+type GenerationState = typeof GenerationState.Type;
+/** A generation that opened: its number, and what the runtime keeps to serve and end it. */
+interface Live<A> {
+  readonly number: number;
+  readonly value: A;
+}
+interface Held<A, H> extends Live<A> {
+  readonly holds: ReadonlySet<H>;
+}
+/** Release ownership remains here until the provider and generation scope have finished. */
+interface Drain<A, H> {
+  readonly _tag: "Draining" | "Releasing" | "Leaving";
+  readonly live: Held<A, H>;
+  readonly ending: Draining;
+}
+/** One serving generation, one shared acquisition, and prior generations still owned. */
+type State<A, H = unknown> = ({
+  readonly _tag: "Opening";
+  readonly number: number;
+  readonly serving: Held<A, H> | undefined;
+} | {
+  readonly _tag: "Open";
+  readonly serving: Held<A, H>;
+} | {
+  readonly _tag: "Down";
+  readonly number: number;
+  readonly detail: string;
+  readonly cause: unknown;
+  readonly serving: Held<A, H> | undefined;
+} | {
+  readonly _tag: "Retired";
+}) & {
+  readonly draining: ReadonlyMap<number, Drain<A, H>>;
+};
+type Input<A, H = unknown> = {
+  readonly _tag: "Opened";
+  readonly live: Live<A>;
+} | {
+  readonly _tag: "Failed";
+  readonly number: number;
+  readonly detail: string;
+  readonly cause: unknown;
+} | {
+  readonly _tag: "Abandoned";
+  readonly number: number;
+} | {
+  readonly _tag: "Lost";
+  readonly number: number;
+  readonly cause: DisconnectCause;
+} | {
+  readonly _tag: "Rotate";
+  readonly due?: number | undefined;
+} | {
+  readonly _tag: "Retire";
+} | {
+  readonly _tag: "Keep";
+} | {
+  readonly _tag: "Hold";
+  readonly number?: number | undefined;
+  readonly hold: H;
+} | {
+  readonly _tag: "Let";
+  readonly number: number;
+  readonly hold: H;
+} | {
+  readonly _tag: "Revoke";
+  readonly number: number;
+} | {
+  readonly _tag: "Released";
+  readonly number: number;
+  readonly released?: Released | undefined;
+};
+type Command<A> = {
+  readonly _tag: "Open";
+  readonly number: number;
+  readonly after: number | undefined;
+} | {
+  readonly _tag: "Watch";
+  readonly live: Live<A>;
+} |
+/** Signal ending and arrange revocation. Repeated only when loss/retirement accelerates it. */
+{
+  readonly _tag: "Drain";
+  readonly live: Live<A>;
+  readonly ending: Draining;
+} |
+/** Revoke/close holds, await their Let inputs, release the provider, then close its scope. */
+{
+  readonly _tag: "Release";
+  readonly live: Live<A>;
+  readonly ending: Draining;
+} | {
+  readonly _tag: "Leave";
+  readonly live: Live<A>;
+  readonly ending: Draining;
+};
+interface Step<A, H = unknown> {
+  readonly state: State<A, H>;
+  readonly events: ReadonlyArray<readonly [number, GenerationState]>;
+  readonly commands: ReadonlyArray<Command<A>>;
+  readonly reply?: number | undefined;
+  readonly borrowed?: Live<A> | undefined;
+}
+declare const start: <A, H = unknown>() => Step<A, H>;
+/** The holds still owned for a generation, including one whose release has begun. */
+declare const lookup: <A, H>(state: State<A, H>, number: number) => Held<A, H> | undefined;
+/** Pure admission and lifecycle changes. A rejected hold preserves state identity. */
+declare const transition: <A, H = unknown>(state: State<A, H>, input: Input<A, H>, exclusive: boolean, now?: number, handover?: number) => Step<A, H>;
+type Resolution<A> = {
+  readonly _tag: "Serve";
+  readonly live: Live<A>;
+} | {
+  readonly _tag: "Unavailable";
+  readonly reason: "down" | "retired";
+  readonly detail: string;
+  readonly cause?: unknown;
+};
+/** An unheld browser resolution; use obtains its hold atomically through Hold instead. */
+declare const resolve: <A, H>(state: State<A, H>, target: number | undefined) => Resolution<A> | undefined;
+declare namespace Supervisor_d_exports {
+  export { Closed, Down, Draining, Generation, GenerationState, Kept, Lease, Lost, Open, Opened, Opening, Options, Released, Reopening, Settled, Superseded, Supervisor, Unavailable, Unconfirmed, UseOptions, make };
+}
+declare const Generation_base: Schema.Class<Generation, Schema.Struct<{
+  readonly number: Schema.Int;
+  readonly at: Schema.Finite;
+  readonly hostTime: Schema.Finite;
+  readonly state: Schema.Union<readonly [typeof Opening, typeof Reopening, typeof Open, typeof Draining, typeof Lost, typeof Down, typeof Closed, typeof Kept]>;
+}>, {}>;
+/** One change in a generation's life. `at` is wall-clock epoch milliseconds from the Effect `Clock`. */
+declare class Generation extends Generation_base {}
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"Unavailable", {
+  readonly reason: Schema.Literals<readonly ["opening", "down", "retired"]>;
+  readonly detail: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, Cause.YieldableError>;
+/**
+ * No browser to give: none opened within `waitTimeout` (`opening`), the latest generation failed
+ * to open (`down`, with what it failed with as `cause`), or the supervisor was retired.
+ */
+declare class Unavailable extends Unavailable_base {
+  get message(): string;
+}
+/** One generation, as a provider opened it in the scope the supervisor gave it. */
+interface Opened<A = void> {
+  readonly value: A;
+  readonly browser: Service;
+  /**
+   * End the generation, and say whether the provider confirmed its end. The supervisor asks it
+   * before it closes the generation's scope; without it, closing the scope ends the generation,
+   * which counts as `Settled`.
+   */
+  readonly release?: Effect.Effect<Released> | undefined;
+}
+interface Options<E, R, A = void> {
+  /** Opens one generation in the scope it is given. */
+  readonly open: Effect.Effect<Opened<A>, E, R>;
+  /** When to try a failed open again. Defaults to exponential from 1 second, for 5 minutes. */
+  readonly reopen?: Schedule.Schedule<unknown, E> | undefined;
+  /**
+   * Failures no new try mends, such as a refused key: an open that fails so is `Down` at once.
+   * Defaults to none.
+   */
+  readonly definite?: ((error: E) => boolean) | undefined;
+  /**
+   * Rotate this long ahead of a generation's `expiresAt`, but no sooner than halfway through its
+   * life. Without it, a generation's end is a loss.
+   */
+  readonly rotateBefore?: Duration.Input | undefined;
+  /** Generations must not overlap: a rotation releases the current one before it opens the next. */
+  readonly exclusive?: boolean | undefined;
+  /** Finite, nonnegative time outgoing holds may finish; defaults to 30 seconds. */
+  readonly handover?: Duration.Input | undefined;
+  /**
+   * Closing the scope leaves the serving generation running, `Kept`: it closes the generation's
+   * scope but never asks `release`. For providers whose scope only disconnects, such as
+   * `Browserbase.supervise` with `keep`. `retire` still releases it.
+   */
+  readonly keep?: boolean | undefined;
+  /** How long `browser` and `rotate` wait for a generation to open. Defaults to 2 minutes. */
+  readonly waitTimeout?: Duration.Input | undefined;
+}
+declare const Superseded_base: Schema.Class<Superseded, Schema.TaggedStruct<"Superseded", {
+  readonly generation: Schema.Int;
+  readonly reason: Schema.Literals<readonly ["rotated", "lost", "retired"]>;
+  readonly revokeAt: Schema.Finite;
+}>, Cause.YieldableError>;
+/** Work whose generation was revoked; input receipts still determine whether input reached a site. */
+declare class Superseded extends Superseded_base {}
+interface Lease<A> {
+  readonly generation: number;
+  readonly browser: Service;
+  readonly value: A;
+  /** First notice that serving ended; loss or retirement may revoke before its deadline. */
+  readonly ending: Effect.Effect<Superseded>;
+  /** An independent scope; its resources close before provider release. Fails once revoked. */
+  readonly retain: Effect.Effect<Scope.Closeable, Superseded>;
+}
+interface UseOptions {
+  /** Finite, nonnegative wait for a serving generation. Zero makes an immediate attempt. */
+  readonly wait?: Duration.Input | undefined;
+}
+interface Supervisor<A = void> {
+  /** Scoped work on the current generation. Revocation interrupts it and waits for its cleanup. */
+  readonly use: <B, E, R>(work: (lease: Lease<A>) => Effect.Effect<B, E, R>, options?: UseOptions) => Effect.Effect<B, E | Unavailable | Superseded, Exclude<R, Scope.Scope>>;
+  /** The current generation's browser, waiting up to `waitTimeout` while none is open. */
+  readonly browser: Effect.Effect<Service, Unavailable>;
+  /** Each generation's changes, in order. A new reader first gets the latest 64; ends on retiring. */
+  readonly states: Stream.Stream<Generation>;
+  /** Open the next generation now, or join the one opening, and wait for it. */
+  readonly rotate: Effect.Effect<Service, Unavailable>;
+  /** Stop opening at once, release every generation, and wait until each release has finished. */
+  readonly retire: Effect.Effect<void>;
+}
+type Provider = Omit<Opened, "value">;
+type MakeOptions<E, R, A> = Omit<Options<E, R, A>, "open"> & {
+  readonly open: Effect.Effect<Opened<A> | Provider, E, R>;
+};
+/** Supervise scoped generation values. Browser-only providers retain their existing void value. */
+declare function make<E, R, A = void>(options: Options<E, R, A>): Effect.Effect<Supervisor<A>, never, Scope.Scope | Exclude<R, Scope.Scope>>;
+declare function make<E, R>(options: MakeOptions<E, R, never>): Effect.Effect<Supervisor<void>, never, Scope.Scope | Exclude<R, Scope.Scope>>;
+//#endregion
+export { Unconfirmed as S, Open as _, Superseded as a, Reopening as b, Unavailable as c, Closed as d, Down as f, Lost as g, Kept as h, Options as i, UseOptions as l, GenerationState as m, Lease as n, Supervisor as o, Draining as p, Opened as r, Supervisor_d_exports as s, Generation as t, make as u, Opening as v, Settled as x, Released as y };
+//# sourceMappingURL=Supervisor-CYWFK3vM.d.mts.map