effect-browser 0.3.0-beta.15 → 0.3.0-beta.19

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

@@ -1,15 +1,16 @@
-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 { Plan, Point } from "./Motion.mjs";
+import { Action, Box, CursorChanged, KeyChanged, Navigated, PageLoaded, PointerPressed, PointerReleased, Subject, 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$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 { a as make$20, c as undispatched, d as monotonicMillis, f as toBrowserSeconds, g as make$19, h as Current, i as failWith, l as estimate, m as uncertaintyAt, n as contextGone, o as reasonOf, p as toHostTime, r as decodeWith, s as refuse } from "./context-w3NJPRLo.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";
+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-CfB6Zn1p.mjs";
 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 { Cause, Clock, Deferred, Duration, Effect, Exit, Fiber, MutableRef, Option, Queue, Random, Ref, Result, Schedule, Schema, Scope, Semaphore, Stream, SynchronizedRef } from "effect";
+import { jpegjs } from "playwright-core/lib/utilsBundle";
 //#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
@@ -17,7 +18,7 @@ import { Cause, Clock, Deferred, Duration, Effect, Exit, Fiber, MutableRef, Opti
 * may use.
 */
 const edit = (names, guard, placing) => {
-	const { activeElement, clean, describe, isDisabled, isHtml, isInput, isSecret, isSelect, isTextArea, lookup, nameOf, roleOf } = names;
+	const { activeElement, clean, describe, inCurrentDocument, isDisabled, isHtml, isInput, isSecret, isSelect, isTextArea, lookup, nameOf, roleOf } = names;
 	const { textEntry, typingRefusal } = guard;
 	/** Whether text may be typed into a ref or focus, and, for a `secret`, only into a secret field. */
 	const typeable = (ref, secret) => {
@@ -48,8 +49,21 @@ const edit = (names, guard, placing) => {
 			}
 		};
 	};
-	const focus = (ref, replace) => {
-		const element = lookup(ref);
+	/**
+	* The focused field, when it is a text field named `name`: one a page put in place of a field
+	* just pressed and gave focus to, as a typeahead does.
+	*/
+	const replacement = (name) => {
+		const active = activeElement();
+		return active !== null && textEntry(active) && inCurrentDocument(active) && nameOf(active, roleOf(active)) === name ? active : void 0;
+	};
+	/**
+	* Focus a field to type into. `follow` is the field's name when the action pressed it first: a
+	* page may answer the press with another field of that name in its place, focused, and the keys
+	* follow focus there, as a person's would.
+	*/
+	const focus = (ref, replace, follow) => {
+		const element = lookup(ref) ?? (follow === null ? void 0 : replacement(follow));
 		if (element === void 0) return {
 			error: `${ref} is not on the page any more`,
 			stale: true
@@ -333,13 +347,9 @@ const targets = (names, walked, placing) => {
 	};
 };
 const ResolvedPointSchema = Schema.Struct({
-	x: Schema.Finite,
-	y: Schema.Finite,
+	...Point.fields,
+	...Subject.fields,
 	element: Schema.String,
-	tag: Schema.String,
-	role: Schema.NullOr(Schema.String),
-	name: Schema.String,
-	context: SubjectContext,
 	box: Schema.optional(Box),
 	cursor: Schema.String,
 	href: Schema.optional(Schema.String)
@@ -356,8 +366,7 @@ const PointResultSchema = Schema.Union([ResolvedPointSchema, Schema.Struct({
 	detail: Schema.String
 })]);
 const ScrollPlanSchema = Schema.NullOr(Schema.Struct({
-	x: Schema.Finite,
-	y: Schema.Finite,
+	...Point.fields,
 	dx: Schema.Finite,
 	dy: Schema.Finite
 }));
@@ -464,6 +473,11 @@ const context = (names, walked) => {
 };
 //#endregion
 //#region src/internal/reading/controls.inpage.ts
+/**
+* In the page: a control's states and value as the outline shows them, and as a value; the elements a CSS selector scopes a
+* read to; and a condition `Page.waitFor` waits for. See `names.inpage.ts` for what a page-side part
+* may use.
+*/
 const controls = (names, walked, subjects, texts) => {
 	const { clean, isDisabled, isHtml, isInput, isSelect, isTextArea, refFor, textOf } = names;
 	const { visible } = walked;
@@ -553,6 +567,7 @@ const controls = (names, walked, subjects, texts) => {
 		waitUntil
 	};
 };
+const ConditionResultSchema = Schema.Union([Schema.Struct({ met: Schema.Boolean }), Schema.Struct({ invalid: Schema.String })]);
 //#endregion
 //#region src/internal/reading/expect.inpage.ts
 const expectations = (names, subjected) => {
@@ -942,6 +957,10 @@ const outline = (names, walked, subjects, texts, controlling, url) => {
 		viewport
 	};
 };
+const SnapshotResultSchema = Schema.Union([Schema.Struct({
+	snapshot: Snapshot,
+	nextRef: Schema.Finite
+}), Schema.Struct({ invalid: Schema.String })]);
 const ViewportResultSchema = Schema.Struct({
 	width: Schema.Finite,
 	height: Schema.Finite
@@ -2066,7 +2085,7 @@ const sight = (names, walked, texts, kept) => {
 */
 const install = (makeNames, makeWalk, makeMatch, makeContext, makeSubjects, makeExpectations, makeText, makeControls, makeFold, makeHistory, makeSight, makeMarks, makeRecord, makeChanges, makeReady, makeOutline, makeTargets, makeEvidence, makeGuard, makeEdit, makeAddresses) => {
 	const installed = globalThis.__effectBrowser;
-	if (installed !== void 0 && installed.version === 19) return installed;
+	if (installed !== void 0 && installed.version === 20) return installed;
 	const named = makeNames();
 	const walked = makeWalk(named);
 	const placing = makeContext(named, walked);
@@ -2083,7 +2102,7 @@ const install = (makeNames, makeWalk, makeMatch, makeContext, makeSubjects, make
 	const edited = makeEdit(named, guarded, placing);
 	const readiness = makeReady(walked, texts, kept, recorder);
 	const api = {
-		version: 19,
+		version: 20,
 		snapshot: read.snapshot,
 		find: subjected.find,
 		until: makeExpectations(named, subjected).until,
@@ -2284,74 +2303,26 @@ const make$18 = Effect.fnUntraced(function* (page) {
 	};
 });
 //#endregion
-//#region src/internal/pictures/clock.ts
-/**
-* The browser's clock read on the owner's: estimates of their offset from timed probes, how an
-* estimate ages, and the one mapping a browser's pages share. `pictures.ts` takes the probes.
-*/
-/** The fastest complete probe limits uncertainty without mistaking transit delay for clock offset. */
-const estimate = (probes) => {
-	let best;
-	for (const probe of probes) {
-		const roundTripMillis = probe.hostEnd - probe.hostStart;
-		if (!Number.isFinite(probe.hostStart) || !Number.isFinite(probe.hostEnd) || !Number.isFinite(probe.browserTime) || !Number.isFinite(roundTripMillis) || roundTripMillis < 0) continue;
-		const sampledAt = probe.hostStart + roundTripMillis / 2;
-		const offsetMillis = probe.browserTime - sampledAt;
-		if (!Number.isFinite(offsetMillis) || !Number.isFinite(probe.browserTime - probe.hostStart) || !Number.isFinite(probe.browserTime - probe.hostEnd)) continue;
-		if (best === void 0 || roundTripMillis < best.roundTripMillis) best = {
-			offsetMillis,
-			uncertaintyMillis: roundTripMillis / 2,
-			roundTripMillis,
-			sampledAt
-		};
-	}
-	return Option.fromUndefinedOr(best);
-};
-const driftPerMillis = 1e-4;
-/** An estimate's uncertainty at `hostTime`, wider the further that is from when it was sampled. */
-const uncertaintyAt = (estimate, hostTime) => estimate.uncertaintyMillis + Math.abs(hostTime - estimate.sampledAt) * driftPerMillis;
-const renewAfter = Duration.seconds(10);
-/**
-* Whether a new measurement should replace the current estimate. Each interval contains the true
-* offset, so overlapping intervals agree and the narrower one is kept, the current one widened by
-* its age: a probe delayed behind a busy page cannot widen every tab's stamps. A disjoint
-* measurement means the clocks moved (a wall clock step, or drift between a remote browser and
-* this host), so the newer evidence wins.
-*/
-const supersedes = (next, current) => {
-	const aged = uncertaintyAt(current, next.sampledAt);
-	return next.uncertaintyMillis <= aged || Math.abs(next.offsetMillis - current.offsetMillis) > next.uncertaintyMillis + aged;
-};
-/**
-* Every renderer of a browser reads the same host wall clock, so the offset belongs to the
-* browser rather than a page. A busy page cannot fail work that an earlier estimate can serve.
-*/
-const mapping = (now) => {
-	let latest;
-	let measuredAt = Number.NEGATIVE_INFINITY;
-	const adopt = (measure) => {
-		measuredAt = now();
-		return measure.pipe(Effect.map((estimate) => {
-			if (latest === void 0 || supersedes(estimate, latest)) latest = estimate;
-			return latest;
-		}));
-	};
-	return {
-		latest: () => latest,
-		current: (measure) => Effect.suspend(() => latest === void 0 ? adopt(measure) : Effect.succeed(latest)),
-		renew: (measure) => Effect.suspend(() => latest === void 0 || now() - measuredAt < Duration.toMillis(renewAfter) ? Effect.void : Effect.ignore(adopt(measure)))
-	};
-};
-const toHostTime = (calibration, browserEpochMillis) => browserEpochMillis - calibration.offsetMillis;
-/** CDP input timestamps use seconds, unlike browser frame timestamps and the owner's clock. */
-const toBrowserSeconds = (calibration, hostMillis) => (hostMillis + calibration.offsetMillis) / 1e3;
-//#endregion
 //#region src/internal/input/dispatch.ts
 /**
 * Sending input to the browser. Each mouse event, key and inserted text goes out on the page's
 * protocol session, stamped with the browser's clock when its run has a mapping, and is published
 * as it is submitted.
 */
+const buttonMask = {
+	none: 0,
+	left: 1,
+	right: 2,
+	middle: 4
+};
+/** A mouse button going down or up at a point, as the `clickCount`th click. */
+const buttonAt = (type, point, button = "left", clickCount = 1) => ({
+	type,
+	...point,
+	button,
+	buttons: type === "mousePressed" ? buttonMask[button] : 0,
+	clickCount
+});
 const make$17 = (page) => {
 	const { id, pointer, publish, now, noteInput, closedBy } = page;
 	const { send } = page.protocol;
@@ -2395,16 +2366,10 @@ const make$17 = (page) => {
 		if (event.type === "mouseReleased") return yield* run.up(held);
 		if (event.type === "mousePressed") {
 			yield* run.reserve(2);
-			yield* run.down(held, () => dispatchMouse(event, estimate, submitted), () => dispatchMouse({
-				type: "mouseReleased",
-				...Option.getOrElse(MutableRef.get(pointer), () => ({
-					x: event.x,
-					y: event.y
-				})),
-				button: event.button ?? "left",
-				buttons: 0,
-				clickCount: event.clickCount ?? 1
-			}, estimate));
+			yield* run.down(held, () => dispatchMouse(event, estimate, submitted), () => dispatchMouse(buttonAt("mouseReleased", Option.getOrElse(MutableRef.get(pointer), () => ({
+				x: event.x,
+				y: event.y
+			})), event.button, event.clickCount), estimate));
 		} else {
 			yield* run.reserve(1);
 			yield* run.send(() => dispatchMouse(event, estimate, submitted));
@@ -2453,6 +2418,8 @@ const make$17 = (page) => {
 * policy decides on, binds an approval to the document and targets it saw, and runs the page
 * script's changes in the approved document only.
 */
+/** Recheck an approval, after any pending input it must see; neither runs without a guard. */
+const check = (approval, options = {}, before = Effect.void) => approval === void 0 ? Effect.void : before.pipe(Effect.andThen(approval.check(options)));
 const inputFailure = (operation, targets, failure) => {
 	const target = failure.index === void 0 ? void 0 : targets[failure.index];
 	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 }));
@@ -2463,8 +2430,8 @@ const make$16 = (page, bridge) => {
 	const { current, evaluateIn, evaluateWithContext } = bridge;
 	const preparePolicy = (action, info, targets, flags = {}) => Effect.gen(function* () {
 		for (const target of targets) {
-			if (typeof target === "string" && !/^e\d+$/.test(target)) return yield* failWith(action, new InvalidRequest({ detail: `"${target}" is not a ref; refs look like e12` }));
-			if (target !== null && typeof target !== "string" && (!Number.isFinite(target.x) || !Number.isFinite(target.y))) return yield* failWith(action, new InvalidRequest({ detail: "point coordinates must be finite" }));
+			if (typeof target === "string" && !/^e\d+$/.test(target)) return yield* refuse(action, `"${target}" is not a ref; refs look like e12`);
+			if (target !== null && typeof target !== "string" && (!Number.isFinite(target.x) || !Number.isFinite(target.y))) return yield* refuse(action, "point coordinates must be finite");
 		}
 		const input = {
 			action,
@@ -2511,9 +2478,12 @@ const make$16 = (page, bridge) => {
 		};
 	});
 	const mutate = (operation, call, approval, mayHaveRun = Effect.void) => (approval === void 0 ? current(operation) : Effect.succeed(approval.contextId)).pipe(Effect.flatMap((contextId) => evaluateIn(operation, call, contextId).pipe(Effect.onInterrupt(() => mayHaveRun), Effect.tapError((error) => error.reason._tag === "Failed" && /Cannot find context|__effectBrowser/i.test(error.reason.detail) ? Effect.void : mayHaveRun))), Effect.catchIf(contextGone, () => failWith(operation, new NotActionable({ detail: "the page changed before the approved input could run" }))));
+	/** A read may follow the current document only when no approval binds it to one. */
+	const evaluate = (operation, call, approval) => approval === void 0 ? bridge.evaluate(operation, call) : mutate(operation, call, approval);
 	return {
 		preparePolicy,
-		mutate
+		mutate,
+		evaluate
 	};
 };
 //#endregion
@@ -2927,10 +2897,7 @@ const admission = (page, pending, name) => {
 	};
 };
 /** Close a run on every exit while preserving its native replies for the page's next input. */
-const useRun = (page, sender, name, run, action) => action.pipe(Effect.matchEffect({
-	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 useRun = (page, sender, name, run, action, canStop) => action.pipe(Effect.tapError(() => run.close.pipe(Effect.andThen(sender.flush(name, run)), Effect.ignore)), Effect.tap(() => run.close.pipe(Effect.andThen(sender.flush(name, run)))), Effect.ensuring(run.close.pipe(Effect.andThen(page.openings.clear))), Effect.onError(() => run.recover(page.stopLoading, page.scope).pipe(Effect.when(canStop))), Effect.provideService(Current, run));
 const make$14 = (page, sender) => {
 	const { id, settings, mapping, lane, publish, now, noteInput, span, owned } = page;
 	const { inputClocks } = sender;
@@ -2965,7 +2932,7 @@ const make$14 = (page, sender) => {
 		const useInput = (action) => input.begin.pipe(Effect.tap((current) => Effect.sync(() => {
 			ticket.using(current);
 			if (estimate !== void 0) inputClocks.set(current, estimate);
-		})), Effect.flatMap((run) => useRun(page, sender, name, run, action(run))));
+		})), Effect.flatMap((run) => useRun(page, sender, name, run, action(run), info.input === false ? Effect.succeed(false) : Ref.get(sent))));
 		let queuedMillis;
 		const dispatch = (action) => Effect.suspend(() => {
 			const asked = now();
@@ -3066,7 +3033,7 @@ const make$13 = (page, dispatch, viewport) => {
 			y: Math.max(0, Math.min(size.height - 1, previous.y))
 		};
 		const planned = yield* style.glide(from, to, dragging);
-		const invalid = failWith(operation, new InvalidRequest({ detail: "motion must be a bounded, ordered schedule ending at the target" }));
+		const invalid = refuse(operation, "motion must be a bounded, ordered schedule ending at the target");
 		const samples = yield* Schema.decodeEffect(Plan)(planned).pipe(Effect.catch(() => invalid));
 		if (samples.at(-1)?.x !== to.x || samples.at(-1)?.y !== to.y) return yield* invalid;
 		yield* Effect.annotateCurrentSpan("samples", samples.length);
@@ -3163,12 +3130,12 @@ const make$12 = (page, bridge) => {
 	});
 	/** Wait for the page to settle after input sent since `before`. */
 	const settle = (operation, before) => Effect.gen(function* () {
-		yield* bridge.evaluate(operation, scriptCall("settle")).pipe(Effect.provideService(Current, void 0), Effect.catchIf(contextGone, () => Effect.void), Effect.onError(() => page.stopLoading));
+		yield* bridge.evaluate(operation, scriptCall("settle")).pipe(Effect.provideService(Current, void 0), Effect.catchIf(contextGone, () => Effect.void));
 		while (document() > before.document && parsed < document()) yield* Deferred.await(changed);
 	}).pipe(Effect.timeoutOrElse({
 		duration: settling,
 		orElse: () => Effect.fail("unsettled")
-	}), Effect.catch(() => Effect.annotateCurrentSpan("settled", false)), Effect.andThen(page.openings.settle(before.openings)), page.span("Page.settle", {}, "Debug"));
+	}), Effect.catch(() => page.stopLoading.pipe(Effect.andThen(Effect.annotateCurrentSpan("settled", false)))), Effect.andThen(page.openings.settle(before.openings)), page.span("Page.settle", {}, "Debug"));
 	return {
 		mark,
 		settle
@@ -3182,29 +3149,22 @@ const make$12 = (page, bridge) => {
 * viewers watch.
 */
 const pointFailure = (operation, target, result) => failWith(operation, result.error === "stale" && typeof target === "string" ? new StaleRef({ ref: target }) : result.error === "outside" ? new InvalidRequest({ detail: result.detail }) : new NotActionable({ detail: result.detail }));
-const resolvedTarget = (result) => new ResolvedTarget({
+const resolvedTarget = ({ x, y, box, ...target }) => new ResolvedTarget({
 	point: {
-		x: result.x,
-		y: result.y
+		x,
+		y
 	},
-	element: result.element,
-	tag: result.tag,
-	role: result.role,
-	name: result.name,
-	context: result.context,
-	box: result.box,
-	cursor: result.cursor,
-	...result.href === void 0 ? {} : { href: result.href }
+	box,
+	...target
 });
-const make$11 = (bridge, viewport, guard, pointer, dispatch, settling) => {
-	const { evaluate } = bridge;
-	const { mutate } = guard;
+const make$11 = (viewport, guard, pointer, dispatch, settling) => {
+	const { evaluate, mutate } = guard;
 	const { moveTo, wheel } = pointer;
 	const { flush } = dispatch;
-	const readPoint = (operation, target, approval, scroll) => (approval === void 0 ? evaluate(operation, scriptCall("point", target, scroll)) : mutate(operation, scriptCall("point", target, scroll), approval)).pipe(Effect.flatMap(decodeWith(operation, PointResultSchema)));
+	const readPoint = (operation, target, approval, scroll) => evaluate(operation, scriptCall("point", target, scroll), approval).pipe(Effect.flatMap(decodeWith(operation, PointResultSchema)));
 	const resolve = (operation, target, approval, scroll = true) => {
-		if (typeof target === "string" && !/^e\d+$/.test(target)) return failWith(operation, new InvalidRequest({ detail: target + " is not a ref; refs look like e12" }));
-		if (typeof target !== "string" && (!Number.isFinite(target.x) || !Number.isFinite(target.y))) return failWith(operation, new InvalidRequest({ detail: "point coordinates must be finite" }));
+		if (typeof target === "string" && !/^e\d+$/.test(target)) return refuse(operation, target + " is not a ref; refs look like e12");
+		if (typeof target !== "string" && (!Number.isFinite(target.x) || !Number.isFinite(target.y))) return refuse(operation, "point coordinates must be finite");
 		return readPoint(operation, target, approval, scroll).pipe(Effect.flatMap((result) => "error" in result ? pointFailure(operation, target, result) : Effect.succeed(resolvedTarget(result))));
 	};
 	return {
@@ -3228,13 +3188,13 @@ const make$11 = (bridge, viewport, guard, pointer, dispatch, settling) => {
 				yield* wheel(operation, marks, point, Math.max(-size.width * .9, Math.min(size.width * .9, plan.dx)), Math.max(-size.height * .9, Math.min(size.height * .9, plan.dy)));
 				yield* flush(operation, marks.input);
 				yield* settling.settle(operation, before);
-				if (approval !== void 0) yield* approval.check();
+				yield* check(approval);
 			}
 			yield* marks.touched;
 			const before = settling.mark();
 			yield* resolve(operation, target, approval);
 			yield* settling.settle(operation, before);
-			if (approval !== void 0) yield* approval.check();
+			yield* check(approval);
 			return yield* resolve(operation, target, approval, false);
 		})
 	};
@@ -3247,12 +3207,6 @@ const make$11 = (bridge, viewport, guard, pointer, dispatch, settling) => {
 * `perform`, which admits it, puts it to the input guard and records it. A click, a key or a scroll
 * then waits for the page to settle: a task and a frame, and a document if the input asked for one.
 */
-const buttonMask = {
-	none: 0,
-	left: 1,
-	right: 2,
-	middle: 4
-};
 const partsOf = (page, bridge, viewport) => {
 	const dispatch = make$17(page);
 	const pointer = make$13(page, dispatch, viewport);
@@ -3260,12 +3214,11 @@ const partsOf = (page, bridge, viewport) => {
 	const settling = make$12(page, bridge);
 	return {
 		page,
-		bridge,
 		...settling,
 		viewportFor: viewport.viewportFor,
 		perform: make$14(page, dispatch),
 		...guard,
-		...make$11(bridge, viewport, guard, pointer, dispatch, settling),
+		...make$11(viewport, guard, pointer, dispatch, settling),
 		...pointer,
 		...make$15(page, bridge, dispatch),
 		sendMouse: dispatch.sendMouse,
@@ -3275,13 +3228,15 @@ const partsOf = (page, bridge, viewport) => {
 /** Whether every number given is finite; a number left out is. */
 const finite = (...values) => values.every((value) => value === void 0 || Number.isFinite(value));
 const named = (target) => typeof target === "string" ? target : `${target.x},${target.y}`;
+/** The ref a target names, if it names one rather than a point. */
+const refOf = (target) => typeof target === "string" ? target : void 0;
 /** A click's options, once its counts are finite. */
-const clickable = (options) => finite(options.clickCount, options.holdMillis) ? Effect.void : failWith("click", new InvalidRequest({ detail: "clickCount and holdMillis must be finite" }));
+const clickable = (options) => finite(options.clickCount, options.holdMillis) ? Effect.void : refuse("click", "clickCount and holdMillis must be finite");
 /** The keys a press sends, once they and its options are valid. */
 const pressed = (keys, options) => {
 	const parts$1 = parts(keys);
-	if (!finite(options.times, options.holdMillis)) return failWith("press", new InvalidRequest({ detail: "times and holdMillis must be finite" }));
-	if (parts$1 === void 0) return failWith("press", new InvalidRequest({ detail: `"${keys}" is not a key; try Enter, Space, ArrowLeft or Control+A` }));
+	if (!finite(options.times, options.holdMillis)) return refuse("press", "times and holdMillis must be finite");
+	if (parts$1 === void 0) return refuse("press", `"${keys}" is not a key; try Enter, Space, ArrowLeft or Control+A`);
 	return Effect.succeed(parts$1);
 };
 const click = (input) => {
@@ -3294,7 +3249,7 @@ const click = (input) => {
 			clickCount: clickOptions.clickCount,
 			holdMillis: clickOptions.holdMillis
 		}
-	}, settings.actionTimeout, Effect.suspend(() => clickable(clickOptions)).pipe(Effect.andThen(preparePolicy("click", { target: typeof target === "string" ? target : void 0 }, [target]))), (marks, approval) => Effect.gen(function* () {
+	}, settings.actionTimeout, Effect.suspend(() => clickable(clickOptions)).pipe(Effect.andThen(preparePolicy("click", { target: refOf(target) }, [target]))), (marks, approval) => Effect.gen(function* () {
 		yield* clickable(clickOptions);
 		const resolved = yield* targetFor("click", target, approval, marks);
 		const { point } = resolved;
@@ -3303,37 +3258,22 @@ const click = (input) => {
 		yield* marks.at(point);
 		yield* marks.on(resolved);
 		yield* moveTo("click", marks, point, resolved.cursor);
-		if (approval !== void 0) yield* approval.check({ presses: [{
+		yield* check(approval, { presses: [{
 			index: 0,
 			...point
 		}] });
 		const before = mark();
 		yield* marks.sent;
 		for (let index = 1; index <= count; index++) {
-			if (approval !== void 0 && index > 1) {
-				yield* flush("click", marks.input);
-				yield* approval.check({ presses: [{
-					index: 0,
-					...point
-				}] }).pipe(Effect.catchIf((error) => error.reason._tag === "StaleRef", () => failWith("click", new NotActionable({ detail: "an earlier click removed the approved target, so no further press was sent" }))));
-			}
-			yield* sendMouse("click", marks.input, {
-				type: "mousePressed",
-				...point,
-				button,
-				buttons: buttonMask[button],
-				clickCount: index
-			});
+			if (index > 1) yield* check(approval, { presses: [{
+				index: 0,
+				...point
+			}] }, flush("click", marks.input)).pipe(Effect.catchIf((error) => error.reason._tag === "StaleRef", () => failWith("click", new NotActionable({ detail: "an earlier click removed the approved target, so no further press was sent" }))));
+			yield* sendMouse("click", marks.input, buttonAt("mousePressed", point, button, index));
 			const hold = clickOptions.holdMillis ?? (yield* marks.style.hold);
 			if (clickOptions.holdMillis === void 0) yield* marks.present(hold);
 			if (hold > 0) yield* Effect.sleep(Duration.millis(hold));
-			yield* sendMouse("click", marks.input, {
-				type: "mouseReleased",
-				...point,
-				button,
-				buttons: 0,
-				clickCount: index
-			});
+			yield* sendMouse("click", marks.input, buttonAt("mouseReleased", point, button, index));
 		}
 		yield* flush("click", marks.input);
 		yield* settle("click", before);
@@ -3343,7 +3283,7 @@ const click = (input) => {
 const hover = (input) => {
 	const { settings } = input.page;
 	const { perform, preparePolicy, targetFor, moveTo, flush } = input;
-	return (target, style = plain) => perform("hover", { target: named(target) }, settings.actionTimeout, preparePolicy("hover", { target: typeof target === "string" ? target : void 0 }, [target]), (marks, approval) => Effect.gen(function* () {
+	return (target, style = plain) => perform("hover", { target: named(target) }, settings.actionTimeout, preparePolicy("hover", { target: refOf(target) }, [target]), (marks, approval) => Effect.gen(function* () {
 		const resolved = yield* targetFor("hover", target, approval, marks);
 		const { point } = resolved;
 		yield* marks.at(point);
@@ -3375,7 +3315,7 @@ const drag = (input) => {
 		yield* marks.at(end.point);
 		yield* marks.on(start, end);
 		yield* moveTo("drag", marks, start.point, start.cursor);
-		if (approval !== void 0) yield* approval.check({ presses: [{
+		yield* check(approval, { presses: [{
 			index: 0,
 			...start.point
 		}, {
@@ -3383,27 +3323,15 @@ const drag = (input) => {
 			...end.point
 		}] });
 		yield* marks.sent;
-		yield* sendMouse("drag", marks.input, {
-			type: "mousePressed",
-			...start.point,
-			button: "left",
-			buttons: 1,
-			clickCount: 1
-		});
+		yield* sendMouse("drag", marks.input, buttonAt("mousePressed", start.point));
 		yield* moveTo("drag", marks, end.point, end.cursor, "drag");
-		yield* sendMouse("drag", marks.input, {
-			type: "mouseReleased",
-			...end.point,
-			button: "left",
-			buttons: 0,
-			clickCount: 1
-		});
+		yield* sendMouse("drag", marks.input, buttonAt("mouseReleased", end.point));
 		yield* flush("drag", marks.input);
 	}), style);
 };
 const typeText = (input) => {
 	const { settings, now } = input.page;
-	const { perform, preparePolicy, mutate, targetFor, moveTo, sendMouse, flush, bridge } = input;
+	const { perform, preparePolicy, mutate, targetFor, moveTo, sendMouse, flush, evaluate } = input;
 	const { currentDocument, sameDocument, keyStroke, typeEvent, mark, settle } = input;
 	return (text, typeOptions = {}, style = plain) => perform("type", {
 		target: typeOptions.into,
@@ -3419,9 +3347,9 @@ const typeText = (input) => {
 	}, [typeOptions.into ?? null], { submit: typeOptions.submit ?? false }), (marks, approval) => Effect.gen(function* () {
 		const replace = typeOptions.replace ?? true;
 		const into = typeOptions.into;
-		if (into !== void 0 && !/^e\d+$/.test(into)) return yield* failWith("type", new InvalidRequest({ detail: `"${into}" is not a ref; refs look like e12` }));
+		if (into !== void 0 && !/^e\d+$/.test(into)) return yield* refuse("type", `"${into}" is not a ref; refs look like e12`);
 		const asked = scriptCall("typeable", into ?? null, typeOptions.secret === true);
-		const typeable = yield* (approval === void 0 ? bridge.evaluate("type", asked) : mutate("type", asked, approval)).pipe(Effect.flatMap(decodeWith("type", TypeableResultSchema)));
+		const typeable = yield* evaluate("type", asked, approval).pipe(Effect.flatMap(decodeWith("type", TypeableResultSchema)));
 		if ("error" in typeable) return yield* failWith("type", typeable.error === "stale" && into !== void 0 ? new StaleRef({ ref: into }) : new NotActionable({ detail: typeable.detail }));
 		if (typeable.subject !== void 0) yield* marks.on(typeable.subject);
 		const since = yield* currentDocument("type");
@@ -3432,29 +3360,24 @@ const typeText = (input) => {
 			yield* marks.on(target);
 			if (marks.style.shown) {
 				yield* moveTo("type", marks, target.point, target.cursor);
-				if (approval !== void 0) yield* approval.check({ presses: [{
+				yield* check(approval, { presses: [{
 					index: 0,
 					...target.point
 				}] });
 				yield* marks.sent;
-				for (const type of ["mousePressed", "mouseReleased"]) yield* sendMouse("type", marks.input, {
-					type,
-					...target.point,
-					button: "left",
-					buttons: type === "mousePressed" ? 1 : 0,
-					clickCount: 1
-				});
+				for (const type of ["mousePressed", "mouseReleased"]) yield* sendMouse("type", marks.input, buttonAt(type, target.point));
 				yield* flush("type", marks.input);
 			}
 			yield* marks.sent;
-			const focused = yield* mutate("type", scriptCall("focus", into, replace), approval).pipe(Effect.flatMap(decodeWith("type", FocusResultSchema)));
+			const follow = marks.style.shown && approval === void 0 && !secret && target.name !== "" ? target.name : null;
+			const focused = yield* mutate("type", scriptCall("focus", into, replace, follow), approval).pipe(Effect.flatMap(decodeWith("type", FocusResultSchema)));
 			if ("error" in focused) return yield* editFailure("type", into, focused);
 			secret ||= focused.secret;
 		}
 		if (!secret) yield* marks.reveal;
-		if (approval !== void 0) yield* approval.check({ focused: true });
+		yield* check(approval, { focused: true });
 		yield* marks.sent;
-		const focusHeld = approval === void 0 ? Effect.void : flush("type", marks.input).pipe(Effect.andThen(approval.check({ focused: true })));
+		const focusHeld = check(approval, { focused: true }, flush("type", marks.input));
 		if (text === "" && replace && into !== void 0) {
 			yield* sameDocument("type", since);
 			yield* keyStroke("type", marks.input, ["Delete"]);
@@ -3475,7 +3398,7 @@ const typeText = (input) => {
 		}
 		yield* flush("type", marks.input);
 		if (typeOptions.submit === true) {
-			if (approval !== void 0) yield* approval.check({ focused: true });
+			yield* check(approval, { focused: true });
 			yield* sameDocument("type", since);
 			const before = mark();
 			yield* keyStroke("type", marks.input, ["Enter"]);
@@ -3508,16 +3431,13 @@ const press = (input) => {
 			yield* marks.on(yield* targetFor("press", on, approval, marks));
 			const focused = yield* mutate("press", scriptCall("focusOn", on), approval).pipe(Effect.flatMap(decodeWith("press", EditResultSchema)));
 			if ("error" in focused) return yield* editFailure("press", on, focused);
-			if (approval !== void 0) yield* approval.check({ focused: true });
+			yield* check(approval, { focused: true });
 		}
 		const before = mark();
 		let due = now();
 		yield* marks.sent;
 		for (let index = 0; index < times; index++) {
-			if (index > 0 && approval !== void 0 && activates) {
-				yield* flush("press", marks.input);
-				yield* approval.check({ focused: true });
-			}
+			if (index > 0 && activates) yield* check(approval, { focused: true }, flush("press", marks.input));
 			yield* sameDocument("press", since);
 			yield* keyStroke("press", marks.input, parts, hold);
 			if (index + 1 < times) {
@@ -3537,14 +3457,14 @@ const scroll = (input) => {
 	const { mark, settle } = input;
 	return (scrollOptions = {}, style = plain) => {
 		const target = scrollOptions.at;
-		const valid = Number.isFinite(scrollOptions.dx ?? 0) && Number.isFinite(scrollOptions.dy ?? 0) ? Effect.void : failWith("scroll", new InvalidRequest({ detail: "scroll deltas must be finite" }));
+		const valid = Number.isFinite(scrollOptions.dx ?? 0) && Number.isFinite(scrollOptions.dy ?? 0) ? Effect.void : refuse("scroll", "scroll deltas must be finite");
 		return perform("scroll", {
 			target: target === void 0 ? void 0 : named(target),
 			options: {
 				dx: scrollOptions.dx,
 				dy: scrollOptions.dy
 			}
-		}, settings.actionTimeout, valid.pipe(Effect.andThen(preparePolicy("scroll", { target: typeof target === "string" ? target : void 0 }, target === void 0 ? [] : [target]))), (marks, approval) => Effect.gen(function* () {
+		}, settings.actionTimeout, valid.pipe(Effect.andThen(preparePolicy("scroll", { target: refOf(target) }, target === void 0 ? [] : [target]))), (marks, approval) => Effect.gen(function* () {
 			yield* valid;
 			const viewport = yield* viewportFor("scroll");
 			const middle = {
@@ -3765,7 +3685,7 @@ const timed = (options, native, timestamp, generation) => {
 				hostTime,
 				uncertaintyMillis: uncertaintyAt(estimate, hostTime)
 			}),
-			receivedAt: Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6,
+			receivedAt: monotonicMillis(options.clock),
 			width: size.width,
 			height: size.height,
 			...generation.transport.frameTag()
@@ -3811,7 +3731,7 @@ const sizeFilter = (options, deliver, drop) => Effect.gen(function* () {
 		run = void 0;
 		Queue.offerUnsafe(wake, void 0);
 	};
-	const now = () => Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6;
+	const now = () => monotonicMillis(options.clock);
 	const adopt = (adopted) => {
 		run = void 0;
 		expected = adopted.device;
@@ -3954,7 +3874,7 @@ const make$8 = (options) => Effect.gen(function* () {
 	let latest = Option.none();
 	let history = [];
 	const keepMillis = Duration.toMillis(options.frameHistory);
-	const now = () => Number(options.clock.monotonicTimeNanosUnsafe()) / 1e6;
+	const now = () => monotonicMillis(options.clock);
 	const counts = tally(now);
 	let delivered = 0;
 	const current = (frame) => isCurrent(frame, generation, latest);
@@ -4035,6 +3955,9 @@ const make$8 = (options) => Effect.gen(function* () {
 				return current.phase !== "Stopped" && current.failure === void 0 && !isClosed();
 			};
 			if (current === void 0 || !resumable()) return;
+			pictures.track("picture restoration", options.restore(), failed(current));
+			yield* pictures.wait("picture restoration");
+			yield* healthy(current);
 			const viewport = yield* readViewport(options);
 			if (!resumable()) return;
 			sizes.restart(viewport);
@@ -4473,7 +4396,7 @@ const millisOf = (input) => Option.match(Duration.fromInput(input), {
 });
 const reuse = (page, bridge, viewport, capture) => (operation, options) => Effect.gen(function* () {
 	const maxAge = millisOf(options.maxAge ?? defaultMaxAge);
-	if (!(maxAge >= 0)) return yield* failWith(operation, new InvalidRequest({ detail: "maxAge must be a duration of zero or more" }));
+	if (!(maxAge >= 0)) return yield* refuse(operation, "maxAge must be a duration of zero or more");
 	const latest = yield* capture.latest;
 	const known = viewport.knownViewport();
 	const { activity } = page;
@@ -4498,6 +4421,11 @@ const make$7 = Effect.fnUntraced(function* (page, bridge, viewport) {
 		watch: bridge.currentDocument("screencast"),
 		frameHistory: settings.frameHistory,
 		viewport: Effect.suspend(() => viewport.viewportFor("screencast")),
+		restore: () => page.protocol.send("Page.captureScreenshot", {
+			format: "jpeg",
+			quality: 0,
+			optimizeForSpeed: true
+		}),
 		imageSize: jpegSize,
 		error
 	});
@@ -4549,7 +4477,7 @@ const make$7 = Effect.fnUntraced(function* (page, bridge, viewport) {
 	const zoom = (requested) => lane.read("zoom")(Effect.gen(function* () {
 		const region = yield* Schema.decodeEffect(Region)(requested).pipe(Effect.mapError((error) => undispatched("zoom", new InvalidRequest({ detail: error.message }))));
 		const size = viewport.knownViewport() ?? (yield* viewport.viewportFor("zoom"));
-		if (region.x + region.width > size.width || region.y + region.height > size.height) return yield* failWith("zoom", new InvalidRequest({ detail: "the crop must fit entirely within the viewport" }));
+		if (region.x + region.width > size.width || region.y + region.height > size.height) return yield* refuse("zoom", "the crop must fit entirely within the viewport");
 		const image = yield* picture("zoom", 80, region);
 		return new Zoom({
 			page: id,
@@ -4560,7 +4488,7 @@ const make$7 = Effect.fnUntraced(function* (page, bridge, viewport) {
 	const captureStats = (options = {}) => {
 		if (options.window === void 0) return capture.stats();
 		const millis = millisOf(options.window);
-		return millis > 0 && millis <= Duration.toMillis(countsKept) ? capture.stats(millis) : failWith("captureStats", new InvalidRequest({ detail: "window must be over zero and at most a minute" }));
+		return millis > 0 && millis <= Duration.toMillis(countsKept) ? capture.stats(millis) : refuse("captureStats", "window must be over zero and at most a minute");
 	};
 	return {
 		capture,
@@ -4578,10 +4506,6 @@ const make$7 = Effect.fnUntraced(function* (page, bridge, viewport) {
 * read takes its turn on the page and shares its work with identical reads, as `lane.ts`
 * describes. The viewport's text as it was last read is kept, for `Page.state`.
 */
-const SnapshotResult = Schema.Union([Schema.Struct({
-	snapshot: Snapshot,
-	nextRef: Schema.Finite
-}), Schema.Struct({ invalid: Schema.String })]);
 const FindResults = Schema.Struct({
 	found: Schema.Array(Found),
 	nextRef: Schema.Finite
@@ -4590,7 +4514,6 @@ const UntilResult = Schema.Struct({
 	met: Schema.Boolean,
 	mark: Schema.String
 });
-const ConditionResult = Schema.Union([Schema.Struct({ met: Schema.Boolean }), Schema.Struct({ invalid: Schema.String })]);
 const wanted = (value) => value === void 0 ? null : typeof value === "string" ? value : {
 	source: value.source,
 	flags: value.flags
@@ -4625,8 +4548,8 @@ const make$6 = Effect.fnUntraced(function* (page, bridge) {
 				...asked,
 				firstRef: yield* Ref.get(nextRef)
 			};
-			const result = yield* evaluate("snapshot", scriptCall("snapshot", request)).pipe(Effect.flatMap(decodeWith("snapshot", SnapshotResult)));
-			if ("invalid" in result) return yield* failWith("snapshot", new InvalidRequest({ detail: result.invalid }));
+			const result = yield* evaluate("snapshot", scriptCall("snapshot", request)).pipe(Effect.flatMap(decodeWith("snapshot", SnapshotResultSchema)));
+			if ("invalid" in result) return yield* refuse("snapshot", result.invalid);
 			const { text, truncated, url } = result.snapshot;
 			yield* counted(result.nextRef);
 			yield* Effect.annotateCurrentSpan({
@@ -4662,7 +4585,7 @@ const make$6 = Effect.fnUntraced(function* (page, bridge) {
 			maxChars: options.maxChars ?? 12e3,
 			unmask: options.unmask ?? false
 		};
-		return (scope !== "viewport" && !/^e\d+$/.test(scope) ? failWith("text", new InvalidRequest({ detail: `${scope} is neither "viewport" nor a ref such as e12` })) : texts(JSON.stringify(request), Effect.gen(function* () {
+		return (scope !== "viewport" && !/^e\d+$/.test(scope) ? refuse("text", `${scope} is neither "viewport" nor a ref such as e12`) : texts(JSON.stringify(request), Effect.gen(function* () {
 			const result = yield* evaluate("text", scriptCall("text", request)).pipe(Effect.flatMap(decodeWith("text", TextResultSchema)));
 			if (result === null) return yield* failWith("text", new StaleRef({ ref: scope }));
 			yield* Effect.annotateCurrentSpan({
@@ -4686,7 +4609,7 @@ const make$6 = Effect.fnUntraced(function* (page, bridge) {
 		};
 		const millis = Math.min(Duration.toMillis(timeout), Number.MAX_SAFE_INTEGER);
 		const unmet = () => failWith("waitFor", new Timeout({ millis }));
-		const look = evaluate("waitFor", scriptCall("waitUntil", request, millis)).pipe(Effect.flatMap(decodeWith("waitFor", ConditionResult)), Effect.flatMap((result) => "invalid" in result ? failWith("waitFor", new InvalidRequest({ detail: result.invalid })) : result.met ? Effect.void : unmet()));
+		const look = evaluate("waitFor", scriptCall("waitUntil", request, millis)).pipe(Effect.flatMap(decodeWith("waitFor", ConditionResultSchema)), Effect.flatMap((result) => "invalid" in result ? refuse("waitFor", result.invalid) : result.met ? Effect.void : unmet()));
 		return lane.read("waitFor")(Effect.void).pipe(Effect.andThen(Effect.retry(look, { while: contextGone })), Effect.timeoutOrElse({
 			duration: timeout,
 			orElse: unmet
@@ -4714,6 +4637,51 @@ const make$6 = Effect.fnUntraced(function* (page, bridge) {
 	};
 });
 //#endregion
+//#region src/internal/pictures/motion.ts
+/**
+* Where a page's screen moves, from its screencast frames: each frame decoded and cut into
+* 16-pixel blocks, a block moving where a few of its pixels, sampled every other one, changed by
+* more than JPEG's noise in any color channel.
+* What moved among the frames before an input is the page's background, such as an idle
+* animation; foreground stillness ignores it.
+*
+* Frames are decoded with the JPEG decoder playwright-core bundles and exports as
+* `playwright-core/lib/utilsBundle`: effect-browser depends on nothing else, and the runtime has
+* no image decoder. That entry point has no types, so `utilsBundle.d.ts` declares what is used.
+*/
+const picture = (frame) => jpegjs.decode(frame.data, { useTArray: true });
+/** A sample changed where any color channel moved more than this, beyond JPEG's noise. */
+const noise = 32;
+/** The blocks where two pictures differ, by `row * columns + column`; -1 for different sizes. */
+const moved = (from, to) => {
+	if (from.width !== to.width || from.height !== to.height) return [-1];
+	const columns = Math.ceil(from.width / 16);
+	const counts = /* @__PURE__ */ new Map();
+	const differs = (at) => Math.abs((from.data[at] ?? 0) - (to.data[at] ?? 0)) > noise;
+	for (let y = 0; y < from.height; y += 2) for (let x = 0; x < from.width; x += 2) {
+		const at = (y * from.width + x) * 4;
+		const block = Math.floor(y / 16) * columns + Math.floor(x / 16);
+		if (differs(at) || differs(at + 1) || differs(at + 2)) counts.set(block, (counts.get(block) ?? 0) + 1);
+	}
+	return [...counts].flatMap(([block, count]) => count >= 3 ? [block] : []);
+};
+/** The blocks that moved from one picture to the next and their neighbours; none past a resize. */
+const background = (pictures) => {
+	const columns = Math.ceil((pictures[0]?.width ?? 0) / 16);
+	const around = (block) => [
+		-1,
+		0,
+		1
+	].flatMap((row) => [
+		-1,
+		0,
+		1
+	].filter((step) => block >= 0 && block % columns + step >= 0).filter((step) => block % columns + step < columns).map((step) => block + row * columns + step));
+	return new Set(pictures.flatMap((to, index) => moved(pictures[index - 1] ?? to, to).flatMap(around)));
+};
+/** Whether anything moved from one picture to another outside the background. */
+const stirs = (from, to, mask) => moved(from, to).some((block) => !mask.has(block));
+//#endregion
 //#region src/internal/reading/ready.ts
 /**
 * Waiting until a page is ready to be shown. The page's own evidence leads: one page-script call
@@ -4727,7 +4695,10 @@ const make$6 = Effect.fnUntraced(function* (page, bridge) {
 * its connection, and a frame that arrives first starts the spell again. Where the page's changes
 * are recorded, its evidence includes them: nothing in view may have changed for the spell, which a
 * DOM page's changes show better than its paint, and no stall on the way can hide. Content
-* stillness starts that record itself and ignores capture silence. Each new document starts a
+* stillness starts that record itself and ignores capture silence. Foreground stillness lets
+* frames keep coming but compares them, so that only motion outside what was moving before the
+* page's latest input counts; it still waits out unanswered acknowledgements while no frame
+* comes, and its last look follows the round trip too. Each new document starts a
 * new observation, while retries of destroyed script contexts share the caller's deadline.
 */
 const make$5 = (page, bridge, capture) => (options = {}) => {
@@ -4738,30 +4709,54 @@ const make$5 = (page, bridge, capture) => (options = {}) => {
 	}), Effect.flatMap(decodeWith("ready", ReadinessSchema)), Effect.tap((waiting) => Effect.annotateCurrentSpan({ waiting: waiting.join(",") })), Effect.filterOrElse((waiting) => waiting.length === 0, () => failWith("ready", new Timeout({ millis: Duration.toMillis(timeout) }))));
 	const quiet = (millis, until) => Effect.gen(function* () {
 		const running = yield* capture.active;
-		let { received } = yield* capture.stats();
+		const foreground = options.still === "foreground";
+		let counts = yield* capture.stats();
 		let stirred = running ? page.now() : Number.POSITIVE_INFINITY;
+		let reference;
+		const decoded = (frame) => Effect.try({
+			try: () => picture(frame),
+			catch: (error) => undispatched("ready", new Failed({ detail: `no picture: ${String(error)}` }))
+		});
+		const { inputAt } = page.activity;
+		const document = Option.getOrUndefined(yield* capture.latest)?.document;
+		const before = (foreground ? yield* capture.recent : []).filter((frame) => frame.hostTime < inputAt && frame.hostTime >= inputAt - 1500 && frame.document === document);
+		const sampled = before.filter((_, index) => index % Math.ceil(before.length / 8) === 0);
+		const mask = background(yield* Effect.forEach(sampled, decoded));
 		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();
+			const latest = Option.getOrUndefined(yield* capture.latest);
+			const arrived = stats.received !== counts.received;
+			const unseen = stats.accepted - counts.accepted;
+			counts = stats;
+			if (latest === void 0 || !capture.current(latest)) stirred = page.now();
+			else if (!foreground ? arrived || stats.ackBacklog > 0 : !arrived && stats.ackBacklog > 0) stirred = page.now();
+			else if (foreground && (unseen > 0 || reference === void 0)) {
+				const frames = (yield* capture.recent).slice(-Math.max(1, Math.min(8, unseen)));
+				if (unseen > frames.length) stirred = page.now();
+				for (const frame of frames) {
+					const seen = yield* decoded(frame);
+					if (reference === void 0 || stirs(reference, seen, mask)) {
+						reference = seen;
+						stirred = page.now();
+					}
+				}
 			}
 			return page.now() - stirred;
 		});
 		const spell = Effect.repeat(look, {
-			schedule: Schedule.spaced(Duration.millis(25)),
+			schedule: Schedule.fixed(Duration.millis(foreground ? 100 : 25)),
 			until: (still) => still >= millis
 		});
 		const capturing = running ? Effect.never : capture.stream().pipe(Stream.runDrain, Effect.andThen(Effect.never));
 		const still = Effect.gen(function* () {
 			for (;;) {
 				yield* spell;
-				const before = received;
+				const before = counts.received;
 				yield* Effect.all([settled(until), capture.sync], {
 					concurrency: 2,
 					discard: true
 				});
-				if ((yield* look) >= millis && received === before) return;
+				if ((yield* look) >= millis && (foreground || counts.received === before)) return;
 			}
 		});
 		return yield* Effect.raceFirst(capturing, still);
@@ -4860,7 +4855,7 @@ const make$3 = (page, read, frames) => ({ since, until, unmask }) => Effect.gen(
 		since,
 		until
 	}, page.now());
-	if (Option.isNone(asked)) return yield* failWith("window", new InvalidRequest({ detail: "a window's bounds must be finite, its reach not negative" }));
+	if (Option.isNone(asked)) return yield* refuse("window", "a window's bounds must be finite, its reach not negative");
 	const bounds = asked.value;
 	const changes = yield* Effect.result(read({
 		since: isWindow(since) ? since.changes ?? bounds.since : isFrame(since) ? since : bounds.since,
@@ -4949,7 +4944,7 @@ const make$2 = (page, perform, preparePolicy) => {
 			"about:",
 			"data:",
 			"file:"
-		].includes(parsed.protocol)) return failWith("navigate", new InvalidRequest({ detail: `"${redact(url)}" is not a URL` }));
+		].includes(parsed.protocol)) return refuse("navigate", `"${redact(url)}" is not a URL`);
 		return navigation("navigate", () => playwright.goto(parsed.href, {
 			waitUntil: "domcontentloaded",
 			timeout: 0
@@ -5099,6 +5094,6 @@ const make = Effect.fnUntraced(function* (options) {
 	return Object.assign(new Built(internals), assembled);
 });
 //#endregion
-export { performed as a, pause as i, make as n, mapping as o, viewOf as r, internalsOf as t };
+export { performed as a, pause as i, make as n, viewOf as r, internalsOf as t };
 
-//# sourceMappingURL=page-B92QnRfT.mjs.map
+//# sourceMappingURL=page-BKwfF6z-.mjs.map