effect-browser 0.0.0-reserved.0 → 0.2.0-beta.0

package/dist/BrowserRuntime.d.mts

@@ -0,0 +1,139 @@
+import { BrowserError, InitializationError } from "./Errors.mjs";
+import { S as Observation, a as BrowserPolicy, c as ClickRequest, m as InlineFile, n as AutomationOptions, q as Viewport, t as ActionResult } from "./BrowserData-DJAnUHoZ.mjs";
+import { BrowserSession, OpenOptions } from "./Browser.mjs";
+import { Effect, Option, Redacted, Schema, Scope } from "effect";
+//#region src/internal/browser/ConnectionCleanup.d.ts
+/** Evidence about this connection, independent of the lifetime of its browser process. */
+type ConnectionState = "closed" | "failed" | "not-connected" | "pending";
+/** Captured teardown operations supplied to the lifetime which owns this connection. */
+interface ConnectionCleanup {
+  readonly fence: Effect.Effect<void>;
+  readonly capture: Effect.Effect<void, BrowserError>;
+  readonly initialization: Effect.Effect<void, BrowserError | InitializationError>;
+  readonly disconnect: Effect.Effect<ConnectionState, BrowserError>;
+}
+export declare const noConnection: ConnectionCleanup;
+type CleanupStep<A> = {
+  readonly _tag: "Success";
+  readonly value: A;
+} | {
+  readonly _tag: "Failure";
+  readonly reason: "timeout" | "interrupted" | "failed";
+};
+/** Every step settles independently, so one failure never suppresses subsequent teardown. */
+export declare const cleanupStep: <A, E, R>(action: Effect.Effect<A, E, R>, timeoutMillis: number) => Effect.Effect<CleanupStep<A>, never, R>;
+/** Bounded host notification; reporting cannot change the cleanup evidence it describes. */
+export declare const reported: <A, E>(effect: Effect.Effect<A, E>) => Effect.Effect<void>;
+//#endregion
+//#region src/BrowserRuntime.d.ts
+/** Opaque engine configuration. Only this constructor's issued values can acquire a runtime. */
+export interface BrowserBinding {
+  readonly _tag: "BrowserBinding";
+}
+export interface PlaywrightOptions {
+  /** A trusted integration validates its own endpoint authority before routing the connection. */
+  readonly resolveEndpoint?: (connection: {
+    readonly url: Redacted.Redacted<string>;
+  }) => Effect.Effect<string, BrowserError>;
+  /** Trusted instrumentation of the existing native connection, before the owner starts using it. */
+  readonly onConnected?: (connection: {
+    readonly native: unknown;
+    readonly endpoint: string;
+  }) => void;
+}
+/** A maintained Playwright connection, loaded lazily. No driver or protocol capability is returned. */
+export declare const playwright: (options?: PlaywrightOptions) => BrowserBinding;
+/**
+ * An integration owns endpoint authority and the meaning of release. Its source must register
+ * release in the supplied Scope before returning; the runtime owns only the connection below it.
+ */
+export interface Lifetime {
+  readonly reference: unknown;
+  readonly connection: (remainingMillis: number) => Effect.Effect<Redacted.Redacted<string>, BrowserError>;
+  readonly release: Effect.Effect<unknown>;
+  readonly cleanupResult: Effect.Effect<Option.Option<unknown>>;
+  readonly closeChecked: Effect.Effect<void, BrowserError>;
+  /**
+   * Memory-only evidence that canonical owned cleanup terminated native browser control.
+   * Omission is unknown. Borrowed disconnection alone never establishes this fact.
+   */
+  readonly controlRetired?: Effect.Effect<boolean>;
+  readonly verifyReconnect?: Effect.Effect<void, BrowserError>;
+}
+export type Source<L extends Lifetime, E, R = never> = (cleanup: ConnectionCleanup, lifetimeDeadline: number) => Effect.Effect<L, E, R | Scope.Scope>;
+export interface RuntimeOptions {
+  readonly implementation: string;
+  readonly binding?: BrowserBinding;
+  readonly automation?: AutomationOptions;
+  readonly viewport?: Viewport;
+  readonly preserveViewport?: boolean;
+  readonly keepAlive?: boolean;
+}
+export interface AcquireOptions<E = never, R = never> extends OpenOptions<E, R> {
+  /** Attach to an existing page without creating a tab or changing its viewport. */
+  readonly existingTarget?: {
+    readonly targetId?: string;
+  };
+}
+/**
+ * Resolved host input for an integration constructing its own runtime. Stored paths must already
+ * have been authorized by that integration; a session cannot recover these operations afterwards.
+ */
+export type ResolvedFileSelection = {
+  readonly _tag: "Inline";
+  readonly files: ReadonlyArray<InlineFile>;
+} | {
+  readonly _tag: "Stored";
+  readonly paths: ReadonlyArray<string>;
+};
+export interface FileRequest {
+  readonly selector: string;
+  readonly selection: ResolvedFileSelection;
+}
+declare const DownloadEvent_base: Schema.Class<DownloadEvent, Schema.Struct<{
+  readonly downloadId: Schema.NonEmptyString;
+  readonly filename: Schema.NonEmptyString;
+  readonly state: Schema.Literals<readonly ["completed", "failed"]>;
+}>, {}>;
+export declare class DownloadEvent extends DownloadEvent_base {}
+/**
+ * Modeled host operations for the integration creating this connection. Native authority stays
+ * inside the owner; the integration adds only the capabilities its public session supports.
+ */
+export interface Integration<Reference> {
+  readonly clickForDownload: (request: ClickRequest) => Effect.Effect<DownloadEvent, BrowserError>;
+  readonly selectFiles: (request: FileRequest) => Effect.Effect<ActionResult, BrowserError>;
+  readonly clickForFileSelection: (request: FileRequest) => Effect.Effect<ActionResult, BrowserError>;
+  readonly liveView: <A>(issue: Effect.Effect<A, BrowserError>) => Effect.Effect<A, BrowserError>;
+  readonly beginHandoff: <A>(issue: Effect.Effect<A, BrowserError>) => Effect.Effect<{
+    readonly token: Redacted.Redacted<string>;
+    readonly view: A;
+  }, BrowserError>;
+  readonly resume: (token: Redacted.Redacted<string>, operatorReleasedControl: boolean) => Effect.Effect<Observation, BrowserError>;
+  readonly detach: Effect.Effect<{
+    readonly reference: Reference;
+    readonly targetId: string;
+  }, BrowserError>;
+  readonly reconnect: (operatorReleasedControl: boolean) => Effect.Effect<Observation, BrowserError | InitializationError>;
+}
+export interface Connection<Reference, E = never> {
+  /** Preserve this object's identity when adding an integration's public capabilities. */
+  readonly session: BrowserSession<E>;
+  readonly operations: Integration<Reference>;
+}
+export interface Acquisition<L extends Lifetime, E = never> {
+  readonly reference: L["reference"];
+  readonly lifetime: L;
+  readonly failure: Effect.Effect<never, E | InitializationError>;
+  readonly close: L["release"];
+  readonly connect: Effect.Effect<Connection<L["reference"], E>, BrowserError | InitializationError | E>;
+}
+export interface Runtime {
+  readonly acquire: <L extends Lifetime, AE, AR, E = never, R = never>(policy: BrowserPolicy, source: Source<L, AE, AR>, request?: AcquireOptions<E, R>) => Effect.Effect<Acquisition<L, E>, AE | BrowserError, Scope.Scope | AR | Exclude<R, Scope.Scope>>;
+}
+/** Validate immutable connection configuration without loading a peer or acquiring a lifetime. */
+export declare const make: (options: RuntimeOptions) => Effect.Effect<Runtime, BrowserError, never>;
+//#endregion
+export type { CleanupStep, ConnectionCleanup, ConnectionState };
+export {};
+//# sourceMappingURL=BrowserRuntime.d.mts.map

package/dist/BrowserRuntime.mjs

@@ -0,0 +1,2 @@
+import { a as noConnection, i as cleanupStep, n as make, o as reported, r as playwright, t as DownloadEvent } from "./BrowserRuntime-fZz1b0VI.mjs";
+export { DownloadEvent, cleanupStep, make, noConnection, playwright, reported };

package/dist/Capture.d.mts

@@ -0,0 +1,40 @@
+import { BrowserError } from "./Errors.mjs";
+import { BrowserSession } from "./Browser.mjs";
+import { CaptureOptions, CaptureSize, CaptureSnapshot, CaptureSummary, CapturedFrame } from "./CaptureData.mjs";
+import { Effect, Scope, Stream } from "effect";
+//#region src/Capture.d.ts
+/** Live stream/Effect capabilities intentionally have no data schema or serialization contract. */
+export interface CaptureInterval {
+  /** Single subscription. Ending or interrupting it stops this interval, not its browser. */
+  readonly frames: Stream.Stream<CapturedFrame, BrowserError>;
+  /**
+   * A bounded copy of recorded metadata, available during capture and after cleanup. No native
+   * work, budget charge or subscription. Drain frames, then read `completed` for final accounting.
+   */
+  readonly snapshot: Effect.Effect<CaptureSnapshot>;
+  readonly stop: Effect.Effect<CaptureSummary>;
+  readonly completed: Effect.Effect<CaptureSummary>;
+}
+/**
+ * Capture one remote page independently of the session's selected page.
+ *
+ * Requires the exact live session returned by the host; copying a session 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.
+ */
+export declare const start: <E>(session: BrowserSession<E>, options?: CaptureOptions) => Effect.Effect<CaptureInterval, BrowserError, Scope.Scope>;
+/**
+ * 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.
+ */
+export declare const stream: <E>(session: BrowserSession<E>, options?: CaptureOptions) => Stream.Stream<CapturedFrame, BrowserError>;
+//#endregion
+export { CaptureOptions, CaptureSize, CaptureSnapshot, CaptureSummary, CapturedFrame };
+export {};
+//# sourceMappingURL=Capture.d.mts.map

package/dist/Capture.mjs

@@ -0,0 +1,476 @@
+import { PageInfo } from "./BrowserData.mjs";
+import { BrowserError, Reasons } from "./Errors.mjs";
+import { n as captureParent, r as jpegGeometry } from "./Association-zlgInoaj.mjs";
+import { a as CapturedFrame, i as CaptureSummary, n as CaptureSize, o as CaptureDefaults, r as CaptureSnapshot, s as CaptureLimits, t as CaptureOptions } from "./CaptureData-AmqVP_Ba.mjs";
+import { Cause, Clock, Deferred, Effect, Exit, 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 > 64 || !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 parseMetadata = Schema.decodeUnknownSync(Metadata);
+/** Private seam for deterministic callback/lifetime tests. The public start accepts a real live session. */
+const startCapture = 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"
+	})));
+	const clock = yield* Clock.Clock;
+	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 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 initialUrl = null;
+	let documentBoundariesTruncated = false;
+	const documentBoundaries = [];
+	/** The page navigated and its screencast kept running: later frames belong to a new document. */
+	const nextDocument = (url) => {
+		if (ended) return;
+		document++;
+		if (documentBoundaries.length >= MaxDocumentBoundaries) documentBoundariesTruncated = true;
+		else documentBoundaries.push({
+			document,
+			observedMonotonicNanos: clock.monotonicTimeNanosUnsafe(),
+			afterSequence: received === 0 ? null : received - 1,
+			url: documentUrl(url)
+		});
+	};
+	let geometry;
+	let nativeStop = "unconfirmed";
+	let lease;
+	const finish = (why, failure) => {
+		if (ended) return;
+		ended = true;
+		reason = why;
+		error = failure;
+		Queue.offerUnsafe(wake, void 0);
+		Queue.offerUnsafe(finished, void 0);
+	};
+	const snapshot = () => {
+		if (target === void 0) throw new Error("Capture target was not admitted");
+		return CaptureSummary.make({
+			target,
+			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
+			}) }
+		});
+	};
+	const stopNative = (yield* Effect.cached(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+		finish("stopped");
+		if (startPromise !== void 0 && !startSettled) yield* restore(Effect.tryPromise({
+			try: () => startPromise,
+			catch: () => BrowserError.make({
+				operation: "capture-start",
+				reason: Reasons.Provider.make({}),
+				outcome: "unknown"
+			})
+		}).pipe(Effect.timeout(2e3), Effect.exit));
+		if (source !== void 0) {
+			const stopped = yield* restore(Effect.tryPromise({
+				try: () => source.stop(),
+				catch: () => BrowserError.make({
+					operation: "capture-stop",
+					reason: Reasons.Provider.make({}),
+					outcome: "unknown"
+				})
+			}).pipe(Effect.timeout(3e3))).pipe(Effect.exit);
+			if (Exit.isSuccess(stopped) && startSettled) nativeStop = "confirmed";
+		} else nativeStop = "confirmed";
+		if (nativeStop === "confirmed" && leaseKey !== void 0 && lease !== void 0 && parent.captureLeases.get(leaseKey) === lease) {
+			parent.captureLeases.delete(leaseKey);
+			parent.captureReservedBytes = Math.max(0, parent.captureReservedBytes - lease.reservedBytes);
+		}
+		cleanupFinished = true;
+		return snapshot();
+	})))).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 meta = parseMetadata(frame);
+			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;
+			buffer.offer({
+				bytes: new Uint8Array(frame.data),
+				mediaType: "image/jpeg",
+				target,
+				sequence,
+				document,
+				sourceTimeMillis: meta.timestamp,
+				sourceClock: "presentation-unix-millis",
+				receivedMonotonicNanos: clock.monotonicTimeNanosUnsafe(),
+				...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.owner.guard("capture-start", (ticket) => Effect.gen(function* () {
+		const resolved = yield* parent.resolve(ticket, options.target);
+		target = Object.freeze(resolved.target);
+		source = resolved.source;
+		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"
+		});
+		lease = {
+			reservedBytes: maxBytes,
+			stop: stopNative.pipe(Effect.asVoid),
+			invalidate: (why) => finish(why, 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();
+		}))));
+		startSettled = false;
+		yield* Effect.tryPromise({
+			try: () => {
+				startPromise = source.start({
+					receive,
+					quality,
+					invalidate: (why) => lease?.invalidate(why),
+					opened: (url) => {
+						initialUrl = documentUrl(url);
+					},
+					...size === void 0 ? {} : { size },
+					...options.lifetime === "page" ? { document: nextDocument } : {}
+				});
+				startPromise.then(() => {
+					startSettled = true;
+					if (cleanupFinished && nativeStop === "unconfirmed" && leaseKey !== void 0 && parent.captureLeases.get(leaseKey) === lease) source.stop().catch(() => {});
+				}, () => {
+					startSettled = true;
+				});
+				return startPromise;
+			},
+			catch: () => BrowserError.make({
+				operation: "capture-start",
+				reason: Reasons.Provider.make({}),
+				outcome: "unknown"
+			})
+		});
+		ticket.check();
+	}), { charge: false }).pipe(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)), Effect.sleep(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 {
+		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))));
+		})),
+		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))
+	};
+});
+//#endregion
+//#region src/Capture.ts
+/**
+* Capture one remote page independently of the session's selected page.
+*
+* Requires the exact live session returned by the host; copying a session 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 = (session, options = {}) => Effect.suspend(() => {
+	const parent = captureParent(session);
+	if (parent === void 0) return Effect.fail(BrowserError.make({
+		operation: "capture",
+		reason: Reasons.UnregisteredSession.make({}),
+		outcome: "undispatched"
+	}));
+	if (options.target === void 0) return startCapture(parent, options);
+	return Schema.decodeEffect(PageInfo)(options.target, { onExcessProperty: "error" }).pipe(Effect.mapError(() => BrowserError.make({
+		operation: "capture",
+		reason: Reasons.Configuration.make({}),
+		outcome: "undispatched"
+	})), Effect.flatMap((target) => startCapture(parent, {
+		...options,
+		target
+	})));
+});
+/**
+* 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 = (session, options = {}) => Stream.unwrap(start(session, options).pipe(Effect.map((interval) => interval.frames)));
+//#endregion
+export { CaptureOptions, CaptureSize, CaptureSnapshot, CaptureSummary, CapturedFrame, start, stream };
+
+//# sourceMappingURL=Capture.mjs.map