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

package/dist/Capture.mjs

@@ -1,678 +0,0 @@
-import { BrowserError, Reasons } from "./Errors.mjs";
-import { t as capturePageParent } from "./PageRegistry-B3q9DS3g.mjs";
-import { A as stream$1, O as span, k as start$1, n as checkedOperationOptions, t as checked } from "./PublicSession-DCSMMqOj.mjs";
-import { t as jpegGeometry } from "./Images-yCG9BmRU.mjs";
-import { a as CaptureSummary, c as CaptureLimits, i as CaptureSnapshot, l as CaptureMaxima, n as CaptureQualification, o as CapturedFrame, r as CaptureSize, s as CaptureDefaults, t as CaptureOptions } from "./CaptureData-CYriZHX1.mjs";
-import { Cause, Clock, Crypto, Deferred, Duration, Effect, Exit, Option, Queue, Schema, Stream } from "effect";
-//#region src/internal/capture/FrameBuffer.ts
-/** Callback-side bounded retention. No Promise, Effect, blocked producer, or per-frame fiber. */
-var FrameBuffer = class {
-	maximumFrames;
-	maximumBytes;
-	items = [];
-	retained = 0;
-	dropped = 0;
-	received = 0;
-	highWaterBytes = 0;
-	highWaterFrames = 0;
-	constructor(maximumFrames, maximumBytes) {
-		if (!Number.isSafeInteger(maximumFrames) || maximumFrames < 1 || maximumFrames > CaptureMaxima.frames || !Number.isSafeInteger(maximumBytes) || maximumBytes < 1 || maximumBytes > 67108864) throw new RangeError("Invalid capture retention limits");
-		this.maximumFrames = maximumFrames;
-		this.maximumBytes = maximumBytes;
-	}
-	offer(frame) {
-		this.received++;
-		if (frame.bytes.byteLength > this.maximumBytes) {
-			this.dropped++;
-			return false;
-		}
-		while (this.items.length >= this.maximumFrames || this.retained + frame.bytes.byteLength > this.maximumBytes) {
-			const removed = this.items.shift();
-			if (removed === void 0) break;
-			this.retained -= removed.bytes.byteLength;
-			this.dropped++;
-		}
-		this.items.push(frame);
-		this.retained += frame.bytes.byteLength;
-		this.highWaterBytes = Math.max(this.highWaterBytes, this.retained);
-		this.highWaterFrames = Math.max(this.highWaterFrames, this.items.length);
-		return true;
-	}
-	take() {
-		const frame = this.items.shift();
-		if (frame !== void 0) this.retained -= frame.bytes.byteLength;
-		return frame;
-	}
-	clear() {
-		this.items.length = 0;
-		this.retained = 0;
-	}
-	get size() {
-		return this.items.length;
-	}
-	get bytes() {
-		return this.retained;
-	}
-};
-//#endregion
-//#region src/internal/capture/Capture.ts
-const MaxParentCaptures = 4;
-const MaxParentBufferedBytes = 67108864;
-const MaxDocumentBoundaries = 64;
-const MaxDocumentUrlLength = 8192;
-/** An over-long address is recorded as null rather than cut into one that was never shown. */
-const documentUrl = (url) => typeof url === "string" && url.length <= MaxDocumentUrlLength ? url : null;
-/**
-* Chromium stamps a screencast frame on its UI thread, encodes it on an unsequenced thread
-* pool, and emits it when that encode completes. It admits a new frame while at most two are
-* unacknowledged (`kMaxScreencastFramesInFlight`), so up to three encode at once and two
-* frames stamped close together can complete in either order. Every frame stamped before an
-* accepted one was already in flight when that one was stamped, so at most two late frames
-* can arrive in a row. A longer run is source time that really went backwards.
-*/
-const MaxConsecutiveLateFrames = 2;
-const Metadata = Schema.Struct({
-	timestamp: Schema.Finite.check(Schema.isGreaterThan(0)),
-	viewportWidth: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 16384
-	})),
-	viewportHeight: Schema.Int.check(Schema.isBetween({
-		minimum: 1,
-		maximum: 16384
-	}))
-});
-const decodeMetadata = Schema.decodeUnknownOption(Metadata);
-/** Private seam for deterministic callback/lifetime tests. The public start accepts a real live session. */
-const acquireCapture = Effect.fnUntraced(function* (parent, options = {}) {
-	const maxFrames = options.maxFrames ?? CaptureDefaults.maxFrames;
-	const maxBytes = options.maxBufferedBytes ?? CaptureDefaults.maxBufferedBytes;
-	const maxFrameBytes = options.maxFrameBytes ?? CaptureDefaults.maxFrameBytes;
-	const duration = options.maxDurationMillis ?? CaptureDefaults.maxDurationMillis;
-	const quality = options.quality ?? CaptureDefaults.quality;
-	const size = options.size === void 0 ? void 0 : yield* Schema.decodeEffect(CaptureSize)(options.size, { onExcessProperty: "error" }).pipe(Effect.map(({ width, height }) => Object.freeze({
-		width,
-		height
-	})), Effect.mapError(() => BrowserError.make({
-		operation: "capture",
-		reason: Reasons.Configuration.make({}),
-		outcome: "undispatched"
-	})));
-	yield* Schema.decodeEffect(CaptureLimits)({
-		maxFrames,
-		maxBufferedBytes: maxBytes,
-		maxFrameBytes,
-		maxDurationMillis: duration,
-		quality
-	}).pipe(Effect.mapError(() => BrowserError.make({
-		operation: "capture",
-		reason: Reasons.Configuration.make({}),
-		outcome: "undispatched"
-	})));
-	let interval;
-	yield* Effect.addFinalizer((exit) => Effect.sync(() => interval?.end(exit)));
-	const clock = parent.owner.clock;
-	const captureId = yield* parent.newCaptureId;
-	const wake = yield* Queue.dropping(1);
-	const finished = yield* Queue.dropping(1);
-	const completed = yield* Deferred.make();
-	yield* Effect.addFinalizer(() => Queue.shutdown(wake).pipe(Effect.andThen(Queue.shutdown(finished)), Effect.asVoid));
-	const buffer = new FrameBuffer(maxFrames, maxBytes);
-	let source;
-	let startPromise;
-	let startSettled = true;
-	let target;
-	let leaseKey;
-	let targetStatus;
-	let metadata;
-	let terminalAuthority;
-	let ended = false, subscribed = false, cleanupFinished = false;
-	let reason = "stopped";
-	let error;
-	let received = 0, delivered = 0, rejected = 0, duplicates = 0, late = 0, lateRun = 0;
-	let first, last;
-	let document = 0;
-	let captureBoundary = 0;
-	let acceptedBoundary = -1;
-	let initialUrl = null;
-	let initialUrlQualification = "Unread";
-	let documentBoundariesTruncated = false;
-	const documentBoundaries = [];
-	/** A URL change is recorded; only a new document advances the frame attribution. */
-	const nextDocument = (url, sameDocument = false) => {
-		if (ended) return;
-		captureBoundary++;
-		if (!sameDocument) document++;
-		if (documentBoundaries.length >= MaxDocumentBoundaries) {
-			documentBoundaries.shift();
-			documentBoundariesTruncated = true;
-		}
-		const boundary = {
-			document,
-			sameDocument,
-			observedMonotonicNanos: clock.monotonicTimeNanosUnsafe(),
-			afterSequence: received === 0 ? null : received - 1,
-			url: documentUrl(url)
-		};
-		documentBoundaries.push(boundary);
-		if (target !== void 0) metadata?.({
-			_tag: "CaptureBoundary",
-			captureId,
-			target,
-			captureBoundary,
-			captureDocument: document,
-			sameDocument: boundary.sameDocument,
-			observedMonotonicNanos: boundary.observedMonotonicNanos,
-			afterSequence: boundary.afterSequence,
-			url: boundary.url,
-			urlQualification: boundary.url === null ? "Omitted" : "NativeCached"
-		});
-	};
-	let geometry;
-	let nativeStop = "unconfirmed";
-	let lease;
-	let reservationReleased = false;
-	let preStartStopConfirmed = false;
-	let postStartStopStarted = false;
-	const releaseReservation = () => {
-		if (reservationReleased) return;
-		reservationReleased = true;
-		source?.release?.();
-		if (leaseKey !== void 0 && lease !== void 0 && parent.captureLeases.get(leaseKey) === lease) {
-			parent.captureLeases.delete(leaseKey);
-			parent.captureReservedBytes = Math.max(0, parent.captureReservedBytes - lease.reservedBytes);
-		}
-	};
-	let confirmPostStartStop = () => {};
-	const observeStop = (stopping, afterStart) => {
-		stopping.then(() => {
-			if (afterStart) {
-				nativeStop = "confirmed";
-				releaseReservation();
-				if (cleanupFinished) publishCapture("Stopped");
-			} else {
-				preStartStopConfirmed = true;
-				confirmPostStartStop();
-			}
-		}, () => {});
-	};
-	confirmPostStartStop = () => {
-		const stoppingSource = source;
-		if (!preStartStopConfirmed || !startSettled || postStartStopStarted || stoppingSource === void 0 || leaseKey === void 0 || lease === void 0 || parent.captureLeases.get(leaseKey) !== lease) return;
-		postStartStopStarted = true;
-		observeStop(Promise.resolve().then(() => stoppingSource.stop()), true);
-	};
-	const finish = (why, failure) => {
-		if (ended) return;
-		ended = true;
-		reason = why;
-		error = failure;
-		publishCapture("Ended");
-		Queue.offerUnsafe(wake, void 0);
-		Queue.offerUnsafe(finished, void 0);
-	};
-	const snapshot = () => {
-		if (target === void 0) throw new Error("Capture target was not admitted");
-		const status = targetStatus?.();
-		const ownerPhase = parent.owner.state.phase;
-		const ownerGeneration = parent.owner.state.generation;
-		const sessionFenced = [
-			"uncertain",
-			"faulted",
-			"closing",
-			"closed"
-		].includes(ownerPhase);
-		const containment = status !== void 0 && status.containment._tag !== "NotRequired" ? { ...status.containment } : sessionFenced ? {
-			_tag: "SessionFenced",
-			generation: ownerGeneration
-		} : { _tag: "NotRequired" };
-		const qualification = {
-			authority: status?.phase === "closed" || terminalAuthority === "closed" ? "closed" : target.generation !== ownerGeneration ? "stale" : status?.phase ?? terminalAuthority ?? "open",
-			containment,
-			ownerPhase,
-			ownerGeneration
-		};
-		return CaptureSummary.make({
-			target,
-			qualification,
-			reason,
-			received,
-			delivered,
-			discarded: buffer.dropped + rejected + late + duplicates,
-			overflow: buffer.dropped,
-			duplicates,
-			late,
-			rejected,
-			peakBufferedFrames: buffer.highWaterFrames,
-			peakBufferedBytes: buffer.highWaterBytes,
-			bufferedFrames: buffer.size,
-			bufferedBytes: buffer.bytes,
-			sourceFirstMillis: first ?? null,
-			sourceLastMillis: last ?? null,
-			initialUrl,
-			documentBoundaries: documentBoundaries.map((boundary) => ({ ...boundary })),
-			documentBoundariesTruncated,
-			nativeStop,
-			upstreamDrops: "unknown",
-			...error === void 0 ? {} : { error: BrowserError.make({
-				operation: error.operation,
-				reason: { ...error.reason },
-				outcome: error.outcome,
-				...error.containment !== void 0 ? { containment: { ...error.containment } } : containment._tag === "NotRequired" ? {} : { containment }
-			}) }
-		});
-	};
-	const publishCapture = (phase) => {
-		if (metadata === void 0 || target === void 0) return;
-		const facts = snapshot();
-		metadata({
-			_tag: "Capture",
-			captureId,
-			target,
-			phase,
-			latePhase: ended && (phase === "Watching" || phase === "Started"),
-			observedMonotonicNanos: clock.monotonicTimeNanosUnsafe(),
-			captureBoundary,
-			captureDocument: document,
-			qualification: facts.qualification,
-			initialUrl,
-			initialUrlQualification,
-			reason: ended ? reason : null,
-			nativeStop: phase === "Stopped" ? nativeStop : null,
-			received,
-			delivered,
-			discarded: facts.discarded,
-			overflow: facts.overflow,
-			late,
-			duplicates,
-			rejected,
-			upstreamDrops: "unknown"
-		});
-	};
-	const stopNative = (yield* Effect.cached(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
-		finish("stopped");
-		if (startPromise !== void 0 && !startSettled) {
-			const starting = startPromise;
-			yield* restore(Effect.tryPromise({
-				try: () => starting,
-				catch: () => BrowserError.make({
-					operation: "capture-start",
-					reason: Reasons.Provider.make({}),
-					outcome: "unknown"
-				})
-			}).pipe(Effect.timeout(2e3), span("Browser.capture.start-settlement"), Effect.exit));
-		}
-		if (source !== void 0) {
-			const stopping = source;
-			const afterStart = startSettled;
-			const stop = Promise.resolve().then(() => stopping.stop());
-			observeStop(stop, afterStart);
-			const stopped = yield* restore(Effect.tryPromise({
-				try: () => stop,
-				catch: () => BrowserError.make({
-					operation: "capture-stop",
-					reason: Reasons.Provider.make({}),
-					outcome: "unknown"
-				})
-			}).pipe(Effect.timeout(3e3), span("Browser.capture.native-stop"))).pipe(Effect.exit);
-			if (Exit.isSuccess(stopped) && afterStart) {
-				nativeStop = "confirmed";
-				releaseReservation();
-			}
-		} else nativeStop = "confirmed";
-		if (nativeStop === "confirmed") releaseReservation();
-		cleanupFinished = true;
-		publishCapture("Stopped");
-		interval?.end(error === void 0 ? Exit.void : Exit.fail(error), {
-			"browser.capture.reason": reason,
-			"browser.capture.native-stop": nativeStop,
-			"browser.capture.received": received,
-			"browser.capture.discarded": buffer.dropped + rejected + late + duplicates
-		});
-		return snapshot();
-	}).pipe(span("Browser.capture.cleanup"))).pipe(Effect.provideService(Clock.Clock, clock)))).pipe(Effect.tap(() => Deferred.succeed(completed, void 0)));
-	const receive = (frame) => {
-		if (ended) return;
-		if (target === void 0 || parent.owner.state.generation !== target.generation || parent.owner.state.phase !== "open") {
-			finish("parent-unavailable", BrowserError.make({
-				operation: "capture",
-				reason: Reasons.Closed.make({}),
-				outcome: "undispatched"
-			}));
-			return;
-		}
-		const sequence = received++;
-		try {
-			const decoded = decodeMetadata(frame);
-			if (Option.isNone(decoded)) {
-				rejected++;
-				finish("malformed-frame", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Malformed.make({}),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			const meta = decoded.value;
-			if (!(frame.data instanceof Uint8Array)) {
-				rejected++;
-				finish("malformed-frame", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Malformed.make({ path: "bytes" }),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			if (frame.data.length > maxFrameBytes) {
-				rejected++;
-				finish("frame-limit", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Limit.make({
-						dimension: "frame-bytes",
-						maximum: maxFrameBytes,
-						observed: frame.data.length
-					}),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			if (last !== void 0 && meta.timestamp < last) {
-				late++;
-				if (++lateRun > MaxConsecutiveLateFrames) finish("timestamp-discontinuity", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Timestamp.make({}),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			if (last === meta.timestamp) {
-				duplicates++;
-				return;
-			}
-			const dimensions = jpegGeometry(frame.data);
-			if (frame.data[frame.data.length - 2] !== 255 || frame.data[frame.data.length - 1] !== 217) {
-				rejected++;
-				finish("malformed-frame", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Malformed.make({ path: "bytes" }),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			const maximumWidth = Math.min(16384, size?.width ?? 16384);
-			const maximumHeight = Math.min(16384, size?.height ?? 16384);
-			const excessive = dimensions.width > maximumWidth ? Reasons.Limit.make({
-				dimension: "width",
-				maximum: maximumWidth,
-				observed: dimensions.width
-			}) : dimensions.height > maximumHeight ? Reasons.Limit.make({
-				dimension: "height",
-				maximum: maximumHeight,
-				observed: dimensions.height
-			}) : dimensions.width * dimensions.height > 33554432 ? Reasons.Limit.make({
-				dimension: "pixels",
-				maximum: 33554432,
-				observed: dimensions.width * dimensions.height
-			}) : void 0;
-			if (excessive !== void 0) {
-				rejected++;
-				finish("frame-limit", BrowserError.make({
-					operation: "capture",
-					reason: excessive,
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			if (geometry !== void 0 && (geometry.width !== dimensions.width || geometry.height !== dimensions.height || geometry.viewportWidth !== meta.viewportWidth || geometry.viewportHeight !== meta.viewportHeight)) {
-				rejected++;
-				finish("resized", BrowserError.make({
-					operation: "capture",
-					reason: Reasons.Resized.make({}),
-					outcome: "undispatched"
-				}));
-				return;
-			}
-			geometry ??= {
-				...dimensions,
-				viewportWidth: meta.viewportWidth,
-				viewportHeight: meta.viewportHeight
-			};
-			first ??= meta.timestamp;
-			last = meta.timestamp;
-			lateRun = 0;
-			const receivedMonotonicNanos = clock.monotonicTimeNanosUnsafe();
-			buffer.offer({
-				bytes: new Uint8Array(frame.data),
-				mediaType: "image/jpeg",
-				target,
-				sequence,
-				document,
-				sourceTimeMillis: meta.timestamp,
-				sourceClock: "presentation-unix-millis",
-				receivedMonotonicNanos,
-				...dimensions,
-				viewportWidth: meta.viewportWidth,
-				viewportHeight: meta.viewportHeight
-			});
-			if (captureBoundary !== acceptedBoundary) {
-				acceptedBoundary = captureBoundary;
-				metadata?.({
-					_tag: "FirstFrame",
-					captureId,
-					target,
-					captureBoundary,
-					captureDocument: document,
-					frameSequence: sequence,
-					sourceTimeMillis: meta.timestamp,
-					sourceClock: "presentation-unix-millis",
-					receivedMonotonicNanos,
-					...dimensions,
-					viewportWidth: meta.viewportWidth,
-					viewportHeight: meta.viewportHeight
-				});
-			}
-			Queue.offerUnsafe(wake, void 0);
-		} catch {
-			rejected++;
-			finish("malformed-frame", BrowserError.make({
-				operation: "capture",
-				reason: Reasons.Malformed.make({}),
-				outcome: "undispatched"
-			}));
-		}
-	};
-	yield* parent.validate("capture-start");
-	const requested = parent.page;
-	const generation = parent.owner.state.generation;
-	yield* parent.owner.guard("capture-start", (ticket) => Effect.gen(function* () {
-		const resolved = yield* parent.resolve(ticket, requested);
-		target = Object.freeze(resolved.target);
-		targetStatus = resolved.status;
-		metadata = resolved.metadata;
-		const resolvedSource = resolved.source;
-		source = resolvedSource;
-		leaseKey = resolved.key;
-		if (parent.captureLeases.has(leaseKey)) return yield* BrowserError.make({
-			operation: "capture",
-			reason: Reasons.Busy.make({}),
-			outcome: "undispatched"
-		});
-		if (parent.captureLeases.size >= MaxParentCaptures || parent.captureReservedBytes + maxBytes > MaxParentBufferedBytes) return yield* BrowserError.make({
-			operation: "capture",
-			reason: parent.captureLeases.size >= MaxParentCaptures ? Reasons.Limit.make({
-				dimension: "captures",
-				maximum: MaxParentCaptures,
-				observed: parent.captureLeases.size + 1
-			}) : Reasons.Limit.make({
-				dimension: "buffered-bytes",
-				maximum: MaxParentBufferedBytes,
-				observed: parent.captureReservedBytes + maxBytes
-			}),
-			outcome: "undispatched"
-		});
-		yield* Effect.uninterruptible(start$1("Browser.capture.interval", { attributes: {
-			"browser.operation": "capture",
-			"browser.capture.lifetime": options.lifetime === "page" ? "page" : "document"
-		} }).pipe(Effect.tap((started) => Effect.sync(() => {
-			interval = started;
-		}))));
-		lease = {
-			pageId: target.pageId,
-			reservedBytes: maxBytes,
-			stop: stopNative.pipe(Effect.asVoid),
-			invalidate: (why) => {
-				if (why === "target-closed") terminalAuthority = "closed";
-				else if (why === "closed") terminalAuthority ??= "closing";
-				if (why === "target-closed") releaseReservation();
-				finish(why === "resized" ? "resized" : "target-changed", BrowserError.make({
-					operation: "capture",
-					reason: why === "resized" ? Reasons.Resized.make({}) : Reasons.TargetChanged.make({}),
-					outcome: "undispatched"
-				}));
-			}
-		};
-		parent.captureLeases.set(leaseKey, lease);
-		parent.captureReservedBytes += maxBytes;
-		yield* Effect.addFinalizer(() => stopNative.pipe(Effect.andThen(Effect.sync(() => {
-			rejected += buffer.size;
-			buffer.clear();
-		}))));
-		publishCapture("Reserved");
-		startSettled = false;
-		yield* Effect.tryPromise({
-			try: () => {
-				try {
-					startPromise = resolvedSource.start({
-						receive,
-						quality,
-						invalidate: (why) => lease?.invalidate(why),
-						opened: (url) => {
-							initialUrl = documentUrl(url);
-							initialUrlQualification = initialUrl === null ? "Omitted" : "NativeCached";
-							publishCapture("Watching");
-						},
-						...size === void 0 ? {} : { size },
-						...options.lifetime === "page" ? { document: nextDocument } : {}
-					});
-				} catch (error) {
-					startSettled = true;
-					throw error;
-				}
-				const cleanupAfterLateStart = () => {
-					startSettled = true;
-					confirmPostStartStop();
-				};
-				startPromise.then(cleanupAfterLateStart, cleanupAfterLateStart);
-				return startPromise;
-			},
-			catch: () => BrowserError.make({
-				operation: "capture-start",
-				reason: Reasons.Provider.make({}),
-				outcome: "unknown"
-			})
-		}).pipe(span("Browser.capture.native-start"));
-		publishCapture("Started");
-		ticket.check();
-	}), {
-		charge: false,
-		admission: options.admission,
-		targetScope: () => ({ pageId: requested.pageId }),
-		preflight: parent.validate("capture-start").pipe(Effect.andThen(Effect.suspend(() => generation === parent.owner.state.generation ? Effect.void : Effect.fail(BrowserError.make({
-			operation: "capture-start",
-			reason: Reasons.Stale.make({}),
-			outcome: "undispatched"
-		})))))
-	}).pipe(Effect.provideService(Clock.Clock, clock), Effect.onExit((exit) => Effect.sync(() => {
-		if (Exit.isFailure(exit)) interval?.end(exit);
-	})), Effect.onError(() => lease === void 0 ? Effect.void : stopNative.pipe(Effect.asVoid)), Effect.onInterrupt(() => lease === void 0 ? Effect.void : stopNative.pipe(Effect.asVoid)));
-	yield* Effect.raceFirst(Queue.take(finished).pipe(Effect.as(false)), clock.sleep(Duration.millis(duration)).pipe(Effect.as(true))).pipe(Effect.tap((expired) => expired ? Effect.sync(() => finish("duration-limit")) : Effect.void), Effect.andThen(stopNative), Effect.forkScoped);
-	const next = Effect.suspend(() => {
-		const frame = buffer.take();
-		if (frame !== void 0) {
-			delivered++;
-			return Effect.succeed(frame);
-		}
-		if (ended) return error === void 0 ? Cause.done() : Effect.fail(error);
-		return Queue.take(wake).pipe(Effect.andThen(next));
-	});
-	return {
-		id: captureId,
-		frames: Stream.unwrap(Effect.suspend(() => {
-			if (subscribed) return Effect.fail(BrowserError.make({
-				operation: "capture-consume",
-				reason: Reasons.Busy.make({}),
-				outcome: "undispatched"
-			}));
-			subscribed = true;
-			return Effect.succeed(Stream.fromEffectRepeat(next).pipe(Stream.ensuring(stopNative.pipe(Effect.asVoid))));
-		})).pipe(stream$1("Browser.capture.consume")),
-		snapshot: Effect.sync(() => {
-			const { reason, nativeStop, ...metadata } = snapshot();
-			return CaptureSnapshot.make({
-				...metadata,
-				phase: cleanupFinished ? "stopped" : ended ? "stopping" : "capturing",
-				observedMonotonicNanos: clock.monotonicTimeNanosUnsafe(),
-				currentDocument: document,
-				reason: ended ? reason : null,
-				nativeStop: cleanupFinished ? nativeStop : null
-			});
-		}),
-		stop: stopNative,
-		completed: Deferred.await(completed).pipe(Effect.map(snapshot))
-	};
-});
-const startCapture = (parent, options = {}) => acquireCapture(parent, options).pipe(span("Browser.capture.start", { attributes: { "browser.operation": "capture-start" } }));
-//#endregion
-//#region src/Capture.ts
-/**
-* Capture one remote page independently of the session's selected page.
-*
-* Requires an exact issued Page; copying an object or decoding a durable reference cannot
-* copy its capture authority. The private owner is not frame data.
-* `CapturedFrame` and `CaptureOptions` are Schema values as well as structural types. Frame
-* decoding checks binary/metadata fields, not the complete JPEG bitstream or target authority,
-* and does not copy bytes. Options decoding preserves omissions; admission applies defaults.
-* `CaptureInterval` remains a live scoped capability, not a schema or JSON/Tool value.
-*/
-const start = (page, options = {}) => Effect.suspend(() => {
-	const parent = capturePageParent(page);
-	if (parent === void 0) return Effect.fail(BrowserError.make({
-		operation: "capture",
-		reason: Reasons.UnregisteredSession.make({}),
-		outcome: "undispatched"
-	}));
-	return checked(CaptureOptions, options, "capture").pipe(Effect.flatMap(({ admission, ...capture }) => checkedOperationOptions(admission === void 0 ? {} : { admission }, "capture").pipe(Effect.flatMap((operationOptions) => startCapture(parent, {
-		...capture,
-		...operationOptions.admission === void 0 ? {} : { admission: operationOptions.admission }
-	})))));
-});
-/**
-* A lazy, scoped frame stream. Each subscription acquires one interval and finalizes it when
-* consumption ends, fails or is interrupted; the browser remains owned by its caller.
-* Concurrent subscriptions on the same page are refused by the existing capture reservation.
-* Unconfirmed native cleanup retains the page reservation. Use start when the host needs
-* explicit stop acknowledgement, interval snapshots and the final capture summary.
-*/
-const stream = (page, options = {}) => Stream.unwrap(start(page, options).pipe(Effect.map((interval) => interval.frames)));
-/**
-* Frames as motion JPEG for an `<img>`: one `multipart/x-mixed-replace` response, as WHATWG HTML
-* defines it for images. Each frame is followed at once by the next part's delimiter and headers,
-* because a browser shows a part only when it has read the headers of the one after it; without
-* that, a still page's last picture would never be shown. Parts carry no metadata, so nothing
-* but the pictures reaches a viewer. The boundary is drawn from `Crypto` for each response, so a
-* page cannot shape its pixels into it. Call it once per viewer.
-*/
-const multipart = (frames) => Effect.map(Effect.flatMap(Crypto.Crypto, (crypto) => crypto.randomUUIDv4), (uuid) => {
-	const boundary = `frame-${uuid.replaceAll("-", "")}`;
-	const encoder = new TextEncoder();
-	const opening = encoder.encode(`--${boundary}\r\nContent-Type: image/jpeg\r\n\r\n`);
-	const next = encoder.encode(`\r\n--${boundary}\r\nContent-Type: image/jpeg\r\n\r\n`);
-	return {
-		contentType: `multipart/x-mixed-replace; boundary=${boundary}`,
-		body: Stream.make(opening).pipe(Stream.concat(frames.pipe(Stream.flatMap((frame) => Stream.make(frame.bytes, next)))), Stream.concat(Stream.make(encoder.encode(`--${boundary}--\r\n`))))
-	};
-});
-//#endregion
-export { CaptureOptions, CaptureQualification, CaptureSize, CaptureSnapshot, CaptureSummary, CapturedFrame, multipart, start, stream };
-
-//# sourceMappingURL=Capture.mjs.map