effect-browser 0.3.0-beta.7 → 0.3.0-beta.9

package/dist/Supervisor-TNKNOVzu.mjs

@@ -0,0 +1,599 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { DisconnectCause } from "./BrowserEvent.mjs";
+import { Cause, Clock, DateTime, Deferred, Duration, Effect, Exit, FiberHandle, FiberMap, Option, Predicate, PubSub, Schedule, Schema, Scope, Semaphore, 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", {}) {};
+/** No longer serving; holds end at this host-monotonic deadline or when their owners let go. */
+var Draining = class extends Schema.TaggedClass()("Draining", {
+	reason: Schema.Literals([
+		"rotated",
+		"lost",
+		"retired"
+	]),
+	revokeAt: Schema.Finite
+}) {};
+/** 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,
+	Draining,
+	Lost,
+	Down,
+	Closed,
+	Kept
+]);
+const start = () => ({
+	state: {
+		_tag: "Opening",
+		number: 1,
+		serving: void 0,
+		draining: /* @__PURE__ */ new Map()
+	},
+	events: [[1, new Opening()]],
+	commands: [{
+		_tag: "Open",
+		number: 1,
+		after: void 0
+	}]
+});
+const servingOf = (state) => state._tag === "Retired" ? void 0 : state.serving;
+/** The holds still owned for a generation, including one whose release has begun. */
+const lookup = (state, number) => servingOf(state)?.number === number ? servingOf(state) : state.draining.get(number)?.live;
+/** The sole writer of a drain's ending and phase; each release command is emitted once. */
+const draining = (change, drain) => {
+	const before = change.state.draining.get(drain.live.number);
+	const { live, ending, _tag } = drain;
+	change.state = {
+		...change.state,
+		draining: new Map(change.state.draining).set(live.number, drain)
+	};
+	if (before?.ending !== ending) {
+		change.events.push([live.number, ending]);
+		change.commands.push({
+			_tag: "Drain",
+			live,
+			ending
+		});
+	}
+	if (_tag !== "Draining" && before?._tag !== _tag) change.commands.push({
+		_tag: _tag === "Leaving" ? "Leave" : "Release",
+		live,
+		ending
+	});
+};
+const end = (change, live, reason, keep = false) => {
+	const ending = new Draining({
+		reason,
+		revokeAt: change.now + (reason === "rotated" ? change.handover : 0)
+	});
+	draining(change, {
+		live,
+		ending,
+		_tag: keep ? "Leaving" : live.holds.size === 0 || ending.revokeAt <= change.now ? "Releasing" : "Draining"
+	});
+};
+const revoke = (change, number, reason) => {
+	const drain = change.state.draining.get(number);
+	if (drain?._tag !== "Draining" || reason === void 0 && change.now < drain.ending.revokeAt) return;
+	draining(change, {
+		...drain,
+		_tag: "Releasing",
+		ending: reason === void 0 ? drain.ending : new Draining({
+			reason,
+			revokeAt: change.now
+		})
+	});
+};
+const holds = (change, input) => {
+	const number = input.number ?? servingOf(change.state)?.number;
+	const live = number === void 0 ? void 0 : lookup(change.state, number);
+	if (live === void 0) return;
+	const drain = change.state.draining.get(live.number);
+	if (input._tag === "Hold" && drain !== void 0 && (drain._tag !== "Draining" || change.now >= drain.ending.revokeAt)) return;
+	if (live.holds.has(input.hold) === (input._tag === "Hold")) return;
+	const holds = new Set(live.holds);
+	if (input._tag === "Hold") {
+		holds.add(input.hold);
+		change.borrowed = live;
+	} else holds.delete(input.hold);
+	const held = {
+		...live,
+		holds
+	};
+	if (drain !== void 0) draining(change, {
+		...drain,
+		live: held,
+		_tag: drain._tag === "Draining" && holds.size === 0 ? "Releasing" : drain._tag
+	});
+	else if (change.state._tag !== "Retired") change.state = {
+		...change.state,
+		serving: held
+	};
+};
+const next = (change, number, reopen) => {
+	const { exclusive } = change;
+	const current = servingOf(change.state);
+	const after = exclusive ? current?.number ?? change.state.draining.keys().next().value : void 0;
+	if (current !== void 0 && (reopen || exclusive)) end(change, current, reopen ? "lost" : "rotated");
+	change.state = {
+		_tag: "Opening",
+		number,
+		serving: reopen || exclusive ? void 0 : current,
+		draining: change.state.draining
+	};
+	change.events.push([number, reopen ? new Reopening() : new Opening()]);
+	change.commands.push({
+		_tag: "Open",
+		number,
+		after
+	});
+};
+const lost = (change, input) => {
+	const { state } = change;
+	const drain = state.draining.get(input.number);
+	const current = servingOf(state);
+	if (drain?._tag === "Draining") {
+		change.events.push([input.number, new Lost({ cause: input.cause })]);
+		revoke(change, input.number, "lost");
+	} else if (state._tag !== "Retired" && current?.number === input.number) {
+		change.events.push([input.number, new Lost({ cause: input.cause })]);
+		if (state._tag !== "Opening") next(change, (state._tag === "Open" ? current.number : state.number) + 1, true);
+		else {
+			change.state = {
+				...state,
+				serving: void 0
+			};
+			end(change, current, "lost");
+		}
+	}
+};
+/** Pure admission and lifecycle changes. A rejected hold preserves state identity. */
+const transition = (state, input, exclusive, now = 0, handover = 3e4) => {
+	const change = {
+		state,
+		events: [],
+		commands: [],
+		exclusive,
+		handover,
+		now
+	};
+	switch (input._tag) {
+		case "Hold":
+		case "Let":
+			holds(change, input);
+			break;
+		case "Revoke":
+			revoke(change, input.number);
+			break;
+		case "Opened": {
+			const live = {
+				...input.live,
+				holds: /* @__PURE__ */ new Set()
+			};
+			if (lookup(state, live.number) !== void 0) break;
+			if (state._tag !== "Opening" || state.number !== live.number) end(change, live, "retired");
+			else {
+				change.events.push([live.number, new Open()]);
+				change.commands.push({
+					_tag: "Watch",
+					live
+				});
+				if (state.serving !== void 0) end(change, state.serving, "rotated");
+				change.state = {
+					_tag: "Open",
+					serving: live,
+					draining: change.state.draining
+				};
+			}
+			break;
+		}
+		case "Failed": {
+			const { number, detail, cause } = input;
+			if (state._tag === "Opening" && state.number === number) change.state = {
+				...state,
+				_tag: "Down",
+				detail,
+				cause
+			};
+			change.events.push([number, new Down({
+				detail,
+				cause
+			})]);
+			break;
+		}
+		case "Abandoned":
+			change.events.push([input.number, new Closed({})]);
+			break;
+		case "Released": {
+			const drain = state.draining.get(input.number);
+			if (drain === void 0 || drain._tag === "Draining" || drain.live.holds.size > 0) break;
+			const draining = new Map(state.draining);
+			draining.delete(input.number);
+			change.state = {
+				...state,
+				draining
+			};
+			change.events.push([input.number, input.released === void 0 ? new Kept() : new Closed({ released: input.released })]);
+			break;
+		}
+		case "Lost":
+			lost(change, input);
+			break;
+		case "Rotate":
+			if (state._tag === "Retired" || input.due !== void 0 && (state._tag !== "Open" || state.serving.number !== input.due)) break;
+			change.reply = state._tag === "Opening" ? state.number : (state._tag === "Open" ? state.serving.number : state.number) + 1;
+			if (state._tag !== "Opening") next(change, change.reply, false);
+			break;
+		case "Keep":
+		case "Retire":
+			if (state._tag === "Retired") break;
+			for (const number of state.draining.keys()) revoke(change, number, "retired");
+			if (state.serving !== void 0) end(change, state.serving, "retired", input._tag === "Keep");
+			change.state = {
+				_tag: "Retired",
+				draining: change.state.draining
+			};
+	}
+	return change;
+};
+/** An unheld browser resolution; use obtains its hold atomically through Hold instead. */
+const resolve = (state, target) => {
+	if (state._tag === "Retired") return {
+		_tag: "Unavailable",
+		reason: "retired",
+		detail: "the supervisor was retired"
+	};
+	if (state.serving !== void 0 && (target === void 0 || state._tag === "Open" && state.serving.number >= target)) return {
+		_tag: "Serve",
+		live: state.serving
+	};
+	if (state._tag === "Down" && (target === void 0 || state.number >= target)) return {
+		_tag: "Unavailable",
+		reason: "down",
+		detail: state.detail,
+		cause: state.cause
+	};
+};
+//#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,
+	Draining: () => Draining,
+	Generation: () => Generation,
+	GenerationState: () => GenerationState,
+	Kept: () => Kept,
+	Lost: () => Lost,
+	Open: () => Open,
+	Opening: () => Opening,
+	Released: () => Released,
+	Reopening: () => Reopening,
+	Settled: () => Settled,
+	Superseded: () => Superseded,
+	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,
+	hostTime: 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}`;
+	}
+};
+/** Work whose generation was revoked; input receipts still determine whether input reached a site. */
+var Superseded = class extends Schema.TaggedError()("Superseded", {
+	generation: Schema.Int,
+	reason: Schema.Literals([
+		"rotated",
+		"lost",
+		"retired"
+	]),
+	revokeAt: Schema.Finite
+}) {};
+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);
+};
+const unavailable = (resolution) => new Unavailable({
+	reason: resolution.reason,
+	detail: resolution.detail,
+	cause: resolution.cause
+});
+const timedOut = () => new Unavailable({
+	reason: "opening",
+	detail: "no generation opened within the wait"
+});
+const bounded = (input, name) => Effect.suspend(() => {
+	const duration = Duration.fromInput(input);
+	return Option.isSome(duration) && Duration.isFinite(duration.value) && !Duration.isNegative(duration.value) ? Effect.succeed(duration.value) : Effect.die(/* @__PURE__ */ new RangeError(`${name} must be a finite nonnegative duration`));
+});
+/** Resolve immediately before starting a bounded wait, including when its duration is zero. */
+const waitFor = (state, wait, clock, target) => {
+	const result = (resolution) => resolution._tag === "Serve" ? Effect.succeed(resolution.live) : Effect.fail(unavailable(resolution));
+	return Effect.suspend(() => {
+		const current = resolve(state.value, target);
+		return current === void 0 ? SubscriptionRef.changes(state).pipe(Stream.map((state) => resolve(state, target)), Stream.filter(Predicate.isNotUndefined), Stream.runHead, Effect.flatMap(Option.match({
+			onNone: () => Effect.fail(retired()),
+			onSome: result
+		})), Effect.timeoutOrElse({
+			duration: wait,
+			orElse: () => Effect.fail(timedOut())
+		})) : result(current);
+	}).pipe(Effect.provideService(Clock.Clock, clock));
+};
+/** 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)));
+}));
+/** Native timers may wake a fraction early; a revocation must reach its monotonic deadline. */
+const until = (at, now) => Effect.suspend(() => now() >= at ? Effect.void : Effect.sleep(Duration.millis(Math.ceil(at - now()))).pipe(Effect.andThen(until(at, now))));
+/** Borrowed work and transferred scopes hold a generation until cleanup lets it go. */
+const leasing = (state, apply, waitTimeout, now, clock) => {
+	const borrow = (hold, wait) => Effect.gen(function* () {
+		const until = now() + Duration.toMillis(wait);
+		for (;;) {
+			const step = yield* apply({
+				_tag: "Hold",
+				hold
+			});
+			if (step.borrowed !== void 0) return step.borrowed;
+			yield* waitFor(state, Duration.millis(Math.max(0, until - now())), clock).pipe(Effect.interruptible);
+			if (now() >= until) return yield* timedOut();
+		}
+	});
+	const leaseOf = (live) => ({
+		generation: live.number,
+		browser: live.value.opened.browser,
+		value: live.value.opened.value,
+		ending: Deferred.await(live.value.ending),
+		retain: Effect.uninterruptible(Effect.gen(function* () {
+			const scope = yield* Scope.make();
+			const hold = {
+				_tag: "Retained",
+				scope
+			};
+			if ((yield* apply({
+				_tag: "Hold",
+				number: live.number,
+				hold
+			})).borrowed === void 0) {
+				yield* Scope.close(scope, Exit.void);
+				return yield* yield* Deferred.await(live.value.ending);
+			}
+			yield* Scope.addFinalizer(scope, apply({
+				_tag: "Let",
+				number: live.number,
+				hold
+			}).pipe(Effect.asVoid));
+			return scope;
+		}))
+	});
+	const use = (work, options = {}) => Effect.scoped(Effect.gen(function* () {
+		const hold = { _tag: "Use" };
+		const wait = yield* bounded(options.wait ?? waitTimeout, "wait");
+		const live = yield* Effect.acquireRelease(borrow(hold, wait), (live) => apply({
+			_tag: "Let",
+			number: live.number,
+			hold
+		}).pipe(Effect.asVoid));
+		return yield* Effect.raceFirst(work(leaseOf(live)), Deferred.await(live.value.revoked).pipe(Effect.flatMap(Effect.fail)));
+	}));
+	return use;
+};
+const acquireGeneration = (open, own) => Effect.uninterruptibleMask((restore) => Effect.flatMap(Scope.fork(own), (scope) => restore(open.pipe(Scope.provide(scope))).pipe(Effect.onError((cause) => Scope.close(scope, Exit.failCause(cause))), Effect.map((opened) => ({
+	opened: {
+		...opened,
+		value: "value" in opened ? opened.value : void 0
+	},
+	scope,
+	ending: Deferred.makeUnsafe(),
+	revoked: Deferred.makeUnsafe()
+})))));
+const changedUntil = (state, predicate) => SubscriptionRef.changes(state).pipe(Stream.filter(predicate), Stream.runHead, Effect.asVoid);
+const watchGeneration = (live, rotateBefore, apply) => {
+	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 releaseGeneration = (command, state, apply) => Effect.gen(function* () {
+	const { live, ending } = command;
+	yield* Deferred.succeed(live.value.revoked, new Superseded({
+		generation: live.number,
+		reason: ending.reason,
+		revokeAt: ending.revokeAt
+	}));
+	const holds = lookup(state.value, live.number)?.holds ?? [];
+	const cleaned = yield* Effect.forEach(holds, (hold) => Effect.exit(hold._tag === "Retained" ? Scope.close(hold.scope, Exit.void) : Effect.void), { concurrency: 8 });
+	yield* changedUntil(state, (current) => (lookup(current, live.number)?.holds.size ?? 0) === 0);
+	const released = command._tag === "Leave" ? void 0 : yield* (live.value.opened.release ?? Effect.succeed(new Settled())).pipe(Effect.catchCause((cause) => Effect.succeed(new Unconfirmed({ detail: `the release failed: ${describe(cause)}` }))));
+	const closed = yield* Effect.exit(Scope.close(live.value.scope, Exit.void));
+	yield* apply({
+		_tag: "Released",
+		number: live.number,
+		released
+	});
+	yield* Exit.asVoidAll([...cleaned, closed]);
+});
+const makeScoped = Effect.fn("Supervisor.make")(function* (options) {
+	const clock = yield* Clock.Clock;
+	const now = () => Number(clock.monotonicTimeNanosUnsafe()) / 1e6;
+	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 = yield* bounded(options.waitTimeout ?? Duration.minutes(2), "waitTimeout");
+	const handover = Duration.toMillis(yield* bounded(options.handover ?? Duration.seconds(30), "handover"));
+	const started = start();
+	const state = yield* SubscriptionRef.make(started.state);
+	const applying = yield* Semaphore.make(1);
+	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) => applying.withPermit(Effect.gen(function* () {
+		const current = state.value;
+		const step = transition(current, input, exclusive, now(), handover);
+		if (step.state !== current) yield* SubscriptionRef.set(state, step.state);
+		yield* perform(step);
+		return step;
+	})).pipe(Effect.uninterruptible, Effect.provideService(Clock.Clock, clock));
+	const perform = (step) => Effect.gen(function* () {
+		for (const [number, generation] of step.events) PubSub.publishUnsafe(events, [new Generation({
+			number,
+			at: clock.currentTimeMillisUnsafe(),
+			hostTime: now(),
+			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(watchGeneration(command.live, rotateBefore, apply), context), command.live.value.scope);
+				break;
+			case "Drain": {
+				const ending = new Superseded({
+					generation: command.live.number,
+					reason: command.ending.reason,
+					revokeAt: command.ending.revokeAt
+				});
+				yield* Deferred.succeed(command.live.value.ending, ending);
+				yield* Effect.forkIn(until(ending.revokeAt, now).pipe(Effect.andThen(Effect.suspend(() => apply({
+					_tag: "Revoke",
+					number: command.live.number
+				})))), command.live.value.scope);
+				break;
+			}
+			case "Release":
+			case "Leave": runRelease(command.live.number, releaseGeneration(command, state, apply));
+		}
+	});
+	const openOnce = acquireGeneration(options.open, own).pipe(Effect.provideContext(context));
+	const openGeneration = (number, after) => Effect.uninterruptibleMask((restore) => restore((after === void 0 ? Effect.void : changedUntil(state, (current) => !current.draining.has(after))).pipe(Effect.andThen(Effect.retry(openOnce, {
+		schedule: reopen,
+		while: (error) => !definite(error)
+	})))).pipe(Effect.exit, Effect.flatMap((exit) => Exit.isSuccess(exit) ? apply({
+		_tag: "Opened",
+		live: {
+			number,
+			value: exit.value
+		}
+	}) : Cause.hasInterruptsOnly(exit.cause) ? apply({
+		_tag: "Abandoned",
+		number
+	}) : apply({
+		_tag: "Failed",
+		number,
+		detail: describe(exit.cause),
+		cause: Cause.squash(exit.cause)
+	}))));
+	const use = leasing(state, apply, waitTimeout, now, clock);
+	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(Effect.suspend(() => Deferred.isDone(releases.deferred).pipe(Effect.flatMap((failed) => failed ? FiberMap.join(releases) : Effect.void)))), Effect.ensuring(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: Effect.map(waitFor(state, waitTimeout, clock), (live) => live.value.opened.browser),
+		use,
+		states: Stream.fromPubSubTake(events),
+		rotate: apply({ _tag: "Rotate" }).pipe(Effect.flatMap(({ reply }) => reply === void 0 ? Effect.fail(retired()) : Effect.map(waitFor(state, waitTimeout, clock, reply), (live) => live.value.opened.browser))),
+		retire
+	};
+});
+function make(options) {
+	return makeScoped(options);
+}
+//#endregion
+export { Unconfirmed as _, make as a, Draining as c, Lost as d, Open as f, Settled as g, Reopening as h, Unavailable as i, GenerationState as l, Released as m, Superseded as n, Closed as o, Opening as p, Supervisor_exports as r, Down as s, Generation as t, Kept as u };
+
+//# sourceMappingURL=Supervisor-TNKNOVzu.mjs.map