effect-browser 0.3.0-beta.13 → 0.3.0-beta.14

package/dist/{page-ZxMhw16l.mjs → page-B92QnRfT.mjs}

@@ -1,7 +1,7 @@
 import { Plan } from "./Motion.mjs";
 import { Action, Box, CursorChanged, KeyChanged, Navigated, PageLoaded, PointerPressed, PointerReleased, Subject, SubjectContext, TextInserted, TrackEvent, TrackPerformed, TrackPlanned, WheelScrolled } from "./BrowserEvent.mjs";
 import { BrowserError, Failed, InvalidRequest, NavigationFailed, NotActionable, NotFound, PolicyTimeout, StaleRef, Timeout } from "./BrowserError.mjs";
-import { a as make$19, c as Current, i as failWith, l as make$18, n as contextGone, o as reasonOf, r as decodeWith, s as undispatched } from "./context-BAjRj7Xo.mjs";
+import { a as make$20, c as Current, i as failWith, l as make$19, n as contextGone, o as reasonOf, r as decodeWith, s as undispatched } from "./context-BAjRj7Xo.mjs";
 import { i as redact, n as parse, s as Correlation, t as addresses } from "./url-Cd04Okid.mjs";
 import { BrowserPaint, CaptureStats, Frame, Image, Screenshot } from "./Frame.mjs";
 import { _ as evidence, c as State, g as guard, h as ValidatedInputResultSchema, i as InputRequest, l as Text, m as PreparedInputResultSchema, o as Region, p as redacted, r as Found, s as ResolvedTarget, u as Zoom } from "./Page-B5cjaUp5.mjs";
@@ -9,7 +9,7 @@ import { Snapshot } from "./Snapshot.mjs";
 import { t as match } from "./match.inpage-xOe9LNO0.mjs";
 import { r as Changes, t as Change } from "./Change-DNvztNLu.mjs";
 import { Window } from "./Moment.mjs";
-import { Clock, Deferred, Duration, Effect, Exit, MutableRef, Option, Queue, Random, Ref, Result, Schedule, Schema, Scope, Semaphore, Stream, SynchronizedRef } from "effect";
+import { Cause, Clock, Deferred, Duration, Effect, Exit, Fiber, MutableRef, Option, Queue, Random, Ref, Result, Schedule, Schema, Scope, Semaphore, Stream, SynchronizedRef } from "effect";
 //#region src/internal/input/edit.inpage.ts
 /**
 * In the page: editing a field. It refuses text that a focused control could act on, focuses a
@@ -2166,7 +2166,7 @@ const mainFrame = (page, event) => "frame" in event ? event.frame.parentId === v
 } : void 0;
 /** A call to the page script, its arguments quoted as JavaScript literals. */
 const scriptCall = (name, ...args) => `${name}(${args.map((arg) => JSON.stringify(arg)).join(", ")})`;
-const make$17 = Effect.fnUntraced(function* (page) {
+const make$18 = Effect.fnUntraced(function* (page) {
 	const { id, cdp, native, span, publish, now } = page;
 	const { send } = page.protocol;
 	const registration = yield* SynchronizedRef.make("none");
@@ -2352,7 +2352,7 @@ const toBrowserSeconds = (calibration, hostMillis) => (hostMillis + calibration.
 * protocol session, stamped with the browser's clock when its run has a mapping, and is published
 * as it is submitted.
 */
-const make$16 = (page) => {
+const make$17 = (page) => {
 	const { id, pointer, publish, now, noteInput, closedBy } = page;
 	const { send } = page.protocol;
 	const inputClocks = /* @__PURE__ */ new WeakMap();
@@ -2458,7 +2458,7 @@ const inputFailure = (operation, targets, failure) => {
 	return failWith(operation, failure.error === "outside" ? new InvalidRequest({ detail: failure.detail }) : failure.error === "stale" && typeof target === "string" ? new StaleRef({ ref: target }) : new NotActionable({ detail: failure.detail }));
 };
 const editFailure = (operation, ref, failure) => failWith(operation, failure.stale === true ? new StaleRef({ ref }) : new NotActionable({ detail: failure.error }));
-const make$15 = (page, bridge) => {
+const make$16 = (page, bridge) => {
 	const { id } = page;
 	const { current, evaluateIn, evaluateWithContext } = bridge;
 	const preparePolicy = (action, info, targets, flags = {}) => Effect.gen(function* () {
@@ -2686,7 +2686,7 @@ const description = (character) => {
 * Keys and typing: a key chord held and released, each typed event, and the document a run of
 * keys must stay in.
 */
-const make$14 = (page, bridge, dispatch) => {
+const make$15 = (page, bridge, dispatch) => {
 	const { playwright } = page;
 	const { send } = page.protocol;
 	const { currentDocument } = bridge;
@@ -2893,7 +2893,7 @@ const timedOut = (operation, timeout) => failWith(operation, new Timeout({ milli
 * Fail `effect` with `Timeout` once `timeout` has passed, and as much later again as `presented`
 * says presentation has planned meanwhile.
 */
-const deadline$1 = (operation, timeout, now, presented) => (effect) => Effect.suspend(() => {
+const deadline$2 = (operation, timeout, now, presented) => (effect) => Effect.suspend(() => {
 	const due = now() + Duration.toMillis(timeout);
 	const expiry = Effect.suspend(() => {
 		const left = due + presented() - now();
@@ -2931,10 +2931,10 @@ const useRun = (page, sender, name, run, action) => action.pipe(Effect.matchEffe
 	onFailure: (error) => run.close.pipe(Effect.andThen(sender.flush(name, run).pipe(Effect.ignore)), Effect.andThen(Effect.fail(error))),
 	onSuccess: (value) => run.close.pipe(Effect.andThen(sender.flush(name, run)), Effect.as(value))
 }), Effect.ensuring(run.close.pipe(Effect.andThen(page.openings.clear))), Effect.provideService(Current, run));
-const make$13 = (page, sender) => {
+const make$14 = (page, sender) => {
 	const { id, settings, mapping, lane, publish, now, noteInput, span, owned } = page;
 	const { inputClocks } = sender;
-	const input = make$18();
+	const input = make$19();
 	const admitted = /* @__PURE__ */ new Set();
 	const perform = (name, info, timeout, prepare, body, style = plain) => Effect.gen(function* () {
 		const startedAt = now();
@@ -2974,14 +2974,14 @@ const make$13 = (page, sender) => {
 				orElse: () => timedOut(name, timeout)
 			})))), Effect.tap(() => Effect.sync(() => {
 				queuedMillis = Math.round(now() - asked);
-			})), Effect.andThen(deadline$1(name, timeout, now, () => presented)(action))));
+			})), Effect.andThen(deadline$2(name, timeout, now, () => presented)(action))));
 		});
 		const guard = settings.guard;
 		const action = guard === void 0 ? dispatch(useInput((run) => body({
 			...marks,
 			input: run
 		}, void 0))) : Effect.gen(function* () {
-			const plan = yield* lane.read(name)(deadline$1(name, settings.actionTimeout, now, () => 0)(prepare)).pipe(span("Page.prepare", {}, "Debug"));
+			const plan = yield* lane.read(name)(deadline$2(name, settings.actionTimeout, now, () => 0)(prepare)).pipe(span("Page.prepare", {}, "Debug"));
 			yield* guard(plan.request).pipe(Effect.mapError((reason) => undispatched(name, reason)), Effect.timeoutOrElse({
 				duration: settings.policyTimeout,
 				orElse: () => failWith(name, new PolicyTimeout({ millis: Duration.toMillis(settings.policyTimeout) }))
@@ -3049,7 +3049,7 @@ const make$13 = (page, sender) => {
 * plan, published before its first move, from where viewers last saw the pointer when it is
 * shown, and a wheel scroll goes in the style's steps.
 */
-const make$12 = (page, dispatch, viewport) => {
+const make$13 = (page, dispatch, viewport) => {
 	const { id, pointer, publish, now, span } = page;
 	const { inputClocks, inputCall, dispatchMouse, sendMouse } = dispatch;
 	const moveTo = (operation, marks, to, cursor, travel = "approach") => Effect.gen(function* () {
@@ -3146,8 +3146,8 @@ const make$12 = (page, dispatch, viewport) => {
 * `pushState` asks for no document, and a navigation a handler starts after a fetch answers is the
 * next look's to see. A tab the input opened waits for the browser's registration too.
 */
-const settling$1 = Duration.seconds(5);
-const make$11 = (page, bridge) => {
+const settling = Duration.seconds(5);
+const make$12 = (page, bridge) => {
 	const document = () => bridge.frameTag().document;
 	let parsed = -1;
 	let changed = Deferred.makeUnsafe();
@@ -3166,7 +3166,7 @@ const make$11 = (page, bridge) => {
 		yield* bridge.evaluate(operation, scriptCall("settle")).pipe(Effect.provideService(Current, void 0), Effect.catchIf(contextGone, () => Effect.void), Effect.onError(() => page.stopLoading));
 		while (document() > before.document && parsed < document()) yield* Deferred.await(changed);
 	}).pipe(Effect.timeoutOrElse({
-		duration: settling$1,
+		duration: settling,
 		orElse: () => Effect.fail("unsettled")
 	}), Effect.catch(() => Effect.annotateCurrentSpan("settled", false)), Effect.andThen(page.openings.settle(before.openings)), page.span("Page.settle", {}, "Debug"));
 	return {
@@ -3196,7 +3196,7 @@ const resolvedTarget = (result) => new ResolvedTarget({
 	cursor: result.cursor,
 	...result.href === void 0 ? {} : { href: result.href }
 });
-const make$10 = (bridge, viewport, guard, pointer, dispatch, settling) => {
+const make$11 = (bridge, viewport, guard, pointer, dispatch, settling) => {
 	const { evaluate } = bridge;
 	const { mutate } = guard;
 	const { moveTo, wheel } = pointer;
@@ -3254,20 +3254,20 @@ const buttonMask = {
 	middle: 4
 };
 const partsOf = (page, bridge, viewport) => {
-	const dispatch = make$16(page);
-	const pointer = make$12(page, dispatch, viewport);
-	const guard = make$15(page, bridge);
-	const settling = make$11(page, bridge);
+	const dispatch = make$17(page);
+	const pointer = make$13(page, dispatch, viewport);
+	const guard = make$16(page, bridge);
+	const settling = make$12(page, bridge);
 	return {
 		page,
 		bridge,
 		...settling,
 		viewportFor: viewport.viewportFor,
-		perform: make$13(page, dispatch),
+		perform: make$14(page, dispatch),
 		...guard,
-		...make$10(bridge, viewport, guard, pointer, dispatch, settling),
+		...make$11(bridge, viewport, guard, pointer, dispatch, settling),
 		...pointer,
-		...make$14(page, bridge, dispatch),
+		...make$15(page, bridge, dispatch),
 		sendMouse: dispatch.sendMouse,
 		flush: dispatch.flush
 	};
@@ -3584,7 +3584,7 @@ const select = (input) => {
 		return result.detail;
 	}));
 };
-const make$9 = (page, bridge, viewport) => {
+const make$10 = (page, bridge, viewport) => {
 	const parts = partsOf(page, bridge, viewport);
 	return {
 		perform: parts.perform,
@@ -3689,6 +3689,47 @@ const tally = (now) => {
 	};
 };
 //#endregion
+//#region src/internal/pictures/quiescence.ts
+/** Actual native replies outlive callers; bounded transactions retain them without holding teardown. */
+const deadline$1 = Duration.seconds(2);
+const make$9 = (options) => {
+	const replies = make$19();
+	const pending = /* @__PURE__ */ new Map();
+	const late = (kind) => options.error(/* @__PURE__ */ new Error(`${kind} exceeded its deadline`));
+	const track = (operation, actual, failed) => {
+		const reply = actual.then(() => void 0, failed);
+		pending.set(operation, reply);
+		return reply.finally(() => {
+			if (pending.get(operation) === reply) pending.delete(operation);
+		});
+	};
+	const wait = (operation) => (operation === void 0 ? replies.idle.pipe(Effect.andThen(Effect.promise(() => Promise.all(pending.values())))) : Effect.promise(() => pending.get(operation) ?? Promise.resolve())).pipe(Effect.asVoid, Effect.interruptible, Effect.timeoutOrElse({
+		duration: deadline$1,
+		orElse: () => Effect.fail(late(operation ?? pending.keys().next().value ?? "picture restoration"))
+	}), Effect.provideService(Clock.Clock, options.clock));
+	const excluding = (picture) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		yield* restore(wait());
+		if (options.closed()) return yield* options.error(/* @__PURE__ */ new Error("Target page has been closed"));
+		const current = options.current();
+		const run = yield* replies.begin;
+		const result = yield* restore(options.pause(current).pipe(Effect.andThen(picture), Effect.provideService(Current, run))).pipe(Effect.exit);
+		const cleaned = yield* wait().pipe(Effect.andThen(options.resume(current)), Effect.timeoutOrElse({
+			duration: deadline$1,
+			orElse: () => Effect.fail(late("picture restoration"))
+		}), Effect.provideService(Clock.Clock, options.clock), Effect.exit, Effect.forkChild, Effect.flatMap(Fiber.join));
+		if (Exit.isFailure(cleaned)) options.fail(current, options.error(Cause.squash(cleaned.cause)));
+		if (Exit.isFailure(result)) return yield* Effect.failCause(result.cause);
+		if (Exit.isFailure(cleaned)) return yield* Effect.failCause(cleaned.cause);
+		return result.value;
+	}));
+	return {
+		excluding,
+		idle: wait(),
+		wait,
+		track
+	};
+};
+//#endregion
 //#region src/internal/pictures/capture.ts
 /**
 * One CDP screencast per page, with bounded transport replies and per-reader loss accounting.
@@ -3700,36 +3741,6 @@ const deadline = Duration.seconds(2);
 const sameSize = (left, right) => Math.abs(left.width - right.width) < 1 && Math.abs(left.height - right.height) < 1;
 const sameShape = (image, device) => Math.abs(image.width * device.height - image.height * device.width) < device.width + device.height;
 const outlasting = Duration.seconds(1);
-const excludedFor = Duration.seconds(10);
-const settling = Duration.millis(50);
-/**
-* Chromium draws the library's own clipped pictures into the running screencast. Where Playwright
-* emulates the viewport they keep the page's device size, and its shape when the crop has the
-* viewport's proportions, so nothing in a frame tells them apart: a frame painted, or arriving,
-* while one is taken is left out, the page's own included. A crop on the page's own session is
-* drawn at the crop's size, so there only a frame of another size than the page's is left out.
-*/
-const pictureWindows = (now) => {
-	let windows = [];
-	return {
-		drawn: ({ hostTime, timing, receivedAt }, foreign) => windows.some((window) => {
-			const until = window.until + Duration.toMillis(settling);
-			return (foreign || !window.resized) && (hostTime + timing.uncertaintyMillis >= window.from && hostTime - timing.uncertaintyMillis <= until || receivedAt >= window.from && receivedAt <= until);
-		}),
-		excluding: (picture, resized = false) => Effect.acquireUseRelease(Effect.sync(() => {
-			const window = {
-				from: now(),
-				until: Number.POSITIVE_INFINITY,
-				resized
-			};
-			const since = window.from - Duration.toMillis(excludedFor);
-			windows = [...windows.filter((kept) => kept.until > since), window];
-			return window;
-		}), () => picture, (window) => Effect.sync(() => {
-			window.until = now();
-		}))
-	};
-};
 /**
 * A native frame as readers get it: its picture's size, else the capture's or its device's, and
 * its paint mapped by the browser's newest estimate, which may be older than the frame and says
@@ -3831,7 +3842,6 @@ const sizeFilter = (options, deliver, drop) => Effect.gen(function* () {
 			expected = viewport;
 		},
 		/** Whether a frame of this device size shows the page, as far as the capture knows. */
-		expects: (device) => expected !== null && sameSize(device, expected),
 		offer: (frame, timestamp, image, device) => {
 			if (image !== void 0 && !sameShape(image, device)) {
 				drop(1);
@@ -3895,7 +3905,7 @@ const confirmation = (read, current, why, error) => (frame) => Effect.suspend(()
 		return after.generation === generation && after.replies === 0 && current(frame);
 	}));
 });
-const isCurrent = (frame, generation, latest) => generation !== void 0 && generation.accepting && generation.failure === void 0 && Option.getOrUndefined(latest) === frame && generation.transport.frameTag().document === frame.document;
+const isCurrent = (frame, generation, latest) => generation !== void 0 && generation.phase === "Capturing" && generation.failure === void 0 && Option.getOrUndefined(latest) === frame && generation.transport.frameTag().document === frame.document;
 const currentFrame = (generation, latest) => Option.getOrUndefined(Option.filter(latest, (frame) => isCurrent(frame, generation, latest)));
 /** One reader counts its own missed envelopes without hiding gaps inside stream chunks. */
 const frames = (subscription, baseline, why, missed) => {
@@ -3909,19 +3919,44 @@ const frames = (subscription, baseline, why, missed) => {
 		});
 	})));
 };
+const renewals = Effect.fnUntraced(function* (options) {
+	const renewing = yield* Queue.sliding(1);
+	yield* Queue.take(renewing).pipe(Effect.andThen(options.renew), Effect.andThen(Effect.sleep(Duration.seconds(1))), Effect.provideService(Clock.Clock, options.clock), Effect.forever, Effect.forkScoped);
+	return renewing;
+});
+const receive = (options, current, replies, counts, sizes, renewing, fail) => (native) => {
+	if (current.phase === "Stopped") return;
+	counts.count("received");
+	if (replies.size >= replyCapacity) {
+		fail(current, options.error(/* @__PURE__ */ new Error("screencast acknowledgement capacity exceeded")));
+		return;
+	}
+	const reply = current.transport.acknowledge(native.sessionId).then(() => void 0, (cause) => {
+		if (current.phase !== "Stopped") fail(current, options.error(cause));
+	}).then(() => void replies.delete(reply));
+	replies.add(reply);
+	const browserSeconds = native.metadata.timestamp;
+	const timestamp = browserSeconds === void 0 ? NaN : browserSeconds * 1e3;
+	if (!Number.isFinite(timestamp)) return counts.count("missingTimestamp");
+	if (current.predecessor !== void 0 && timestamp <= current.predecessor) return counts.count("late");
+	Queue.offerUnsafe(renewing, void 0);
+	const { frame, image, device } = timed(options, native, timestamp, current);
+	if (current.phase === "Paused") return counts.count("duringPictures");
+	sizes.offer(frame, timestamp, image, device);
+};
 const make$8 = (options) => Effect.gen(function* () {
 	const lock = yield* Semaphore.make(1);
 	const replies = /* @__PURE__ */ new Set();
 	let generation;
 	const closed = yield* Deferred.make();
-	let unsettledStop;
+	const pageScope = yield* Effect.scope;
+	const isClosed = () => pageScope.state._tag === "Closed" || Deferred.isDoneUnsafe(closed);
 	let latest = Option.none();
 	let history = [];
 	const keepMillis = Duration.toMillis(options.frameHistory);
 	const now = () => Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6;
 	const counts = tally(now);
 	let delivered = 0;
-	const pictures = pictureWindows(now);
 	const current = (frame) => isCurrent(frame, generation, latest);
 	const deliver = (frame, timestamp) => {
 		const current = generation;
@@ -3940,8 +3975,7 @@ const make$8 = (options) => Effect.gen(function* () {
 		});
 	};
 	const sizes = yield* sizeFilter(options, deliver, (frames) => counts.count("foreignSize", frames));
-	const renewing = yield* Queue.sliding(1);
-	yield* Queue.take(renewing).pipe(Effect.andThen(options.renew), Effect.andThen(Effect.sleep(Duration.seconds(1))), Effect.provideService(Clock.Clock, options.clock), Effect.forever, Effect.forkScoped);
+	const renewing = yield* renewals(options);
 	const notifyFailure = (current, failure) => {
 		if (current.failure !== void 0) return;
 		current.failure = failure;
@@ -3949,37 +3983,67 @@ const make$8 = (options) => Effect.gen(function* () {
 			_tag: "Failure",
 			error: failure
 		});
+		stop(current);
 	};
+	const failed = (current) => (cause) => notifyFailure(current, options.error(cause));
+	const stopNative = (current) => pictures.track("screencast stop", current.transport.stop(), failed(current));
+	const startNative = (current) => pictures.track("screencast start", current.transport.start({
+		format: "jpeg",
+		quality: current.quality,
+		...current.size === null ? {} : {
+			maxWidth: current.size.width,
+			maxHeight: current.size.height
+		}
+	}), failed(current));
 	const stop = (current) => {
-		if (!current.accepting) return;
-		current.accepting = false;
+		if (current.phase === "Stopped") return;
+		const paused = current.phase === "Paused";
+		current.phase = "Stopped";
 		sizes.end();
 		current.unlisten();
-		const reply = current.transport.stop().then(() => void 0, (cause) => {
-			notifyFailure(current, options.error(cause));
-		});
-		current.stopReply = reply;
-		unsettledStop = reply;
-		reply.then(() => {
-			if (unsettledStop === reply) unsettledStop = void 0;
-		});
-	};
-	const fail = (current, failure) => {
-		notifyFailure(current, failure);
-		stop(current);
+		if (!paused) stopNative(current);
 	};
 	const gone = () => options.error(/* @__PURE__ */ new Error("Target page has been closed"));
-	const stopDeadline = () => options.error(/* @__PURE__ */ new Error("screencast stop exceeded its deadline"));
 	const why = told(closed, gone, options.clock);
-	const settled = (reply, late) => Effect.suspend(() => {
-		const pending = reply();
-		return pending === void 0 ? Effect.void : Effect.promise(() => pending).pipe(Effect.interruptible, Effect.timeoutOrElse({
-			duration: deadline,
-			orElse: () => late
-		}));
-	}).pipe(Effect.provideService(Clock.Clock, options.clock));
-	const awaitStop = (current) => settled(() => current.stopReply, Effect.sync(() => notifyFailure(current, stopDeadline())));
-	const awaitPreviousStop = settled(() => unsettledStop, Effect.fail(stopDeadline()));
+	const awaitStop = (current) => pictures.wait("screencast stop").pipe(Effect.catch((error) => Effect.sync(() => notifyFailure(current, error))));
+	const healthy = (current) => Effect.suspend(() => current.failure === void 0 ? Effect.void : Effect.fail(current.failure));
+	const pictures = make$9({
+		clock: options.clock,
+		error: options.error,
+		closed: isClosed,
+		current: () => generation,
+		fail: (current, error) => {
+			if (current !== void 0) notifyFailure(current, error);
+		},
+		pause: (current) => Effect.gen(function* () {
+			if (current?.phase !== "Capturing" || current.failure !== void 0) return;
+			current.phase = "Paused";
+			latest = Option.none();
+			sizes.end();
+			stopNative(current);
+			yield* pictures.wait("screencast stop").pipe(Effect.tapError((error) => Effect.sync(() => notifyFailure(current, error))));
+			yield* healthy(current);
+		}),
+		resume: (current) => Effect.gen(function* () {
+			const resumable = () => {
+				if (current === void 0 || generation !== current) return false;
+				if (current.subscribers.size === 0) {
+					stop(current);
+					generation = void 0;
+					return false;
+				}
+				return current.phase !== "Stopped" && current.failure === void 0 && !isClosed();
+			};
+			if (current === void 0 || !resumable()) return;
+			const viewport = yield* readViewport(options);
+			if (!resumable()) return;
+			sizes.restart(viewport);
+			current.phase = "Capturing";
+			startNative(current);
+			yield* pictures.wait("screencast start");
+			yield* healthy(current);
+		})
+	});
 	const leave = (current, subscription) => Effect.gen(function* () {
 		current.subscribers.delete(subscription);
 		yield* Queue.shutdown(subscription);
@@ -3989,50 +4053,25 @@ const make$8 = (options) => Effect.gen(function* () {
 		if (generation === current) generation = void 0;
 	});
 	const acquire = (screencast) => lock.withPermits(1)(Effect.gen(function* () {
-		if (Deferred.isDoneUnsafe(closed)) return yield* gone();
+		if (isClosed()) return yield* gone();
 		let current = generation;
 		const starting = current === void 0;
 		if (current === void 0) {
-			yield* awaitPreviousStop;
+			yield* pictures.idle;
 			const [transport, { calibration, viewport }] = yield* prepare(options, screencast);
 			const size = screencast.size ?? viewport;
-			if (Deferred.isDoneUnsafe(closed)) return yield* gone();
-			const created = {
+			if (isClosed()) return yield* gone();
+			current = {
 				subscribers: /* @__PURE__ */ new Set(),
 				transport,
 				unlisten: () => void 0,
 				calibration,
 				quality: screencast.quality ?? 80,
 				size,
-				accepting: true,
+				phase: "Capturing",
 				predecessor: void 0,
-				failure: void 0,
-				stopReply: void 0,
-				onFrame: (native) => {
-					if (!created.accepting) return;
-					counts.count("received");
-					if (replies.size >= replyCapacity) {
-						fail(created, options.error(/* @__PURE__ */ new Error("screencast acknowledgement capacity exceeded")));
-						return;
-					}
-					const reply = created.transport.acknowledge(native.sessionId).then(() => {
-						replies.delete(reply);
-					}, (cause) => {
-						replies.delete(reply);
-						if (created.accepting) fail(created, options.error(cause));
-					});
-					replies.add(reply);
-					const browserSeconds = native.metadata.timestamp;
-					const timestamp = browserSeconds === void 0 ? NaN : browserSeconds * 1e3;
-					if (!Number.isFinite(timestamp)) return counts.count("missingTimestamp");
-					if (created.predecessor !== void 0 && timestamp <= created.predecessor) return counts.count("late");
-					Queue.offerUnsafe(renewing, void 0);
-					const { frame, image, device } = timed(options, native, timestamp, created);
-					if (pictures.drawn(frame, !sizes.expects(device))) return counts.count("duringPictures");
-					sizes.offer(frame, timestamp, image, device);
-				}
+				failure: void 0
 			};
-			current = created;
 			generation = current;
 			latest = Option.none();
 			sizes.restart(viewport);
@@ -4046,24 +4085,13 @@ const make$8 = (options) => Effect.gen(function* () {
 		const baseline = delivered;
 		const frame = currentFrame(current, latest);
 		if (starting) {
-			const { transport, quality, size } = current;
 			const listening = current;
-			current.unlisten = transport.listen({
-				frame: current.onFrame,
-				lost: (error) => fail(listening, error)
-			});
-			const screencast = Effect.tryPromise({
-				try: () => transport.start({
-					format: "jpeg",
-					quality,
-					...size === null ? {} : {
-						maxWidth: size.width,
-						maxHeight: size.height
-					}
-				}),
-				catch: options.error
+			current.unlisten = listening.transport.listen({
+				frame: receive(options, current, replies, counts, sizes, renewing, notifyFailure),
+				lost: (error) => notifyFailure(listening, error)
 			});
-			const started = yield* Effect.all([options.watch, screencast], { concurrency: 2 }).pipe(Effect.interruptible, Effect.timeoutOrElse({
+			const screencast = Effect.promise(() => startNative(listening)).pipe(Effect.andThen(healthy(listening)));
+			const started = yield* options.watch.pipe(Effect.zip(screencast, { concurrent: true }), Effect.interruptible, Effect.timeoutOrElse({
 				duration: deadline,
 				orElse: () => Effect.fail(options.error(/* @__PURE__ */ new Error("screencast start exceeded its deadline")))
 			}), Effect.provideService(Clock.Clock, options.clock), Effect.exit);
@@ -4079,30 +4107,29 @@ const make$8 = (options) => Effect.gen(function* () {
 			frame
 		};
 	}));
-	const open = (screencast = {}) => Effect.acquireRelease(acquire(screencast), ({ current, subscription }) => lock.withPermits(1)(leave(current, subscription))).pipe(Effect.map((lease) => ({
+	const open = (screencast = {}) => Effect.acquireRelease(acquire(screencast), ({ current, subscription }) => Effect.sync(() => current.subscribers.delete(subscription)).pipe(Effect.andThen(lock.withPermits(1)(leave(current, subscription))))).pipe(Effect.map((lease) => ({
 		current: lease.frame,
 		stream: frames(lease.subscription, lease.baseline, why, (count) => counts.count("lost", count))
 	})));
-	yield* Effect.addFinalizer(() => lock.withPermits(1)(Effect.suspend(() => {
+	yield* Effect.addFinalizer(() => Effect.sync(() => Deferred.doneUnsafe(closed, Exit.void)).pipe(Effect.andThen(lock.withPermits(1)(Effect.suspend(() => {
 		const current = generation;
-		Deferred.doneUnsafe(closed, Exit.void);
 		if (current === void 0) return Effect.void;
-		fail(current, gone());
+		notifyFailure(current, gone());
 		return awaitStop(current);
-	})));
+	})))));
 	return {
 		open,
 		stream: (options) => Stream.unwrap(Effect.map(open(options), ({ stream }) => stream)),
 		latest: Effect.sync(() => latest),
 		recent: Effect.sync(() => history),
-		active: Effect.sync(() => generation?.accepting === true),
+		active: Effect.sync(() => generation !== void 0 && generation.phase !== "Stopped"),
 		sync: Effect.suspend(() => synced(generation, why, options.error)),
 		current,
 		confirm: confirmation(() => ({
 			generation,
 			replies: replies.size
 		}), current, why, options.error),
-		excluding: pictures.excluding,
+		excluding: (picture) => lock.withPermits(1)(pictures.excluding(picture)),
 		stats: (windowMillis) => Effect.sync(() => new CaptureStats({
 			...counts.read(windowMillis),
 			ackBacklog: replies.size
@@ -4366,22 +4393,23 @@ const ScreenSize = Schema.Struct({
 	height: Schema.Int
 });
 const camera = (page, bridge, viewport, capture) => {
-	const { playwright, settings, native, within } = page;
+	const { playwright, native, within } = page;
 	const { send } = page.protocol;
-	const actionMillis = Duration.toMillis(settings.actionTimeout);
 	let ratio = 1;
-	const alone = Semaphore.makeUnsafe(1).withPermits(1);
 	let screenHeld = false;
-	const holdScreen = (operation) => Effect.suspend(() => screenHeld ? Effect.void : bridge.evaluate(operation, scriptCall("screenSize")).pipe(Effect.flatMap(decodeWith(operation, ScreenSize)), Effect.flatMap(({ width, height }) => native(operation, () => send("Emulation.setDeviceMetricsOverride", {
-		width: 0,
-		height: 0,
-		deviceScaleFactor: 0,
-		mobile: false,
-		screenWidth: width,
-		screenHeight: height
-	})).pipe(alone)), Effect.andThen(Effect.sync(() => {
+	const holdScreen = Effect.fnUntraced(function* (operation) {
+		if (screenHeld) return;
+		const { width, height } = yield* bridge.evaluate(operation, scriptCall("screenSize")).pipe(Effect.flatMap(decodeWith(operation, ScreenSize)));
+		yield* native(operation, () => send("Emulation.setDeviceMetricsOverride", {
+			width: 0,
+			height: 0,
+			deviceScaleFactor: 0,
+			mobile: false,
+			screenWidth: width,
+			screenHeight: height
+		}));
 		screenHeld = true;
-	}))));
+	});
 	const decoded = (operation, data, format) => {
 		const size = format === "png" ? pngSize(data) : jpegSize(data);
 		return size === void 0 ? failWith(operation, new Failed({ detail: `the browser's picture is not a ${format.toUpperCase()}` })) : Effect.succeed(new Image({
@@ -4390,18 +4418,19 @@ const camera = (page, bridge, viewport, capture) => {
 			...size
 		}));
 	};
-	const shot = (operation, format, quality, clip) => native(operation, () => send("Page.captureScreenshot", {
+	const take = (operation, format, run) => native(operation, run).pipe(untilPainted, Effect.flatMap((data) => decoded(operation, data, format)));
+	const shot = (operation, format, quality, clip) => take(operation, format, () => send("Page.captureScreenshot", {
 		format,
 		...format === "jpeg" ? { quality } : {},
 		...clip === void 0 ? {} : { clip }
-	})).pipe(alone, untilPainted, Effect.flatMap(({ data }) => decoded(operation, Buffer.from(data, "base64"), format)));
-	const emulatedShot = (operation, format, quality, crop) => native(operation, () => playwright.screenshot({
+	}).then(({ data }) => Buffer.from(data, "base64")));
+	const emulatedShot = (operation, format, quality, crop) => take(operation, format, () => playwright.screenshot({
 		type: format,
 		...format === "jpeg" ? { quality } : {},
 		scale: "css",
-		timeout: actionMillis,
+		timeout: 0,
 		...crop === void 0 ? {} : { clip: crop }
-	}), actionMillis).pipe(alone, untilPainted, Effect.flatMap((data) => decoded(operation, data, format)));
+	}));
 	return (operation, quality, crop, format = "jpeg") => Effect.gen(function* () {
 		const known = viewport.knownViewport();
 		let whole;
@@ -4412,9 +4441,9 @@ const camera = (page, bridge, viewport, capture) => {
 		const emulated = playwright.viewportSize();
 		if (emulated !== null) {
 			if (whole !== void 0) ratio = whole.width / emulated.width;
-			return yield* capture.excluding(emulatedShot(operation, format, quality, crop));
+			return yield* emulatedShot(operation, format, quality, crop);
 		}
-		const [metrics] = yield* Effect.all([native(operation, () => send("Page.getLayoutMetrics")).pipe(Effect.flatMap(decodeWith(operation, LayoutMetrics))), crop === void 0 ? Effect.void : holdScreen(operation)], { concurrency: 2 });
+		const [metrics] = yield* native(operation, () => send("Page.getLayoutMetrics")).pipe(Effect.flatMap(decodeWith(operation, LayoutMetrics)), Effect.zip(crop === void 0 ? Effect.void : holdScreen(operation), { concurrent: true }));
 		const measured = metrics.contentSize.width / metrics.cssContentSize.width;
 		ratio = Number.isFinite(measured) && measured > 0 ? measured : 1;
 		if (crop === void 0 && ratio === 1) {
@@ -4429,14 +4458,14 @@ const camera = (page, bridge, viewport, capture) => {
 		};
 		const { pageX, pageY, scale } = metrics.cssVisualViewport;
 		yield* holdScreen(operation);
-		return yield* capture.excluding(shot(operation, format, quality, {
+		return yield* shot(operation, format, quality, {
 			x: pageX + rect.x,
 			y: pageY + rect.y,
 			width: Math.floor(rect.width / scale + .001),
 			height: Math.floor(rect.height / scale + .001),
 			scale: scale / ratio
-		}), crop !== void 0);
-	}).pipe(within(operation));
+		});
+	}).pipe(capture.excluding, within(operation));
 };
 const millisOf = (input) => Option.match(Duration.fromInput(input), {
 	onNone: () => NaN,
@@ -4711,8 +4740,9 @@ const make$5 = (page, bridge, capture) => (options = {}) => {
 		const running = yield* capture.active;
 		let { received } = yield* capture.stats();
 		let stirred = running ? page.now() : Number.POSITIVE_INFINITY;
-		const look = Effect.map(capture.stats(), (stats) => {
-			if (stats.received !== received || stats.ackBacklog > 0) {
+		const look = Effect.gen(function* () {
+			const stats = yield* capture.stats();
+			if (!Option.exists(yield* capture.latest, capture.current) || stats.received !== received || stats.ackBacklog > 0) {
 				received = stats.received;
 				stirred = page.now();
 			}
@@ -4996,11 +5026,11 @@ const viewOf = (page, view) => {
 	return internals === void 0 ? view : Object.assign(new Built(internals), view);
 };
 const make = Effect.fnUntraced(function* (options) {
-	const page = make$19(options, yield* Effect.scope);
+	const page = make$20(options, yield* Effect.scope);
 	const { id, playwright, native, owned, within, lane, span } = page;
-	const bridge = yield* make$17(page);
+	const bridge = yield* make$18(page);
 	const viewport = make$1(page, bridge);
-	const input = make$9(page, bridge, viewport);
+	const input = make$10(page, bridge, viewport);
 	const pictures = yield* make$7(page, bridge, viewport);
 	const reading = yield* make$6(page, bridge);
 	const navigation = make$2(page, input.perform, input.preparePolicy);
@@ -5071,4 +5101,4 @@ const make = Effect.fnUntraced(function* (options) {
 //#endregion
 export { performed as a, pause as i, make as n, mapping as o, viewOf as r, internalsOf as t };
 
-//# sourceMappingURL=page-ZxMhw16l.mjs.map
+//# sourceMappingURL=page-B92QnRfT.mjs.map