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

package/dist/Stage.d.mts

@@ -0,0 +1,54 @@
+import { t as BrowserError } from "./BrowserError-DXXIA6Rk.mjs";
+import { n as CaptureStats, o as ScreencastOptions, r as Frame } from "./Frame-BERmf_gM.mjs";
+import { u as Page } from "./Page-DYTdVhYa.mjs";
+import { Duration, Effect, Option, Schema, Stream } from "effect";
+declare namespace Stage_d_exports {
+  export { Options, Presented, Stage, make };
+}
+export interface Options extends ScreencastOptions {
+  /** How long a switch waits for the new page's first frame. Defaults to 5 seconds. */
+  readonly firstFrame?: Duration.Input | undefined;
+}
+declare const Presented_base: Schema.Class<Presented, Schema.Struct<{
+  readonly page: Schema.String;
+  /**
+   * When it took effect, in host monotonic milliseconds on the frame clock: no earlier than the
+   * time asked for, the frames it followed or the new page's first.
+   */
+  readonly at: Schema.Finite;
+  /** How long after the time asked for it took effect. */
+  readonly latency: Schema.Finite;
+}>, {}>;
+/** A switch that took effect. */
+export declare class Presented extends Presented_base {}
+export interface Stage {
+  readonly present: (page: Page, options?: {
+    readonly at?: number | undefined;
+  }) => Effect.Effect<Presented, BrowserError>;
+  /**
+   * The presented page's frames, each naming its page, session, document and address. A reader
+   * more than 16 frames behind loses the oldest.
+   */
+  readonly frames: Stream.Stream<Frame>;
+  readonly current: Effect.Effect<Option.Option<Page>>;
+  /**
+   * The presented page's capture counts over the latest `window`, at most a minute: its frames,
+   * their largest gap, and those filtered out, as another capture's or a crop's.
+   */
+  readonly stats: (options?: {
+    readonly window?: Duration.Input | undefined;
+  }) => Effect.Effect<Option.Option<CaptureStats>, BrowserError>;
+}
+export declare const make: (options?: Options | undefined) => Effect.Effect<{
+  present: (page: Page, options?: {
+    readonly at?: number | undefined;
+  }) => Effect.Effect<Presented, BrowserError>;
+  frames: Stream.Stream<Frame, never, never>;
+  current: Effect.Effect<Option.Option<Page>, never, never>;
+  stats: (statsOptions?: {
+    readonly window?: Duration.Input | undefined;
+  } | undefined) => Effect.Effect<Option.Option<CaptureStats>, BrowserError, never>;
+}, BrowserError, import("effect/Scope").Scope>;
+//#endregion
+export { Stage_d_exports as t };
+//# sourceMappingURL=Stage.d.mts.map

package/dist/Stage.mjs

@@ -0,0 +1,133 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { InvalidRequest, Timeout, consequence } from "./BrowserError.mjs";
+import { i as failWith } from "./context-DAYjATgC.mjs";
+import { t as internalsOf } from "./page-BkRcLCWZ.mjs";
+import { Clock, Deferred, Duration, Effect, Exit, Fiber, Option, PubSub, Schedule, Schema, Semaphore, Stream } from "effect";
+//#region src/Stage.ts
+/**
+* The stage: whichever page's capture feeds a live output, switched between pages in one browser
+* session or across two, each switch stamped with when it took effect on the frame clock. Make one
+* per live output.
+*
+* `present(page, { at })` switches the output to `page` at `at`, host monotonic milliseconds on the
+* clock that times frames, or at once. It starts the new page's capture ahead, waits for its first
+* frame, then for any input already under way on the old page, and turns: from then on `frames`
+* carries the new page's frames, its newest first, and the old page's capture stops. The captures
+* overlap, so a switch shows no dark spell; on Browserbase two ran in one session at the frame
+* rate of one. A first frame that does not come in time fails `present`, and the old page stays. A
+* capture that fails restarts on the same page while its page and browser stand.
+*
+* What a live output does with frames stays the application's: a delay line, a liveness rule,
+* redaction and repeating a held frame. A still page sends no frames until it changes, so the frame
+* a switch begins with may be older than the frames before it; `Presented.at` says when it took
+* effect.
+*
+* @since 0.3.0
+*/
+var Stage_exports = /* @__PURE__ */ __exportAll({
+	Presented: () => Presented,
+	make: () => make
+});
+/** A switch that took effect. */
+var Presented = class extends Schema.Class("effect-browser/Presented")({
+	page: Schema.String,
+	/**
+	* When it took effect, in host monotonic milliseconds on the frame clock: no earlier than the
+	* time asked for, the frames it followed or the new page's first.
+	*/
+	at: Schema.Finite,
+	/** How long after the time asked for it took effect. */
+	latency: Schema.Finite
+}) {};
+const restartable = (error) => {
+	const { lost, repeat } = consequence(error);
+	return lost === "nothing" && repeat !== "pointless";
+};
+const make = Effect.fn("Stage.make")(function* (options = {}) {
+	const clock = yield* Clock.Clock;
+	const scope = yield* Effect.scope;
+	const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+	const waited = Duration.fromInput(options.firstFrame ?? Duration.seconds(5));
+	if (Option.isNone(waited) || !Duration.isPositive(waited.value)) return yield* failWith("stage", new InvalidRequest({ detail: "firstFrame must be a positive duration" }));
+	const firstFrame = waited.value;
+	const settings = {
+		quality: options.quality,
+		size: options.size
+	};
+	const output = yield* PubSub.sliding(16);
+	const switching = yield* Semaphore.make(1);
+	let shown;
+	let painted = Number.NEGATIVE_INFINITY;
+	const feed = (page) => Effect.gen(function* () {
+		const fed = {
+			page,
+			first: yield* Deferred.make(),
+			latest: void 0,
+			live: false,
+			fiber: void 0
+		};
+		fed.fiber = yield* page.screencast(settings).pipe(Stream.runForEach((frame) => Effect.sync(() => {
+			fed.latest = frame;
+			if (fed.live) {
+				painted = frame.hostTime;
+				PubSub.publishUnsafe(output, frame);
+			}
+			Deferred.doneUnsafe(fed.first, Exit.void);
+		})), Effect.retry({
+			while: restartable,
+			schedule: Schedule.spaced(Duration.millis(500))
+		}), Effect.forkIn(scope));
+		return fed;
+	});
+	const stop = (fed) => Effect.suspend(() => {
+		fed.live = false;
+		return fed.fiber === void 0 ? Effect.void : Fiber.interrupt(fed.fiber);
+	});
+	const firstOf = (fed) => Effect.raceFirst(Deferred.await(fed.first), fed.fiber === void 0 ? Effect.never : Effect.andThen(Fiber.join(fed.fiber), Effect.never)).pipe(Effect.timeoutOrElse({
+		duration: firstFrame,
+		orElse: () => failWith("present", new Timeout({ millis: Duration.toMillis(firstFrame) }))
+	}));
+	const until = (at) => Effect.suspend(() => at > now() ? Effect.andThen(Effect.sleep(Duration.millis(Math.ceil(at - now()))), until(at)) : Effect.void);
+	const present = (page, presentOptions = {}) => switching.withPermits(1)(Effect.gen(function* () {
+		const asked = presentOptions.at ?? now();
+		const old = shown;
+		if (old?.feed.page === page) return old.presented;
+		const fed = yield* feed(page);
+		yield* Effect.gen(function* () {
+			yield* firstOf(fed);
+			yield* until(asked);
+			if (old !== void 0) yield* Effect.ignore(internalsOf(old.feed.page)?.inputEnded ?? Effect.void);
+		}).pipe(Effect.onError(() => stop(fed)));
+		const presented = yield* Effect.sync(() => {
+			const frame = fed.latest;
+			const at = Math.max(asked, frame?.hostTime ?? asked, painted);
+			if (old !== void 0) old.feed.live = false;
+			fed.live = true;
+			if (frame !== void 0) {
+				painted = frame.hostTime;
+				PubSub.publishUnsafe(output, frame);
+			}
+			shown = {
+				feed: fed,
+				presented: new Presented({
+					page: page.id,
+					at,
+					latency: at - asked
+				})
+			};
+			return shown.presented;
+		});
+		if (old !== void 0) yield* stop(old.feed);
+		return presented;
+	}).pipe(Effect.provideService(Clock.Clock, clock)));
+	return {
+		present,
+		frames: Stream.fromPubSub(output),
+		current: Effect.sync(() => Option.fromNullishOr(shown?.feed.page)),
+		stats: (statsOptions = {}) => shown === void 0 ? Effect.succeedNone : Effect.asSome(shown.feed.page.captureStats({ window: statsOptions.window ?? "1 second" }))
+	};
+});
+//#endregion
+export { Presented, make, Stage_exports as t };
+
+//# sourceMappingURL=Stage.mjs.map

package/dist/Stage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.mjs","names":[],"sources":["../src/Stage.ts"],"sourcesContent":["/**\n * The stage: whichever page's capture feeds a live output, switched between pages in one browser\n * session or across two, each switch stamped with when it took effect on the frame clock. Make one\n * per live output.\n *\n * `present(page, { at })` switches the output to `page` at `at`, host monotonic milliseconds on the\n * clock that times frames, or at once. It starts the new page's capture ahead, waits for its first\n * frame, then for any input already under way on the old page, and turns: from then on `frames`\n * carries the new page's frames, its newest first, and the old page's capture stops. The captures\n * overlap, so a switch shows no dark spell; on Browserbase two ran in one session at the frame\n * rate of one. A first frame that does not come in time fails `present`, and the old page stays. A\n * capture that fails restarts on the same page while its page and browser stand.\n *\n * What a live output does with frames stays the application's: a delay line, a liveness rule,\n * redaction and repeating a held frame. A still page sends no frames until it changes, so the frame\n * a switch begins with may be older than the frames before it; `Presented.at` says when it took\n * effect.\n *\n * @since 0.3.0\n */\nimport {\n  Clock,\n  Deferred,\n  Duration,\n  Effect,\n  Exit,\n  Fiber,\n  Option,\n  PubSub,\n  Schedule,\n  Schema,\n  Semaphore,\n  Stream,\n} from \"effect\";\n\nimport { type BrowserError, consequence, InvalidRequest, Timeout } from \"./BrowserError.ts\";\nimport type { CaptureStats, Frame, ScreencastOptions } from \"./Frame.ts\";\nimport { failWith } from \"./internal/page/context.ts\";\nimport { internalsOf } from \"./internal/page/page.ts\";\nimport type { Page } from \"./Page.ts\";\n\nexport interface Options extends ScreencastOptions {\n  /** How long a switch waits for the new page's first frame. Defaults to 5 seconds. */\n  readonly firstFrame?: Duration.Input | undefined;\n}\n\n/** A switch that took effect. */\nexport class Presented extends Schema.Class<Presented>(\"effect-browser/Presented\")({\n  page: Schema.String,\n  /**\n   * When it took effect, in host monotonic milliseconds on the frame clock: no earlier than the\n   * time asked for, the frames it followed or the new page's first.\n   */\n  at: Schema.Finite,\n  /** How long after the time asked for it took effect. */\n  latency: Schema.Finite,\n}) {}\n\nexport interface Stage {\n  readonly present: (\n    page: Page,\n    options?: { readonly at?: number | undefined },\n  ) => Effect.Effect<Presented, BrowserError>;\n  /**\n   * The presented page's frames, each naming its page, session, document and address. A reader\n   * more than 16 frames behind loses the oldest.\n   */\n  readonly frames: Stream.Stream<Frame>;\n  readonly current: Effect.Effect<Option.Option<Page>>;\n  /**\n   * The presented page's capture counts over the latest `window`, at most a minute: its frames,\n   * their largest gap, and those filtered out, as another capture's or a crop's.\n   */\n  readonly stats: (options?: {\n    readonly window?: Duration.Input | undefined;\n  }) => Effect.Effect<Option.Option<CaptureStats>, BrowserError>;\n}\n\n/** A page's capture for the stage: its newest frame, and whether its frames go out. */\ninterface Feed {\n  readonly page: Page;\n  readonly first: Deferred.Deferred<void>;\n  latest: Frame | undefined;\n  live: boolean;\n  fiber: Fiber.Fiber<void, BrowserError> | undefined;\n}\n\n// A capture restarts unless its page or browser is gone, or it would fail the same way again.\nconst restartable = (error: BrowserError) => {\n  const { lost, repeat } = consequence(error);\n\n  return lost === \"nothing\" && repeat !== \"pointless\";\n};\n\nexport const make = Effect.fn(\"Stage.make\")(function* (options: Options = {}) {\n  const clock = yield* Clock.Clock;\n  const scope = yield* Effect.scope;\n  const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;\n  const waited = Duration.fromInput(options.firstFrame ?? Duration.seconds(5));\n\n  if (Option.isNone(waited) || !Duration.isPositive(waited.value))\n    return yield* failWith(\n      \"stage\",\n      new InvalidRequest({ detail: \"firstFrame must be a positive duration\" }),\n    );\n  const firstFrame = waited.value;\n  const settings = { quality: options.quality, size: options.size };\n  const output = yield* PubSub.sliding<Frame>(16);\n  const switching = yield* Semaphore.make(1);\n  // What is on the stage, which only `present` changes, and the paint of the latest frame out.\n  let shown: { readonly feed: Feed; readonly presented: Presented } | undefined;\n  let painted = Number.NEGATIVE_INFINITY;\n\n  const feed = (page: Page) =>\n    Effect.gen(function* () {\n      const fed: Feed = {\n        page,\n        first: yield* Deferred.make<void>(),\n        latest: undefined,\n        live: false,\n        fiber: undefined,\n      };\n\n      fed.fiber = yield* page.screencast(settings).pipe(\n        Stream.runForEach((frame) =>\n          Effect.sync(() => {\n            fed.latest = frame;\n            if (fed.live) {\n              painted = frame.hostTime;\n              PubSub.publishUnsafe(output, frame);\n            }\n            // Last: a switch waiting for this frame may turn, and send it, at once.\n            Deferred.doneUnsafe(fed.first, Exit.void);\n          }),\n        ),\n        Effect.retry({ while: restartable, schedule: Schedule.spaced(Duration.millis(500)) }),\n        Effect.forkIn(scope),\n      );\n\n      return fed;\n    });\n\n  // No frame of it goes out once this returns, and its capture stops.\n  const stop = (fed: Feed) =>\n    Effect.suspend(() => {\n      fed.live = false;\n\n      return fed.fiber === undefined ? Effect.void : Fiber.interrupt(fed.fiber);\n    });\n\n  // The new page's first frame; its capture's own failure, or `Timeout`.\n  const firstOf = (fed: Feed) =>\n    Effect.raceFirst(\n      Deferred.await(fed.first),\n      fed.fiber === undefined ? Effect.never : Effect.andThen(Fiber.join(fed.fiber), Effect.never),\n    ).pipe(\n      Effect.timeoutOrElse({\n        duration: firstFrame,\n        orElse: () => failWith(\"present\", new Timeout({ millis: Duration.toMillis(firstFrame) })),\n      }),\n    );\n\n  // A timer can fire a fraction of a millisecond early, so the wait looks again.\n  const until = (at: number): Effect.Effect<void> =>\n    Effect.suspend(() =>\n      at > now()\n        ? Effect.andThen(Effect.sleep(Duration.millis(Math.ceil(at - now()))), until(at))\n        : Effect.void,\n    );\n\n  const present: Stage[\"present\"] = (page, presentOptions = {}) =>\n    switching.withPermits(1)(\n      Effect.gen(function* () {\n        const asked = presentOptions.at ?? now();\n        const old = shown;\n\n        if (old?.feed.page === page) return old.presented;\n        const fed = yield* feed(page);\n\n        yield* Effect.gen(function* () {\n          yield* firstOf(fed);\n          yield* until(asked);\n          // Input under way on the old page ends first, within its action timeout.\n          if (old !== undefined)\n            yield* Effect.ignore(internalsOf(old.feed.page)?.inputEnded ?? Effect.void);\n        }).pipe(Effect.onError(() => stop(fed)));\n\n        const presented = yield* Effect.sync(() => {\n          const frame = fed.latest;\n          const at = Math.max(asked, frame?.hostTime ?? asked, painted);\n\n          if (old !== undefined) old.feed.live = false;\n          fed.live = true;\n          if (frame !== undefined) {\n            painted = frame.hostTime;\n            PubSub.publishUnsafe(output, frame);\n          }\n          shown = {\n            feed: fed,\n            presented: new Presented({ page: page.id, at, latency: at - asked }),\n          };\n\n          return shown.presented;\n        });\n\n        if (old !== undefined) yield* stop(old.feed);\n\n        return presented;\n      }).pipe(Effect.provideService(Clock.Clock, clock)),\n    );\n\n  return {\n    present,\n    frames: Stream.fromPubSub(output),\n    current: Effect.sync(() => Option.fromNullishOr(shown?.feed.page)),\n    stats: (statsOptions = {}) =>\n      shown === undefined\n        ? Effect.succeedNone\n        : Effect.asSome(\n            shown.feed.page.captureStats({ window: statsOptions.window ?? \"1 second\" }),\n          ),\n  } satisfies Stage;\n});\n"],"mappings":"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"}

package/dist/Supervisor-BtEG93gR.mjs

@@ -0,0 +1,420 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DisconnectCause } from "./BrowserEvent.mjs";
+import { Cause, Clock, DateTime, Duration, Effect, Exit, Fiber, FiberHandle, FiberMap, Option, Predicate, PubSub, Schedule, Schema, Scope, Stream, SubscriptionRef } from "effect";
+//#region src/internal/supervisor/lifecycle.ts
+/**
+* A supervisor's life as one state and one transition function, and the generation states it
+* publishes. The transition has no effects: `Supervisor.make` applies each input under one lock,
+* publishes the events in order and runs the commands, so the rules here are tested alone.
+*/
+/** The provider confirmed that the generation's browser ended. */
+var Settled = class extends Schema.TaggedClass()("Settled", {}) {};
+/** The provider could not confirm the end by its deadline, so the browser may still run, and bill. */
+var Unconfirmed = class extends Schema.TaggedClass()("Unconfirmed", { detail: Schema.String }) {};
+const Released = Schema.Union([Settled, Unconfirmed]);
+/** Opening, but not after a loss: the first generation, a rotation, or the one after `Down`. */
+var Opening = class extends Schema.TaggedClass()("Opening", {}) {};
+/** Opening after the generation before it was lost. */
+var Reopening = class extends Schema.TaggedClass()("Reopening", {}) {};
+/** Open: `browser` gives this generation until the next one opens. */
+var Open = class extends Schema.TaggedClass()("Open", {}) {};
+/** Lost: its connection dropped, or its provider ended its session, as `cause` says. */
+var Lost = class extends Schema.TaggedClass()("Lost", { cause: DisconnectCause }) {};
+/**
+* It never opened: its last try failed with `cause`, which the provider deems definite, or after
+* which the reopen schedule gave up.
+*/
+var Down = class extends Schema.TaggedClass()("Down", {
+	detail: Schema.String,
+	cause: Schema.Defect()
+}) {};
+/** It ended. `released` says how its release went; one retired while opening has none. */
+var Closed = class extends Schema.TaggedClass()("Closed", { released: Schema.optional(Released) }) {};
+/**
+* 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.
+*/
+var Kept = class extends Schema.TaggedClass()("Kept", {}) {};
+const GenerationState = Schema.Union([
+	Opening,
+	Reopening,
+	Open,
+	Lost,
+	Down,
+	Closed,
+	Kept
+]);
+const start = () => ({
+	state: {
+		_tag: "Opening",
+		number: 1,
+		serving: void 0
+	},
+	events: [[1, new Opening()]],
+	commands: [{
+		_tag: "Open",
+		number: 1,
+		after: void 0
+	}]
+});
+const servingOf = (state) => state._tag === "Retired" ? void 0 : state.serving;
+/** The state after `input`, with the events to publish and the commands to run. */
+const transition = (state, input, exclusive) => {
+	const release = (live) => ({
+		_tag: "Release",
+		live
+	});
+	const stay = {
+		state,
+		events: [],
+		commands: []
+	};
+	/**
+	* Open `number`, ending `current` now if it `ends`; exclusive generations open only once its
+	* release has finished. Otherwise `current` serves until the next one opens.
+	*/
+	const next = (number, reopen, current, ends) => ({
+		state: {
+			_tag: "Opening",
+			number,
+			serving: ends ? void 0 : current
+		},
+		events: [[number, reopen ? new Reopening() : new Opening()]],
+		commands: [...ends && current !== void 0 ? [release(current)] : [], {
+			_tag: "Open",
+			number,
+			after: ends && exclusive ? current?.number : void 0
+		}]
+	});
+	switch (input._tag) {
+		case "Opened": {
+			const { live } = input;
+			if (state._tag !== "Opening" || state.number !== live.number) return {
+				...stay,
+				commands: [release(live)]
+			};
+			return {
+				state: {
+					_tag: "Open",
+					serving: live
+				},
+				events: [[live.number, new Open()]],
+				commands: [{
+					_tag: "Watch",
+					live
+				}, ...state.serving === void 0 ? [] : [release(state.serving)]]
+			};
+		}
+		case "Failed": {
+			const { number, detail, cause } = input;
+			const events = [[number, new Down({
+				detail,
+				cause
+			})]];
+			if (state._tag !== "Opening" || state.number !== input.number) return {
+				...stay,
+				events
+			};
+			return {
+				state: {
+					_tag: "Down",
+					number,
+					detail,
+					cause,
+					serving: state.serving
+				},
+				events,
+				commands: []
+			};
+		}
+		case "Abandoned": return {
+			...stay,
+			events: [[input.number, new Closed({})]]
+		};
+		case "Released": return {
+			...stay,
+			events: [[input.number, new Closed({ released: input.released })]]
+		};
+		case "Lost": {
+			const lost = servingOf(state);
+			if (state._tag === "Retired" || lost?.number !== input.number) return stay;
+			const events = [[lost.number, new Lost({ cause: input.cause })]];
+			if (state._tag === "Opening") return {
+				state: {
+					...state,
+					serving: void 0
+				},
+				events,
+				commands: [release(lost)]
+			};
+			const reopened = next((state._tag === "Open" ? lost.number : state.number) + 1, true, lost, true);
+			return {
+				...reopened,
+				events: [...events, ...reopened.events]
+			};
+		}
+		case "Rotate": {
+			if (state._tag === "Retired") return stay;
+			if (input.due !== void 0 && (state._tag !== "Open" || state.serving.number !== input.due)) return stay;
+			if (state._tag === "Opening") return {
+				...stay,
+				reply: state.number
+			};
+			const number = (state._tag === "Open" ? state.serving.number : state.number) + 1;
+			return {
+				...next(number, false, state.serving, exclusive),
+				reply: number
+			};
+		}
+		case "Retire":
+		case "Keep": {
+			const current = servingOf(state);
+			if (state._tag === "Retired") return stay;
+			if (current === void 0) return {
+				state: { _tag: "Retired" },
+				events: [],
+				commands: []
+			};
+			return input._tag === "Retire" ? {
+				state: { _tag: "Retired" },
+				events: [],
+				commands: [release(current)]
+			} : {
+				state: { _tag: "Retired" },
+				events: [[current.number, new Kept()]],
+				commands: [{
+					_tag: "Leave",
+					live: current
+				}]
+			};
+		}
+	}
+};
+/**
+* What a caller waiting for generation `target`, or for any when it is undefined, gets in
+* `state`; undefined while it should go on waiting.
+*/
+const resolve = (state, target) => {
+	const serve = (live) => ({
+		_tag: "Serve",
+		live
+	});
+	switch (state._tag) {
+		case "Retired": return {
+			_tag: "Unavailable",
+			reason: "retired",
+			detail: "the supervisor was retired"
+		};
+		case "Open": return target === void 0 || state.serving.number >= target ? serve(state.serving) : void 0;
+		case "Opening": return target === void 0 && state.serving !== void 0 ? serve(state.serving) : void 0;
+		case "Down":
+			if (target === void 0 && state.serving !== void 0) return serve(state.serving);
+			return target === void 0 || state.number >= target ? {
+				_tag: "Unavailable",
+				reason: "down",
+				detail: state.detail,
+				cause: state.cause
+			} : void 0;
+	}
+};
+//#endregion
+//#region src/Supervisor.ts
+/**
+* A browser kept open across losses and session ends, as a series of generations, each a new
+* browser from the same provider. Pages don't carry over from one generation to the next.
+*
+* `make` opens the first generation at once with the provider's `open`, in a scope of its own, so
+* a caller that stops waiting never interrupts a half-open browser. `browser` gives the current
+* generation; callers wait, bounded, and share one open. A loss is published at once and the next
+* generation opens on the `reopen` schedule, which also retries a failed open, unless the provider
+* deems its failure `definite`: that goes `Down` at once, with its cause. `rotate` opens the
+* next generation now, and so does the time `rotateBefore` ahead of a generation's `expiresAt`. A
+* rotation makes the next generation before it breaks the current one, unless generations are
+* `exclusive`, as sessions saving to one stored context must be: then the current one is released
+* first. `retire` stops reopening at once and releases what is open; the scope's close retires
+* too, unless the supervisor `keep`s: then it leaves the serving generation running, `Kept`. `states`
+* publishes each generation's changes, with the provider's release outcome last.
+*
+* Providers supply the specifics: `Browserbase.supervise` opens hosted sessions this way.
+*
+* @since 0.3.0
+*/
+var Supervisor_exports = /* @__PURE__ */ __exportAll({
+	Closed: () => Closed,
+	Down: () => Down,
+	Generation: () => Generation,
+	GenerationState: () => GenerationState,
+	Kept: () => Kept,
+	Lost: () => Lost,
+	Open: () => Open,
+	Opening: () => Opening,
+	Released: () => Released,
+	Reopening: () => Reopening,
+	Settled: () => Settled,
+	Unavailable: () => Unavailable,
+	Unconfirmed: () => Unconfirmed,
+	make: () => make
+});
+/** One change in a generation's life. `at` is wall-clock epoch milliseconds from the Effect `Clock`. */
+var Generation = class extends Schema.Class("effect-browser/Generation")({
+	number: Schema.Int.check(Schema.isGreaterThan(0)),
+	at: Schema.Finite,
+	state: GenerationState
+}) {};
+/**
+* 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.
+*/
+var Unavailable = class extends Schema.TaggedError()("Unavailable", {
+	reason: Schema.Literals([
+		"opening",
+		"down",
+		"retired"
+	]),
+	detail: Schema.String,
+	cause: Schema.optional(Schema.Defect())
+}) {
+	get message() {
+		return `no browser: ${this.detail}`;
+	}
+};
+const retired = () => new Unavailable({
+	reason: "retired",
+	detail: "the supervisor was retired"
+});
+const describe = (cause) => {
+	const error = Cause.squash(cause);
+	return Predicate.isError(error) ? error.message : String(error);
+};
+/**
+* Wait up to `waitTimeout` for generation `target`, or for any when it is undefined, as `state`
+* changes.
+*/
+const waitFor = (state, waitTimeout, target) => SubscriptionRef.changes(state).pipe(Stream.map((current) => resolve(current, target)), Stream.filter(Predicate.isNotUndefined), Stream.runHead, Effect.flatMap(Option.match({
+	onNone: () => Effect.fail(retired()),
+	onSome: (resolution) => resolution._tag === "Serve" ? Effect.succeed(resolution.live.value.opened.browser) : Effect.fail(new Unavailable({
+		reason: resolution.reason,
+		detail: resolution.detail,
+		cause: resolution.cause
+	}))
+})), Effect.timeoutOrElse({
+	duration: waitTimeout,
+	orElse: () => Effect.fail(new Unavailable({
+		reason: "opening",
+		detail: `no generation opened within ${Duration.format(waitTimeout)}`
+	}))
+}));
+/** Sleep until `before` ahead of `expiresAt`, but no sooner than halfway there from now. */
+const untilRotation = (expiresAt, before) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => {
+	const left = DateTime.toEpochMillis(expiresAt) - now;
+	return Effect.sleep(Duration.millis(Math.max(left - Duration.toMillis(before), left / 2, 0)));
+}));
+/** Supervise generations of a provider's browser for as long as the scope is open. */
+const make = Effect.fn("Supervisor.make")(function* (options) {
+	const clock = yield* Clock.Clock;
+	const context = yield* Effect.context();
+	const own = yield* Scope.fork(yield* Effect.scope);
+	const exclusive = options.exclusive ?? false;
+	const definite = options.definite ?? (() => false);
+	const reopen = options.reopen ?? Schedule.exponential("1 second").pipe(Schedule.upTo({ duration: Duration.minutes(5) }));
+	const rotateBefore = options.rotateBefore === void 0 ? void 0 : Duration.fromInputUnsafe(options.rotateBefore);
+	const waitTimeout = Duration.fromInputUnsafe(options.waitTimeout ?? Duration.minutes(2));
+	const started = start();
+	const state = yield* SubscriptionRef.make(started.state);
+	const events = yield* PubSub.unbounded({ replay: 64 });
+	const opening = yield* FiberHandle.make();
+	const releases = yield* FiberMap.make();
+	const runOpen = yield* FiberHandle.runtime(opening)();
+	const runRelease = yield* FiberMap.runtime(releases)();
+	const apply = (input) => SubscriptionRef.modifyEffect(state, (current) => {
+		const step = transition(current, input, exclusive);
+		return Effect.as(perform(step), [step.reply, step.state]);
+	}).pipe(Effect.uninterruptible);
+	const perform = (step) => Effect.gen(function* () {
+		for (const [number, generation] of step.events) PubSub.publishUnsafe(events, [new Generation({
+			number,
+			at: clock.currentTimeMillisUnsafe(),
+			state: generation
+		})]);
+		for (const command of step.commands) switch (command._tag) {
+			case "Open":
+				runOpen(openGeneration(command.number, command.after));
+				break;
+			case "Watch":
+				yield* Effect.forkIn(Effect.provideContext(watch(command.live), context), command.live.value.scope);
+				break;
+			case "Release":
+				runRelease(command.live.number, release(command.live));
+				break;
+			case "Leave": runRelease(command.live.number, Scope.close(command.live.value.scope, Exit.void));
+		}
+	});
+	const openOnce = Effect.uninterruptibleMask((restore) => Effect.flatMap(Scope.fork(own), (scope) => restore(options.open.pipe(Scope.provide(scope), Effect.provideContext(context))).pipe(Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))), Effect.map((opened) => ({
+		opened,
+		scope
+	})))));
+	const openGeneration = (number, after) => Effect.uninterruptibleMask((restore) => {
+		const previous = after === void 0 ? Effect.void : FiberMap.get(releases, after).pipe(Effect.flatMap(Option.match({
+			onNone: () => Effect.void,
+			onSome: Fiber.await
+		})));
+		const tries = Effect.retry(openOnce, {
+			schedule: reopen,
+			while: (error) => !definite(error)
+		});
+		return restore(previous.pipe(Effect.andThen(tries))).pipe(Effect.exit, Effect.flatMap((exit) => {
+			if (Exit.isSuccess(exit)) return apply({
+				_tag: "Opened",
+				live: {
+					number,
+					value: exit.value
+				}
+			});
+			return Cause.hasInterruptsOnly(exit.cause) ? apply({
+				_tag: "Abandoned",
+				number
+			}) : apply({
+				_tag: "Failed",
+				number,
+				detail: describe(exit.cause),
+				cause: Cause.squash(exit.cause)
+			});
+		}));
+	});
+	const watch = (live) => {
+		const { browser } = live.value.opened;
+		const loss = browser.disconnected.pipe(Effect.flatMap((cause) => apply({
+			_tag: "Lost",
+			number: live.number,
+			cause
+		})));
+		const rotation = browser.expiresAt === void 0 || rotateBefore === void 0 ? Effect.void : untilRotation(browser.expiresAt, rotateBefore).pipe(Effect.andThen(apply({
+			_tag: "Rotate",
+			due: live.number
+		})));
+		return Effect.all([loss, rotation], {
+			concurrency: 2,
+			discard: true
+		});
+	};
+	const release = (live) => (live.value.opened.release ?? Effect.succeed(new Settled())).pipe(Effect.catchCause((cause) => Effect.succeed(new Unconfirmed({ detail: `the release failed: ${describe(cause)}` }))), Effect.ensuring(Scope.close(live.value.scope, Exit.void)), Effect.flatMap((released) => apply({
+		_tag: "Released",
+		number: live.number,
+		released
+	})));
+	const end = yield* Effect.cached(PubSub.publish(events, Exit.void));
+	const stop = (input) => apply(input).pipe(Effect.andThen(FiberHandle.clear(opening)), Effect.andThen(FiberMap.awaitEmpty(releases)), Effect.andThen(end), Effect.asVoid);
+	const retire = yield* Effect.cached(stop({ _tag: "Retire" }));
+	yield* Effect.addFinalizer(() => options.keep === true ? stop({ _tag: "Keep" }) : retire);
+	yield* perform(started);
+	return {
+		browser: waitFor(state, waitTimeout, void 0),
+		states: Stream.fromPubSubTake(events),
+		rotate: apply({ _tag: "Rotate" }).pipe(Effect.flatMap((target) => target === void 0 ? Effect.fail(retired()) : waitFor(state, waitTimeout, target))),
+		retire
+	};
+});
+//#endregion
+export { Closed as a, Kept as c, Opening as d, Released as f, Unconfirmed as h, make as i, Lost as l, Settled as m, Supervisor_exports as n, Down as o, Reopening as p, Unavailable as r, GenerationState as s, Generation as t, Open as u };
+
+//# sourceMappingURL=Supervisor-BtEG93gR.mjs.map