reverseport 0.0.0-stage → 1.2.0

package/dist/mcp/browserScenario-z7jveI9P.js

@@ -0,0 +1,2319 @@
+import { t as __esmMin } from "./rolldown-runtime-BjeaiXFo.js";
+import { d as init_analysisErrorCore, f as err, g as init_analysisErrorBase, h as AnalysisError, l as AnalysisTimeoutError, m as ok, p as init_result, r as AnalysisCancelledError } from "./analysisErrorCore-BqyeMw3_.js";
+import { n as projectAnalysisError, t as init_analysisErrorProjection } from "./analysisErrorProjection-B7pHef2y.js";
+import { n as init_providerAdapterError, t as ProviderAdapterError } from "./providerAdapterError-CdPaQ6-Z.js";
+import { n as init_browserObservationError, t as BrowserObservationError } from "./browserObservationError-BKBEX85K.js";
+import { f as sanitizeBrowserUrl, s as init_browserObservation, u as isLiteralLoopbackHostname } from "./webContentArtifact-DUBgMzVO.js";
+import { a as browserScenarioStepSchema, c as init_browserScenarioCaptureValues, d as init_browserNetworkEvidence, i as browserScenarioEventSchema, l as PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION, n as init_browserScenarioCapture, o as browserStepArtifactsSchema, s as classifyBrowserScenarioCompleteness, t as browserScenarioCaptureSchema } from "./browserScenarioCapture-BvnKTmtZ.js";
+import { a as init_providerIdentities, r as PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities--ptAh481.js";
+import { join, resolve } from "node:path";
+import { z } from "zod";
+import { tmpdir } from "node:os";
+import { chmod, mkdtemp, rm } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+
+//#region dist/browser/BrowserScenarioPartialObservation.js
+var OPERATION$4, browserScenarioLimitations, browserScenarioCaptureData, browserScenarioCleanupObservation, browserScenarioOperationFailure;
+function init_BrowserScenarioPartialObservation() {
+	return (init_BrowserScenarioPartialObservation = __esmMin((() => {
+		init_browserNetworkEvidence();
+		init_analysisErrorBase();
+		init_analysisErrorCore();
+		init_analysisErrorProjection();
+		init_browserObservationError();
+		init_providerAdapterError();
+		init_providerIdentities();
+		OPERATION$4 = "capture_browser_scenario";
+		browserScenarioLimitations = (session, scenario, events) => {
+			const capturedResponseBody = scenario.capture.network.response_body && events.some((event) => event.kind === "network-content" && event.phase === "response" && event.body.state === "captured" && (event.body.representation === "playwright-response-body-bytes" || event.body.representation === "browser-decoded-response-bytes"));
+			return [
+				"Event sequence records provider receipt order; simultaneous browser causality is not inferred.",
+				"Network content is retained only when selected; Playwright response-body bytes are API results and are not guaranteed to match wire bytes.",
+				"Request bytes are limited to what Playwright exposes; not_exposed does not establish body absence or multipart file coverage.",
+				"Network content reads settle within 5 seconds each and the observer does not request bodies from unfinished responses.",
+				...capturedResponseBody ? [PLAYWRIGHT_RESPONSE_BODY_PROVENANCE_LIMITATION] : [],
+				"Playwright scenario events do not expose request initiator stacks; receipt order does not prove causality.",
+				"Storage values are hashed only after declared-secret redaction.",
+				...scenario.storage.local_storage.length === 0 && scenario.storage.session_storage.length === 0 ? [] : ["Non-cookie storage seeds use CDP pre-script instrumentation; only pauses in the scenario's private seed script are resumed by this observer."],
+				...session.eventLimitations?.() ?? [],
+				...session.mode === "connect" ? ["CDP attachment cannot recover pre-attach events or guarantee launch-time context options."] : []
+			];
+		};
+		browserScenarioCaptureData = (input) => {
+			const events = input.session.events();
+			return {
+				browser: {
+					mode: input.session.mode,
+					process_ownership: input.session.processOwnership,
+					cleanup: input.cleanup,
+					product: input.session.product,
+					version: input.session.version
+				},
+				scenario: {
+					start_origin: new URL(input.scenario.start_url.url).origin,
+					action_count: input.scenario.actions.length,
+					secret_references: input.scenario.secrets.map(({ secret_id: id }) => id).sort(),
+					network_content: input.scenario.capture.network
+				},
+				duration_ms: Date.now() - input.startedAt,
+				steps: [...input.steps],
+				events,
+				limitations: [...browserScenarioLimitations(input.session, input.scenario, events.items), ...input.limitations ?? []]
+			};
+		};
+		browserScenarioCleanupObservation = (cause) => cause instanceof AnalysisError && cause.cleanup !== undefined ? cause.cleanup : {
+			reason: cause instanceof Error ? cause.message : String(cause),
+			resources: cause instanceof AnalysisError && cause.cleanupResources.length > 0 ? cause.cleanupResources : ["browser_transport"]
+		};
+		browserScenarioOperationFailure = (cause, partialObservation, cleanupFailure) => {
+			const primary = cause instanceof AnalysisError ? cause : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION$4, { cause });
+			const primaryProjection = projectAnalysisError(primary);
+			const cleanupCause = cleanupFailure === undefined ? undefined : cleanupFailure.cause instanceof AnalysisError ? cleanupFailure.cause : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, "close_browser_scenario", { cause: cleanupFailure.cause });
+			const cleanupObservation = cleanupFailure === undefined ? undefined : browserScenarioCleanupObservation(cleanupFailure.cause);
+			const retainedOptions = {
+				cause: primary,
+				partialObservation,
+				...primary.capturedOutput === undefined ? {} : { capturedOutput: primary.capturedOutput },
+				...primary.cleanup === undefined ? {} : { cleanup: primary.cleanup }
+			};
+			if (cleanupCause === undefined) {
+				if (primary instanceof AnalysisCancelledError) return new AnalysisCancelledError(primary.operation, retainedOptions);
+				if (primary instanceof AnalysisTimeoutError) return new AnalysisTimeoutError(primary.operation, primary.timeoutMs, retainedOptions);
+				if (primary instanceof BrowserObservationError) return new BrowserObservationError(primary.operation, primary.reason, {
+					...retainedOptions,
+					...primary.userMessage === undefined ? {} : { detail: primary.userMessage }
+				});
+			}
+			const cleanup = cleanupObservation ?? primary.cleanup;
+			return new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION$4, {
+				...retainedOptions,
+				cause: cleanupCause === undefined ? primary : new AggregateError([primary, cleanupCause], "Browser scenario operation and cleanup both failed", { cause: primary }),
+				userMessage: primaryProjection.message,
+				...cleanup === undefined ? {} : { cleanup },
+				diagnostics: {
+					primary_error: primaryProjection,
+					...cleanupCause === undefined ? {} : { cleanup_error: projectAnalysisError(cleanupCause) }
+				}
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightBrowserScenarioProvider.js
+var OPERATION$3, SNAPSHOT_KINDS, requestedForStep, unavailableArtifacts, stepCompleteness, createStep, initialStep, executeStep, globalCompleteness, runScenario, PlaywrightBrowserScenarioProvider;
+function init_PlaywrightBrowserScenarioProvider() {
+	return (init_PlaywrightBrowserScenarioProvider = __esmMin((() => {
+		init_browserScenarioCapture();
+		init_browserScenarioCaptureValues();
+		init_analysisErrorBase();
+		init_browserObservationError();
+		init_providerAdapterError();
+		init_result();
+		init_BrowserScenarioPartialObservation();
+		init_providerIdentities();
+		OPERATION$3 = "capture_browser_scenario";
+		SNAPSHOT_KINDS = [
+			"screenshot",
+			"dom",
+			"accessibility",
+			"url",
+			"history",
+			"storage"
+		];
+		requestedForStep = (scenario, stepIndex) => new Set([...scenario.capture.after_each_step, ...stepIndex === scenario.actions.length ? scenario.capture.at_end : []]);
+		unavailableArtifacts = (requested, reason) => {
+			const state = (kind) => requested.has(kind) ? {
+				state: "missing",
+				reason
+			} : { state: "not_requested" };
+			return browserStepArtifactsSchema.parse({
+				screenshot: state("screenshot"),
+				dom: state("dom"),
+				accessibility: state("accessibility"),
+				url: state("url"),
+				history: state("history"),
+				storage: state("storage")
+			});
+		};
+		stepCompleteness = (artifacts, status) => {
+			const missing = SNAPSHOT_KINDS.filter((section) => artifacts[section].state === "missing");
+			const truncated = SNAPSHOT_KINDS.filter((section) => artifacts[section].state === "truncated");
+			if (status !== "completed") missing.push("action");
+			return classifyBrowserScenarioCompleteness(missing, truncated);
+		};
+		createStep = (input) => browserScenarioStepSchema.parse({
+			step_index: input.stepIndex,
+			step_id: input.stepId,
+			action: input.action,
+			status: input.status,
+			elapsed_ms: input.elapsedMs,
+			before_url: input.beforeUrl,
+			after_url: input.afterUrl,
+			error: input.error,
+			event_sequence_start: input.eventStart,
+			event_sequence_end: input.eventEnd,
+			artifacts: input.artifacts,
+			completeness: stepCompleteness(input.artifacts, input.status)
+		});
+		initialStep = async (input) => {
+			const { session, scenario, elapsedMs, signal } = input;
+			const artifacts = await session.capture(requestedForStep(scenario, 0), signal);
+			return createStep({
+				stepIndex: 0,
+				stepId: "scenario_start",
+				action: "goto_start",
+				status: "completed",
+				elapsedMs,
+				beforeUrl: session.sanitizeUrl(session.initialUrl),
+				afterUrl: session.sanitizeUrl(session.currentUrl()),
+				error: null,
+				eventStart: 1,
+				eventEnd: session.lastEventSequence(),
+				artifacts
+			});
+		};
+		executeStep = async (input) => {
+			const { session, scenario, action, stepIndex, priorFailure, signal } = input;
+			const beforeUrl = session.sanitizeUrl(session.currentUrl());
+			const eventStart = session.nextEventSequence();
+			const requested = requestedForStep(scenario, stepIndex);
+			if (priorFailure) return createStep({
+				stepIndex,
+				stepId: action.step_id,
+				action: action.action,
+				status: "cancelled",
+				elapsedMs: 0,
+				beforeUrl,
+				afterUrl: beforeUrl,
+				error: "not executed after an earlier action failure",
+				eventStart,
+				eventEnd: session.lastEventSequence(),
+				artifacts: unavailableArtifacts(requested, "action was not executed after an earlier failure")
+			});
+			const actionStartedAt = Date.now();
+			session.setStep(stepIndex);
+			const requestCancelled = () => signal?.aborted === true;
+			let outcome = {
+				status: "completed",
+				error: null
+			};
+			if (requestCancelled()) {
+				outcome = {
+					status: "cancelled",
+					error: "scenario request cancelled"
+				};
+			} else {
+				try {
+					await session.perform(action, signal);
+				} catch (cause) {
+					outcome = {
+						status: requestCancelled() ? "cancelled" : "failed",
+						error: session.redactError(cause)
+					};
+				}
+			}
+			const artifacts = outcome.status === "cancelled" ? unavailableArtifacts(requested, "scenario request cancelled") : await session.capture(requested, signal);
+			return createStep({
+				stepIndex,
+				stepId: action.step_id,
+				action: action.action,
+				...outcome,
+				elapsedMs: Date.now() - actionStartedAt,
+				beforeUrl,
+				afterUrl: session.sanitizeUrl(session.currentUrl()),
+				eventStart,
+				eventEnd: session.lastEventSequence(),
+				artifacts
+			});
+		};
+		globalCompleteness = (scenario, session, steps) => {
+			const missing = steps.flatMap(({ completeness }) => completeness.missing_sections);
+			const truncated = steps.flatMap(({ completeness }) => completeness.truncated_sections);
+			if (session.mode === "connect") missing.push("events");
+			if ((session.eventLimitations?.().length ?? 0) > 0) missing.push("events");
+			return classifyBrowserScenarioCompleteness(missing, truncated);
+		};
+		runScenario = async (openSession, scenario, options, retainCleanup) => {
+			if (options.signal?.aborted === true) throw new BrowserObservationError(OPERATION$3, "cancelled");
+			const startedAt = Date.now();
+			const session = await openSession(scenario, {
+				...options.signal === undefined ? {} : { signal: options.signal },
+				retainCleanup
+			});
+			const steps = [];
+			let operationOutcome = { ok: true };
+			try {
+				steps.push(await initialStep({
+					session,
+					scenario,
+					elapsedMs: Date.now() - startedAt,
+					signal: options.signal
+				}));
+				let failed = false;
+				for (const [offset, action] of scenario.actions.entries()) {
+					const step = await executeStep({
+						session,
+						scenario,
+						action,
+						stepIndex: offset + 1,
+						priorFailure: failed,
+						signal: options.signal
+					});
+					steps.push(step);
+					failed ||= step.status !== "completed";
+				}
+			} catch (cause) {
+				operationOutcome = {
+					ok: false,
+					cause
+				};
+			}
+			let cleanupOutcome;
+			try {
+				cleanupOutcome = {
+					ok: true,
+					cleanup: await session.close()
+				};
+			} catch (cause) {
+				cleanupOutcome = {
+					ok: false,
+					cause
+				};
+				retainCleanup(() => session.close());
+			}
+			if (!cleanupOutcome.ok) {
+				const cleanup = browserScenarioCleanupObservation(cleanupOutcome.cause);
+				const partialObservation = {
+					kind: "browser-scenario-observation",
+					capture: browserScenarioCaptureData({
+						session,
+						scenario,
+						startedAt,
+						steps,
+						cleanup: "incomplete",
+						limitations: ["Scenario observations are partial because browser cleanup could not be confirmed."]
+					})
+				};
+				if (!operationOutcome.ok) throw browserScenarioOperationFailure(operationOutcome.cause, partialObservation, { cause: cleanupOutcome.cause });
+				throw new BrowserObservationError(OPERATION$3, "cleanup_failed", {
+					cause: cleanupOutcome.cause,
+					cleanup,
+					partialObservation,
+					detail: `Browser scenario cleanup could not be confirmed: ${cleanup.reason}. Collected steps and events are retained in partial_observation. Review the reported resources before retrying.`
+				});
+			}
+			if (!operationOutcome.ok) throw browserScenarioOperationFailure(operationOutcome.cause, {
+				kind: "browser-scenario-observation",
+				capture: browserScenarioCaptureData({
+					session,
+					scenario,
+					startedAt,
+					steps,
+					cleanup: cleanupOutcome.cleanup,
+					limitations: ["Scenario capture ended after an operation failed; uncollected steps are not represented."]
+				})
+			});
+			const completeness = globalCompleteness(scenario, session, steps);
+			return browserScenarioCaptureSchema.parse({
+				...browserScenarioCaptureData({
+					session,
+					scenario,
+					startedAt,
+					steps,
+					cleanup: cleanupOutcome.cleanup
+				}),
+				completeness
+			});
+		};
+		PlaywrightBrowserScenarioProvider = class {
+			openSession;
+			#tail = Promise.resolve();
+			#closing = false;
+			#closePromise;
+			#pendingCleanup = new Set();
+			constructor(openSession) {
+				this.openSession = openSession;
+			}
+			identity() {
+				return PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY;
+			}
+			captureScenario(scenario, options = {}) {
+				if (this.#closing) return Promise.resolve(err(this.#closedError()));
+				const operation = this.#tail.then(() => this.#closing ? err(this.#closedError()) : this.#captureScenario(scenario, options));
+				this.#tail = operation.then(() => undefined, () => undefined);
+				return operation;
+			}
+			async #captureScenario(scenario, options) {
+				const pending = await this.#retryCleanup();
+				if (pending !== undefined) return err(pending);
+				try {
+					return ok(await runScenario(this.openSession, scenario, options, (close) => {
+						this.#pendingCleanup.add(close);
+					}));
+				} catch (cause) {
+					if (cause instanceof AnalysisError) return err(cause);
+					return err(new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION$3, { cause }));
+				}
+			}
+			async close() {
+				this.#closing = true;
+				this.#closePromise ??= this.#tail.then(async () => {
+					const failure = await this.#retryCleanup();
+					if (failure !== undefined) throw failure;
+				}).catch((cause) => {
+					this.#closePromise = undefined;
+					throw cause;
+				});
+				return this.#closePromise;
+			}
+			#closedError() {
+				return new BrowserObservationError(OPERATION$3, "cleanup_failed", {
+					detail: "Browser scenario provider is closing.",
+					cleanup: {
+						reason: "Provider is closing",
+						resources: []
+					}
+				});
+			}
+			async #retryCleanup() {
+				for (const pending of this.#pendingCleanup) {
+					try {
+						await pending();
+						this.#pendingCleanup.delete(pending);
+					} catch (cause) {
+						return cause instanceof AnalysisError ? cause : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION$3, { cause });
+					}
+				}
+				return undefined;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/BrowserScenarioSecrets.js
+var REDACTION_PREFIX, encodedSecretValues, secretSpellings, declaredLiterals, redactionMarker, replaceSecretLiterals, secretNeedles, BrowserScenarioSecrets;
+function init_BrowserScenarioSecrets() {
+	return (init_BrowserScenarioSecrets = __esmMin((() => {
+		init_browserObservation();
+		REDACTION_PREFIX = "[REDACTED:";
+		encodedSecretValues = (secret) => new Set([
+			secret,
+			encodeURIComponent(secret),
+			new URLSearchParams([["value", secret]]).toString().slice("value=".length)
+		]);
+		secretSpellings = (secret, spellings) => {
+			if (secret === "") return [];
+			if (spellings === "raw") return [secret];
+			const values = [...encodedSecretValues(secret)];
+			if (spellings === "bytes") values.push(JSON.stringify(secret).slice(1, -1));
+			return [...new Set(values)].filter((value) => value !== "");
+		};
+		declaredLiterals = (values, spellings) => [...new Set([...values.values()].flatMap((secret) => secretSpellings(secret, spellings)))];
+		redactionMarker = (id, literals) => [
+			`${REDACTION_PREFIX}${id}]`,
+			"[REDACTED]",
+			"…",
+			""
+		].find((candidate) => literals.every((literal) => !candidate.includes(literal))) ?? "";
+		replaceSecretLiterals = (value, values, spellings, literals) => {
+			const replacements = [...values].flatMap(([id, secret]) => secretSpellings(secret, spellings).map((text) => ({
+				id,
+				text
+			}))).sort((left, right) => right.text.length - left.text.length || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+			let output = value;
+			for (const replacement of replacements) output = output.replaceAll(replacement.text, redactionMarker(replacement.id, literals));
+			return output;
+		};
+		secretNeedles = (values, literals) => [...values].flatMap(([id, secret]) => secretSpellings(secret, "bytes").map((text) => ({
+			id,
+			needle: Buffer.from(text),
+			marker: Buffer.from(redactionMarker(id, literals))
+		})));
+		BrowserScenarioSecrets = class BrowserScenarioSecrets {
+			values;
+			constructor(values) {
+				this.values = values;
+			}
+			static resolve(scenario, environment) {
+				const values = new Map();
+				for (const declaration of scenario.secrets) {
+					const value = environment[declaration.environment_variable];
+					if (!Object.hasOwn(environment, declaration.environment_variable) || typeof value !== "string") return undefined;
+					values.set(declaration.secret_id, value);
+				}
+				return new BrowserScenarioSecrets(values);
+			}
+			value(source) {
+				if (source.source === "literal") return source.value;
+				const value = this.values.get(source.secret_id);
+				if (value === undefined) throw new Error("Validated browser secret was not resolved");
+				return value;
+			}
+			url(destination) {
+				const url = new URL(destination.url);
+				for (const { name, value } of destination.query) url.searchParams.append(name, this.value(value));
+				return url.href;
+			}
+			redact(value) {
+				const literals = declaredLiterals(this.values, "raw");
+				const output = replaceSecretLiterals(value, this.values, "raw", literals);
+				return literals.some((literal) => output.includes(literal)) ? "" : output;
+			}
+			/** Replace declared UTF-8, URI/form, and JSON-escaped secrets without decoding binary data. */
+			redactBytes(value) {
+				const literals = declaredLiterals(this.values, "bytes");
+				const candidates = secretNeedles(this.values, literals).map((candidate) => ({
+					...candidate,
+					index: value.indexOf(candidate.needle)
+				})).sort((left, right) => right.needle.length - left.needle.length || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+				const parts = [];
+				let offset = 0;
+				while (true) {
+					let next;
+					for (const candidate of candidates) {
+						if (candidate.index >= 0 && candidate.index < offset) candidate.index = value.indexOf(candidate.needle, offset);
+						if (candidate.index >= 0 && (next === undefined || candidate.index < next.index)) next = candidate;
+					}
+					if (next === undefined) break;
+					parts.push(value.subarray(offset, next.index), next.marker);
+					offset = next.index + next.needle.length;
+				}
+				if (parts.length === 0) return value;
+				parts.push(value.subarray(offset));
+				const redacted = Buffer.concat(parts);
+				return literals.some((literal) => redacted.includes(Buffer.from(literal))) ? Buffer.alloc(0) : redacted;
+			}
+			/** Remove only declared secret values from one URL and report that action. */
+			sanitizeUrl(value) {
+				const literals = declaredLiterals(this.values, "url");
+				const output = replaceSecretLiterals(value, this.values, "url", literals);
+				if (literals.some((literal) => output.includes(literal))) return {
+					url: "",
+					origin: null,
+					query_parameter_names: [],
+					redacted: true
+				};
+				const sanitized = sanitizeBrowserUrl(output);
+				return {
+					...sanitized,
+					redacted: sanitized.redacted || output !== value
+				};
+			}
+			fingerprint(value) {
+				for (const secret of this.values.values()) if (secret !== "" && value.includes(secret)) return {
+					value_state: "redacted-secret",
+					value_sha256: null
+				};
+				return {
+					value_state: "hashed",
+					value_sha256: createHash("sha256").update(this.redact(value)).digest("hex")
+				};
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightExecutionBoundary.js
+var OPERATION$2, withPlaywrightExecutionBoundary;
+function init_PlaywrightExecutionBoundary() {
+	return (init_PlaywrightExecutionBoundary = __esmMin((() => {
+		init_analysisErrorCore();
+		OPERATION$2 = "capture_browser_scenario";
+		withPlaywrightExecutionBoundary = (work, timeoutMs, signal) => {
+			if (timeoutMs !== undefined && timeoutMs <= 0) return Promise.reject(new AnalysisTimeoutError(OPERATION$2, timeoutMs));
+			if (signal?.aborted === true) return Promise.reject(new AnalysisCancelledError(OPERATION$2));
+			return new Promise((resolve, reject) => {
+				let settled = false;
+				let timer;
+				const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+				const scheduleTimeout = () => {
+					if (deadline === undefined) return;
+					const remaining = deadline - Date.now();
+					if (remaining <= 0) {
+						fail(new AnalysisTimeoutError(OPERATION$2, timeoutMs ?? 0));
+						return;
+					}
+					timer = setTimeout(scheduleTimeout, Math.min(remaining, 2147483647));
+					timer.unref();
+				};
+				const cleanup = () => {
+					if (timer !== undefined) clearTimeout(timer);
+					signal?.removeEventListener("abort", onAbort);
+				};
+				const succeed = (value) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					resolve(value);
+				};
+				const fail = (error) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					reject(error);
+				};
+				const onAbort = () => {
+					fail(new AnalysisCancelledError(OPERATION$2));
+				};
+				scheduleTimeout();
+				signal?.addEventListener("abort", onAbort, { once: true });
+				if (signal?.aborted === true) {
+					onAbort();
+					return;
+				}
+				void work().then(succeed, fail);
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioBrowser.js
+var OPERATION$1, throwIfScenarioCancelled$1, PlaywrightScenarioBrowserCleanupOwner, attachedScenarioAdmissions, releaseAttachedScenario, createAttachedScenarioRelease, attachedScenarioLeaseKey, acquireAttachedScenario, allowedBrowserEnvironment, findConnectedPage, configureAttachedEnvironment, failBrowserScenarioOperation, openAttachedScenarioBrowser, openPlaywrightScenarioBrowser;
+function init_PlaywrightScenarioBrowser() {
+	return (init_PlaywrightScenarioBrowser = __esmMin((() => {
+		init_analysisErrorBase();
+		init_browserObservation();
+		init_browserObservationError();
+		init_PlaywrightExecutionBoundary();
+		OPERATION$1 = "capture_browser_scenario";
+		throwIfScenarioCancelled$1 = (signal) => {
+			if (signal?.aborted === true) throw new BrowserObservationError(OPERATION$1, "cancelled");
+		};
+		PlaywrightScenarioBrowserCleanupOwner = class {
+			resources;
+			#browserClosed = false;
+			#profileRemoved;
+			#closePromise;
+			#eventFinalizationPromise;
+			/** Keep the narrow provider actions needed to release one opened browser. */
+			constructor(resources) {
+				this.resources = resources;
+				this.#profileRemoved = resources.removeProfile === undefined;
+			}
+			get browserClosed() {
+				return this.#browserClosed;
+			}
+			close(finishEvents, signal) {
+				const cleanup = this.#closePromise ?? this.#closeResources(finishEvents);
+				if (this.#closePromise === undefined) {
+					this.#closePromise = cleanup;
+					void cleanup.then(() => this.resources.onSettled?.(this.#browserClosed), () => {
+						if (this.#closePromise === cleanup) this.#closePromise = undefined;
+						this.resources.onSettled?.(this.#browserClosed);
+					});
+				}
+				return this.#awaitCleanup(cleanup, signal);
+			}
+			async #awaitCleanup(cleanup, signal) {
+				try {
+					await withPlaywrightExecutionBoundary(() => cleanup, 1e3, signal);
+				} catch (cause) {
+					throw new BrowserObservationError(OPERATION$1, "cleanup_failed", {
+						cause,
+						cleanup: {
+							reason: cause instanceof Error ? cause.message : String(cause),
+							resources: ["browser_transport", ...this.resources.removeProfile === undefined ? [] : ["browser_profile"]]
+						}
+					});
+				}
+			}
+			async #closeResources(finishEvents) {
+				const failures = [];
+				const eventFinalization = this.#eventFinalizationPromise ??= Promise.resolve().then(async () => {
+					await finishEvents?.();
+				});
+				try {
+					await eventFinalization;
+				} catch (cause) {
+					failures.push(cause);
+				}
+				if (!this.#browserClosed) {
+					try {
+						await this.resources.closeBrowser();
+						this.#browserClosed = true;
+					} catch (cause) {
+						failures.push(cause);
+					}
+				}
+				if (this.#browserClosed && !this.#profileRemoved && this.resources.removeProfile !== undefined) {
+					try {
+						await this.resources.removeProfile();
+						this.#profileRemoved = true;
+					} catch (cause) {
+						failures.push(cause);
+					}
+				}
+				if (failures.length === 1) throw failures[0];
+				if (failures.length > 1) throw new AggregateError(failures, "Browser session cleanup failed");
+			}
+		};
+		attachedScenarioAdmissions = new Map();
+		releaseAttachedScenario = (key, admission) => {
+			const waiter = admission.waiters.shift();
+			if (waiter === undefined) {
+				admission.active = false;
+				if (admission.cleanupOwner === undefined && attachedScenarioAdmissions.get(key) === admission) attachedScenarioAdmissions.delete(key);
+				return;
+			}
+			if (waiter.onAbort !== undefined) waiter.signal?.removeEventListener("abort", waiter.onAbort);
+			if (waiter.signal?.aborted === true) {
+				waiter.reject(new BrowserObservationError(OPERATION$1, "cancelled"));
+				releaseAttachedScenario(key, admission);
+				return;
+			}
+			waiter.resolve(createAttachedScenarioRelease(key, admission));
+		};
+		createAttachedScenarioRelease = (key, admission) => {
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				releaseAttachedScenario(key, admission);
+			};
+		};
+		attachedScenarioLeaseKey = (endpoint, targetId) => {
+			const discovery = new URL("/json/version", endpoint);
+			if (isLiteralLoopbackHostname(discovery.hostname)) discovery.hostname = "127.0.0.1";
+			return JSON.stringify([discovery.href, targetId]);
+		};
+		acquireAttachedScenario = (scenario, signal) => {
+			if (signal?.aborted === true) return Promise.reject(new BrowserObservationError(OPERATION$1, "cancelled"));
+			const key = attachedScenarioLeaseKey(scenario.cdp_endpoint, scenario.target_id);
+			const admission = attachedScenarioAdmissions.get(key) ?? {
+				active: false,
+				waiters: [],
+				cleanupOwner: undefined
+			};
+			attachedScenarioAdmissions.set(key, admission);
+			return new Promise((resolve, reject) => {
+				const grant = (release) => resolve({
+					admission,
+					release
+				});
+				if (!admission.active) {
+					admission.active = true;
+					grant(createAttachedScenarioRelease(key, admission));
+					return;
+				}
+				const waiter = {
+					signal,
+					resolve: (release) => grant(release),
+					reject,
+					onAbort: undefined
+				};
+				admission.waiters.push(waiter);
+				if (signal !== undefined) {
+					const onAbort = () => {
+						const index = admission.waiters.indexOf(waiter);
+						if (index < 0) return;
+						admission.waiters.splice(index, 1);
+						signal.removeEventListener("abort", onAbort);
+						reject(new BrowserObservationError(OPERATION$1, "cancelled"));
+						if (!admission.active && admission.waiters.length === 0) releaseAttachedScenario(key, admission);
+					};
+					waiter.onAbort = onAbort;
+					signal.addEventListener("abort", onAbort, { once: true });
+					if (signal.aborted) {
+						onAbort();
+						return;
+					}
+				}
+			});
+		};
+		allowedBrowserEnvironment = (environment) => {
+			const allowed = [
+				"DBUS_SESSION_BUS_ADDRESS",
+				"DISPLAY",
+				"HOME",
+				"LANG",
+				"LD_LIBRARY_PATH",
+				"PATH",
+				"SystemRoot",
+				"TEMP",
+				"TMP",
+				"TMPDIR",
+				"WAYLAND_DISPLAY",
+				"XAUTHORITY",
+				"XDG_RUNTIME_DIR"
+			];
+			const selected = Object.fromEntries(allowed.map((name) => [name, environment[name]]).filter((entry) => entry[1] !== undefined));
+			if (process.platform !== "android") return selected;
+			const prefix = environment.PREFIX;
+			if (prefix === undefined) return selected;
+			return {
+				...selected,
+				LD_PRELOAD: `${prefix}/lib/libtermux-exec.so`,
+				TERMUX_EXEC__PROC_SELF_EXE: process.execPath
+			};
+		};
+		findConnectedPage = async (browser, targetId, signal) => {
+			for (const context of browser.contexts()) for (const page of context.pages()) {
+				const session = await context.newCDPSession(page);
+				try {
+					throwIfScenarioCancelled$1(signal);
+					const { targetInfo } = await session.send("Target.getTargetInfo");
+					throwIfScenarioCancelled$1(signal);
+					if (targetInfo.targetId !== targetId) continue;
+					return {
+						context,
+						page
+					};
+				} finally {
+					await session.detach();
+				}
+			}
+			throw new BrowserObservationError(OPERATION$1, "target_not_found");
+		};
+		configureAttachedEnvironment = async (context, page, environment, signal) => {
+			await page.emulateMedia({
+				colorScheme: environment.color_scheme,
+				reducedMotion: environment.reduced_motion
+			});
+			throwIfScenarioCancelled$1(signal);
+			const session = await context.newCDPSession(page);
+			throwIfScenarioCancelled$1(signal);
+			await session.send("Emulation.setDeviceMetricsOverride", {
+				width: environment.viewport.width,
+				height: environment.viewport.height,
+				deviceScaleFactor: environment.viewport.device_scale_factor,
+				mobile: false,
+				dontSetVisibleSize: true
+			});
+			throwIfScenarioCancelled$1(signal);
+			await session.send("Emulation.setLocaleOverride", { locale: environment.locale });
+			throwIfScenarioCancelled$1(signal);
+			await session.send("Emulation.setTimezoneOverride", { timezoneId: environment.timezone });
+		};
+		failBrowserScenarioOperation = async (cleanup, primaryFailure, fallbackCleanupResources = ["browser_transport"]) => {
+			try {
+				await cleanup();
+			} catch (cleanupFailure) {
+				const cleanupDetails = cleanupFailure instanceof AnalysisError && cleanupFailure.cleanup !== undefined ? cleanupFailure.cleanup : {
+					reason: cleanupFailure instanceof Error ? cleanupFailure.message : String(cleanupFailure),
+					resources: cleanupFailure instanceof AnalysisError ? cleanupFailure.cleanupResources : fallbackCleanupResources
+				};
+				throw new BrowserObservationError(OPERATION$1, "cleanup_failed", {
+					cause: new AggregateError([primaryFailure, cleanupFailure], "Browser scenario operation and cleanup both failed", { cause: primaryFailure }),
+					cleanup: cleanupDetails
+				});
+			}
+			throw primaryFailure;
+		};
+		openAttachedScenarioBrowser = async (browserRequest, environment, launcher, signal, retainCleanup) => {
+			const lease = await acquireAttachedScenario(browserRequest, signal);
+			let cleanupOwner;
+			try {
+				const priorOwner = lease.admission.cleanupOwner;
+				if (priorOwner !== undefined) await priorOwner.close();
+				throwIfScenarioCancelled$1(signal);
+				const browser = await launcher.connectOverCDP(browserRequest.cdp_endpoint);
+				const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
+					closeBrowser: () => browser.close(),
+					onSettled: (browserClosed) => {
+						if (browserClosed && lease.admission.cleanupOwner === cleanup) lease.admission.cleanupOwner = undefined;
+						lease.release();
+					},
+					removeProfile: undefined
+				});
+				cleanupOwner = cleanup;
+				lease.admission.cleanupOwner = cleanup;
+				throwIfScenarioCancelled$1(signal);
+				const target = await withPlaywrightExecutionBoundary(() => findConnectedPage(browser, browserRequest.target_id, signal), undefined, signal);
+				throwIfScenarioCancelled$1(signal);
+				await withPlaywrightExecutionBoundary(() => configureAttachedEnvironment(target.context, target.page, environment, signal), undefined, signal);
+				return {
+					...target,
+					browser,
+					profilePath: undefined,
+					cleanup
+				};
+			} catch (cause) {
+				if (cleanupOwner === undefined) {
+					lease.release();
+					throw cause;
+				}
+				const cleanup = cleanupOwner;
+				const close = () => cleanup.close();
+				try {
+					return await failBrowserScenarioOperation(close, cause);
+				} catch (failure) {
+					if (failure !== cause) retainCleanup?.(close);
+					throw failure;
+				}
+			}
+		};
+		openPlaywrightScenarioBrowser = async (scenario, environment, options = {}) => {
+			const launcher = options.launcher ?? (await import("playwright-core")).chromium;
+			if (scenario.browser.mode === "connect") return openAttachedScenarioBrowser(scenario.browser, scenario.environment, launcher, options.signal, options.retainCleanup);
+			const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
+			let context;
+			try {
+				await chmod(profilePath, 448);
+				context = await launcher.launchPersistentContext(profilePath, {
+					executablePath: resolve(scenario.browser.executable_path),
+					headless: scenario.browser.headless,
+					acceptDownloads: false,
+					viewport: {
+						width: scenario.environment.viewport.width,
+						height: scenario.environment.viewport.height
+					},
+					deviceScaleFactor: scenario.environment.viewport.device_scale_factor,
+					locale: scenario.environment.locale,
+					timezoneId: scenario.environment.timezone,
+					colorScheme: scenario.environment.color_scheme,
+					reducedMotion: scenario.environment.reduced_motion,
+					serviceWorkers: scenario.environment.service_workers,
+					env: allowedBrowserEnvironment(environment),
+					handleSIGHUP: false,
+					handleSIGINT: false,
+					handleSIGTERM: false,
+					timeout: 0,
+					args: process.platform === "android" ? ["--no-sandbox", "--single-process"] : []
+				});
+			} catch (cause) {
+				const cleanup = () => rm(profilePath, {
+					recursive: true,
+					force: true,
+					maxRetries: 3
+				});
+				try {
+					return await failBrowserScenarioOperation(cleanup, cause, ["browser_profile"]);
+				} catch (failure) {
+					if (failure !== cause) options.retainCleanup?.(cleanup);
+					throw failure;
+				}
+			}
+			const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
+				closeBrowser: () => context.close(),
+				removeProfile: () => rm(profilePath, {
+					recursive: true,
+					force: true,
+					maxRetries: 3
+				})
+			});
+			try {
+				const browser = context.browser();
+				if (browser === null) throw new BrowserObservationError(OPERATION$1, "protocol_error");
+				const page = context.pages()[0] ?? await context.newPage();
+				return {
+					context,
+					page,
+					browser,
+					profilePath,
+					cleanup
+				};
+			} catch (cause) {
+				const close = () => cleanup.close();
+				try {
+					return await failBrowserScenarioOperation(close, cause);
+				} catch (failure) {
+					if (failure !== cause) options.retainCleanup?.(close);
+					throw failure;
+				}
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioActions.js
+var resolveLocator, resolveValue, performPlaywrightScenarioAction;
+function init_PlaywrightScenarioActions() {
+	return (init_PlaywrightScenarioActions = __esmMin((() => {
+		resolveLocator = (page, locator) => {
+			switch (locator.kind) {
+				case "test_id": return page.getByTestId(locator.value);
+				case "role": return page.getByRole(locator.role, {
+					name: locator.name,
+					exact: true
+				});
+				case "css": return page.locator(locator.selector);
+			}
+		};
+		resolveValue = (value, secrets) => secrets.value(value);
+		performPlaywrightScenarioAction = async (input) => {
+			const { page, action, secrets } = input;
+			const timeout = "timeout_ms" in action ? action.timeout_ms : undefined;
+			const options = timeout === undefined ? {} : { timeout };
+			switch (action.action) {
+				case "goto":
+					await page.goto(secrets.url(action.destination), {
+						...options,
+						waitUntil: action.wait_until
+					});
+					return;
+				case "click":
+					await resolveLocator(page, action.locator).click({
+						...options,
+						button: action.button,
+						clickCount: action.click_count
+					});
+					return;
+				case "fill":
+					await resolveLocator(page, action.locator).fill(resolveValue(action.value, secrets), options);
+					return;
+				case "press":
+					await resolveLocator(page, action.locator).press(action.key, options);
+					return;
+				case "select_option":
+					await resolveLocator(page, action.locator).selectOption(resolveValue(action.value, secrets), options);
+					return;
+				case "check":
+					await resolveLocator(page, action.locator).check(options);
+					return;
+				case "uncheck":
+					await resolveLocator(page, action.locator).uncheck(options);
+					return;
+				case "wait_for":
+					await resolveLocator(page, action.locator).waitFor({
+						...options,
+						state: action.state
+					});
+					return;
+				case "wait_for_timeout": await page.waitForTimeout(action.duration_ms);
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioArtifacts.js
+var historyValueSchema, storageValueSchema, notRequested, missing, textArtifact, captureScreenshot, captureDom, captureAccessibility, navigationType, captureHistory, captureStorage, capturePlaywrightStepArtifacts;
+function init_PlaywrightScenarioArtifacts() {
+	return (init_PlaywrightScenarioArtifacts = __esmMin((() => {
+		init_browserScenarioCaptureValues();
+		historyValueSchema = z.strictObject({
+			length: z.number().int().min(0),
+			navigation_entries: z.array(z.strictObject({
+				type: z.string(),
+				name: z.string()
+			}))
+		});
+		storageValueSchema = z.strictObject({
+			local_storage: z.array(z.tuple([z.string(), z.string()])),
+			session_storage: z.array(z.tuple([z.string(), z.string()]))
+		});
+		notRequested = () => ({ state: "not_requested" });
+		missing = (reason) => ({
+			state: "missing",
+			reason
+		});
+		textArtifact = (text) => {
+			const bytes = Buffer.from(text);
+			return {
+				state: "captured",
+				value: {
+					sha256: createHash("sha256").update(bytes).digest("hex"),
+					bytes: bytes.byteLength,
+					text
+				}
+			};
+		};
+		captureScreenshot = async (page) => {
+			try {
+				const bytes = await page.screenshot({
+					type: "png",
+					fullPage: false,
+					animations: "disabled",
+					caret: "hide"
+				});
+				const sha256 = createHash("sha256").update(bytes).digest("hex");
+				return {
+					state: "captured",
+					value: {
+						sha256,
+						bytes: bytes.byteLength,
+						media_type: "image/png",
+						data_base64: bytes.toString("base64")
+					}
+				};
+			} catch (cause) {
+				void cause;
+				return missing("screenshot capture failed");
+			}
+		};
+		captureDom = async (input) => {
+			const { page, secrets } = input;
+			try {
+				return textArtifact(secrets.redact(await page.content()));
+			} catch (cause) {
+				void cause;
+				return missing("DOM capture failed");
+			}
+		};
+		captureAccessibility = async (input) => {
+			const { page, secrets } = input;
+			try {
+				const text = await page.locator("html").ariaSnapshot();
+				return textArtifact(secrets.redact(text));
+			} catch (cause) {
+				void cause;
+				return missing("accessibility capture failed");
+			}
+		};
+		navigationType = (value) => {
+			switch (value) {
+				case "navigate":
+				case "reload":
+				case "back_forward":
+				case "prerender": return value;
+				default: return "unknown";
+			}
+		};
+		captureHistory = async (page, secrets) => {
+			try {
+				const raw = historyValueSchema.parse(await page.evaluate(`(() => ({
+        length: window.history.length,
+        navigation_entries: performance.getEntriesByType("navigation").map(
+          entry => ({
+            type: typeof entry.type === "string" ? entry.type : "unknown",
+            name: entry.name
+          })
+        )
+      }))()`));
+				const value = {
+					length: raw.length,
+					current_url: secrets.sanitizeUrl(page.url()),
+					navigation_entries: raw.navigation_entries.map(({ type, name }) => ({
+						type: navigationType(type),
+						name: secrets.sanitizeUrl(name)
+					}))
+				};
+				return {
+					state: "captured",
+					value
+				};
+			} catch (cause) {
+				void cause;
+				return missing("history capture failed");
+			}
+		};
+		captureStorage = async (input) => {
+			const { context, page, secrets } = input;
+			try {
+				const pageUrl = new URL(page.url());
+				const cookies = pageUrl.protocol === "http:" || pageUrl.protocol === "https:" ? await context.cookies(pageUrl.href) : [];
+				const pageStorage = storageValueSchema.parse(await page.evaluate(`(() => ({
+        local_storage: Object.entries(window.localStorage),
+        session_storage: Object.entries(window.sessionStorage)
+      }))()`));
+				const value = {
+					cookies: cookies.map((cookie) => ({
+						name: secrets.redact(cookie.name),
+						domain: secrets.redact(cookie.domain),
+						path: secrets.redact(cookie.path),
+						secure: cookie.secure,
+						http_only: cookie.httpOnly,
+						same_site: cookie.sameSite,
+						...secrets.fingerprint(cookie.value)
+					})),
+					local_storage: pageStorage.local_storage.map(([name, value]) => ({
+						name: secrets.redact(name),
+						...secrets.fingerprint(value)
+					})),
+					session_storage: pageStorage.session_storage.map(([name, value]) => ({
+						name: secrets.redact(name),
+						...secrets.fingerprint(value)
+					}))
+				};
+				return {
+					state: "captured",
+					value
+				};
+			} catch (cause) {
+				void cause;
+				return missing("storage capture failed");
+			}
+		};
+		capturePlaywrightStepArtifacts = async (input) => {
+			const { context, page, secrets, requested } = input;
+			const state = (kind, capture) => !requested.has(kind) ? Promise.resolve(notRequested()) : capture();
+			return browserStepArtifactsSchema.parse({
+				screenshot: await state("screenshot", () => captureScreenshot(page)),
+				dom: await state("dom", () => captureDom({
+					page,
+					secrets
+				})),
+				accessibility: await state("accessibility", () => captureAccessibility({
+					page,
+					secrets
+				})),
+				url: await state("url", async () => ({
+					state: "captured",
+					value: secrets.sanitizeUrl(page.url())
+				})),
+				history: await state("history", () => captureHistory(page, secrets)),
+				storage: await state("storage", () => captureStorage({
+					context,
+					page,
+					secrets
+				}))
+			});
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/network/PlaywrightNetworkContent.js
+var credentialHeaders, errorMessage, captureNetworkHeaders, captureNetworkBody;
+function init_PlaywrightNetworkContent() {
+	return (init_PlaywrightNetworkContent = __esmMin((() => {
+		init_analysisErrorCore();
+		init_PlaywrightExecutionBoundary();
+		credentialHeaders = new Set([
+			"authorization",
+			"proxy-authorization",
+			"cookie",
+			"set-cookie"
+		]);
+		errorMessage = (cause, secrets) => secrets.redact(cause instanceof Error && cause.message !== "" ? cause.message : "Network read failed");
+		captureNetworkHeaders = async (source, secrets, options) => {
+			try {
+				const headers = await withPlaywrightExecutionBoundary(() => source.headersArray(), options.timeoutMs, options.signal);
+				return {
+					state: "captured",
+					items: headers.map(({ name, value }) => {
+						const safeName = secrets.redact(name);
+						const credential = credentialHeaders.has(name.toLowerCase());
+						const safeValue = credential ? null : secrets.redactBytes(Buffer.from(value)).toString("utf8");
+						return {
+							name: safeName,
+							value: safeValue,
+							redacted: credential || safeName !== name || safeValue !== value
+						};
+					})
+				};
+			} catch (cause) {
+				return {
+					state: "unavailable",
+					message: errorMessage(cause, secrets)
+				};
+			}
+		};
+		captureNetworkBody = async (read, phase, source, secrets, options) => {
+			try {
+				const observed = await withPlaywrightExecutionBoundary(read, options.timeoutMs, options.signal);
+				if (observed === null) return { state: "not_exposed" };
+				const retained = secrets.redactBytes(observed);
+				const contentType = source.headers()["content-type"];
+				return {
+					state: "captured",
+					representation: phase === "request" ? "browser-exposed-request-bytes" : "playwright-response-body-bytes",
+					encoding: "base64",
+					content: retained.toString("base64"),
+					bytes: retained.length,
+					sha256: createHash("sha256").update(retained).digest("hex"),
+					media_type: contentType === undefined ? null : secrets.redactBytes(Buffer.from(contentType)).toString("utf8"),
+					redacted: !retained.equals(observed)
+				};
+			} catch (cause) {
+				return {
+					state: "unavailable",
+					reason: cause instanceof AnalysisCancelledError ? "cancelled" : cause instanceof AnalysisTimeoutError ? "body-read-timeout" : "body-read-failed",
+					message: errorMessage(cause, secrets)
+				};
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/network/PlaywrightScenarioNetwork.js
+var PlaywrightScenarioNetwork;
+function init_PlaywrightScenarioNetwork() {
+	return (init_PlaywrightScenarioNetwork = __esmMin((() => {
+		init_PlaywrightNetworkContent();
+		PlaywrightScenarioNetwork = class {
+			options;
+			transactions = new Map();
+			pending = [];
+			gaps = new Set();
+			accepting = true;
+			readOptions;
+			constructor(options) {
+				this.options = options;
+				this.readOptions = {
+					timeoutMs: options.readTimeoutMs ?? 5e3,
+					...options.signal === undefined ? {} : { signal: options.signal }
+				};
+			}
+			/** Observe a request start, retaining the producer's redirect relationship when known. */
+			request(request) {
+				if (!this.accepting) return;
+				const transaction = this.transaction(request);
+				const sequence = this.options.emit({
+					...this.metadata(request, transaction),
+					kind: "request",
+					status: null,
+					failure: null
+				});
+				if (this.options.selection.request_body || this.options.selection.header_values) this.collect(transaction, sequence, "request", request, this.options.selection.request_body ? captureNetworkBody(async () => request.postDataBuffer(), "request", request, this.options.secrets, this.readOptions) : Promise.resolve({ state: "not_requested" }));
+			}
+			/** Observe response metadata without starting a potentially unfinished body read. */
+			response(response) {
+				if (!this.accepting) return;
+				const request = response.request();
+				const transaction = this.transaction(request);
+				const sequence = this.options.emit({
+					...this.metadata(request, transaction),
+					kind: "response",
+					url: this.options.secrets.sanitizeUrl(response.url()),
+					status: response.status(),
+					header_names: this.headerNames(response),
+					failure: null
+				});
+				transaction.response = {
+					source: response,
+					sequence
+				};
+			}
+			/** Record completion and read selected content through the response API. */
+			finished(request) {
+				if (!this.accepting) return;
+				const transaction = this.transaction(request);
+				transaction.terminal = "finished";
+				this.options.emit({
+					...this.metadata(request, transaction),
+					kind: "request-finished",
+					status: null,
+					failure: null
+				});
+				this.responseContent(transaction);
+			}
+			/** Preserve request failure separately from missing or unreadable response content. */
+			failed(request) {
+				if (!this.accepting) return;
+				const transaction = this.transaction(request);
+				transaction.terminal = "failed";
+				const message = this.options.secrets.redact(request.failure()?.errorText || "Unknown request failure");
+				this.options.emit({
+					...this.metadata(request, transaction),
+					kind: "request-failed",
+					status: null,
+					failure: message
+				});
+				this.responseContent(transaction, {
+					state: "unavailable",
+					reason: "request-failed",
+					message
+				});
+			}
+			/** Stop observing, mark unfinished transactions, and settle bounded content reads. */
+			async finish() {
+				if (!this.accepting) {
+					await Promise.all(this.pending);
+					return;
+				}
+				this.accepting = false;
+				for (const [request, transaction] of this.transactions) {
+					if (transaction.terminal === undefined) {
+						this.gaps.add("Some network requests had not completed when capture ended; later activity is unknown.");
+						this.options.emit({
+							...this.metadata(request, transaction),
+							kind: "request-unfinished",
+							status: null,
+							failure: null,
+							reason: this.options.signal?.aborted === true ? "cancelled" : "capture-ended"
+						});
+						this.responseContent(transaction, {
+							state: "unavailable",
+							reason: this.options.signal?.aborted === true ? "cancelled" : "response-unfinished",
+							message: "The response had not finished at the capture cutoff; no body read or refetch was attempted."
+						});
+					}
+				}
+				await Promise.all(this.pending);
+			}
+			/** Missing selected content contributes to aggregate completeness. */
+			limitations() {
+				return [...this.gaps];
+			}
+			transaction(request) {
+				const known = this.transactions.get(request);
+				if (known !== undefined) return known;
+				const predecessor = request.redirectedFrom();
+				const transaction = {
+					id: `request-${this.transactions.size + 1}`,
+					redirectedFrom: predecessor === null ? null : this.transactions.get(predecessor)?.id ?? null,
+					responseScheduled: false
+				};
+				this.transactions.set(request, transaction);
+				return transaction;
+			}
+			headerNames(source) {
+				return Object.keys(source.headers()).map((name) => this.options.secrets.redact(name)).sort();
+			}
+			metadata(request, transaction) {
+				return {
+					transaction_id: transaction.id,
+					redirected_from_transaction_id: transaction.redirectedFrom,
+					method: this.options.secrets.redact(request.method()),
+					url: this.options.secrets.sanitizeUrl(request.url()),
+					resource_type: this.options.secrets.redact(request.resourceType()),
+					header_names: this.headerNames(request)
+				};
+			}
+			responseContent(transaction, unavailable) {
+				const response = transaction.response;
+				if (response === undefined || transaction.responseScheduled || !this.options.selection.response_body && !this.options.selection.header_values) return;
+				transaction.responseScheduled = true;
+				this.collect(transaction, response.sequence, "response", response.source, this.options.selection.response_body ? unavailable === undefined ? captureNetworkBody(() => response.source.body(), "response", response.source, this.options.secrets, this.readOptions) : Promise.resolve(unavailable) : Promise.resolve({ state: "not_requested" }));
+			}
+			collect(transaction, sequence, phase, source, body) {
+				const headers = this.options.selection.header_values ? captureNetworkHeaders(source, this.options.secrets, this.readOptions) : Promise.resolve({ state: "not_requested" });
+				this.pending.push(Promise.all([headers, body]).then(([retainedHeaders, retainedBody]) => {
+					if (retainedHeaders.state === "unavailable" || retainedBody.state === "unavailable" || retainedBody.state === "not_exposed") this.gaps.add("Some selected network content was unavailable; per-transaction content states retain the reason.");
+					this.options.emit({
+						kind: "network-content",
+						transaction_id: transaction.id,
+						source_event_sequence: sequence,
+						phase,
+						headers: retainedHeaders,
+						body: retainedBody
+					});
+				}));
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioEvents.js
+var PlaywrightScenarioEvents;
+function init_PlaywrightScenarioEvents() {
+	return (init_PlaywrightScenarioEvents = __esmMin((() => {
+		init_browserScenarioCaptureValues();
+		init_PlaywrightScenarioNetwork();
+		PlaywrightScenarioEvents = class {
+			items = [];
+			stepIndex = 0;
+			sequence = 0;
+			enabled;
+			secrets;
+			ownsContext;
+			pages = new Set();
+			incompleteFamilies = new Set();
+			network;
+			stopNetwork;
+			sealed = false;
+			constructor(options) {
+				const network = options.network ?? {
+					request_body: false,
+					response_body: false,
+					header_values: false
+				};
+				this.enabled = new Set(options.enabled);
+				if (network.request_body || network.response_body || network.header_values) this.enabled = new Set([...this.enabled, "network"]);
+				this.secrets = options.secrets;
+				this.ownsContext = options.ownsContext === true;
+				this.pages.add(options.page);
+				if (this.ownsContext && this.enabled.size > 0) (options.context ?? options.page.context()).on("page", (page) => this.popup(page));
+				if (this.enabled.has("network")) {
+					const context = options.context ?? options.page.context();
+					const collector = new PlaywrightScenarioNetwork({
+						selection: network,
+						secrets: options.secrets,
+						emit: (event) => this.push(event),
+						...options.signal === undefined ? {} : { signal: options.signal }
+					});
+					this.network = collector;
+					const inScope = (request) => {
+						if (this.ownsContext) return true;
+						try {
+							return this.pages.has(request.frame().page());
+						} catch (cause) {
+							void cause;
+							return false;
+						}
+					};
+					const onRequest = (request) => {
+						if (inScope(request)) collector.request(request);
+					};
+					const onResponse = (response) => {
+						if (inScope(response.request())) collector.response(response);
+					};
+					const onFailed = (request) => {
+						if (inScope(request)) collector.failed(request);
+					};
+					const onFinished = (request) => {
+						if (inScope(request)) collector.finished(request);
+					};
+					context.on("request", onRequest);
+					context.on("response", onResponse);
+					context.on("requestfailed", onFailed);
+					context.on("requestfinished", onFinished);
+					this.stopNetwork = () => {
+						context.off("request", onRequest);
+						context.off("response", onResponse);
+						context.off("requestfailed", onFailed);
+						context.off("requestfinished", onFinished);
+					};
+				}
+				this.observePage(options.page);
+			}
+			setStep(index) {
+				this.stepIndex = index;
+			}
+			nextSequence() {
+				return this.sequence + 1;
+			}
+			lastSequence() {
+				return this.sequence;
+			}
+			/** Drain selected network content and freeze the result before browser teardown. */
+			async finish() {
+				this.stopNetwork?.();
+				this.stopNetwork = undefined;
+				try {
+					await this.network?.finish();
+				} finally {
+					this.sealed = true;
+				}
+			}
+			/** Report selected popup event families with unrecoverable pre-discovery gaps. */
+			limitations() {
+				const popupGaps = [...this.incompleteFamilies].map((family) => `Popup ${family} events before Page discovery are unavailable; later events are retained.`);
+				const gaps = [...popupGaps, ...this.network?.limitations() ?? []];
+				return this.enabled.has("network") && !this.ownsContext ? ["Shared-context network capture excludes requests without a known root or descendant Page frame.", ...gaps] : gaps;
+			}
+			result() {
+				return {
+					retained: this.items.length,
+					dropped: 0,
+					items: this.items
+				};
+			}
+			push(event) {
+				if (this.sealed) return this.sequence;
+				this.sequence += 1;
+				const parsed = browserScenarioEventSchema.parse({
+					...event,
+					sequence: this.sequence,
+					step_index: this.stepIndex
+				});
+				this.items.push(parsed);
+				return this.sequence;
+			}
+			observePage(page) {
+				if (this.enabled.has("console")) page.on("console", (message) => this.console(message));
+				if (this.enabled.has("page-errors")) page.on("pageerror", (error) => {
+					this.push({
+						kind: "page-error",
+						message: this.secrets.redact(error.message),
+						stack: error.stack === undefined ? null : this.secrets.redact(error.stack)
+					});
+				});
+				if (this.enabled.has("websockets")) page.on("websocket", (socket) => this.webSocket(socket));
+				if (this.enabled.has("frames")) {
+					page.on("frameattached", (frame) => this.frame("frame-attached", frame));
+					page.on("framedetached", (frame) => this.frame("frame-detached", frame));
+					page.on("framenavigated", (frame) => this.frame("frame-navigated", frame));
+				}
+				if (this.enabled.has("workers")) page.on("worker", (worker) => this.worker(worker));
+				if (this.enabled.size > 0) page.on("popup", (popup) => this.popup(popup));
+				if (this.enabled.has("downloads")) page.on("download", (download) => this.download(download));
+			}
+			safeUrl(value) {
+				return this.secrets.sanitizeUrl(value);
+			}
+			console(message) {
+				const location = message.location();
+				this.push({
+					kind: "console",
+					level: this.secrets.redact(message.type()),
+					text: this.secrets.redact(message.text()),
+					url: location.url === "" ? null : this.safeUrl(location.url)
+				});
+			}
+			webSocket(socket) {
+				const url = this.safeUrl(socket.url());
+				this.push({
+					kind: "websocket-opened",
+					url
+				});
+				socket.on("framesent", ({ payload }) => this.webSocketFrame("websocket-frame-sent", url, payload));
+				socket.on("framereceived", ({ payload }) => this.webSocketFrame("websocket-frame-received", url, payload));
+				socket.on("close", () => this.push({
+					kind: "websocket-closed",
+					url
+				}));
+			}
+			webSocketFrame(kind, url, payload) {
+				const bytes = Buffer.byteLength(payload);
+				const isText = typeof payload === "string";
+				if (!isText) {
+					this.push({
+						kind,
+						url,
+						payload_type: "binary",
+						payload_bytes: bytes,
+						payload_text: null,
+						truncated: false
+					});
+					return;
+				}
+				const text = this.secrets.redact(payload);
+				this.push({
+					kind,
+					url,
+					payload_type: "text",
+					payload_bytes: bytes,
+					payload_text: text,
+					truncated: false
+				});
+			}
+			frame(kind, frame) {
+				this.push({
+					kind,
+					url: frame.url() === "" ? null : this.safeUrl(frame.url()),
+					name: frame.name() === "" ? null : this.secrets.redact(frame.name())
+				});
+			}
+			worker(worker) {
+				const details = {
+					url: this.safeUrl(worker.url()),
+					name: null
+				};
+				this.push({
+					kind: "worker-created",
+					...details
+				});
+				worker.on("close", () => this.push({
+					kind: "worker-closed",
+					...details
+				}));
+			}
+			popup(page) {
+				if (this.pages.has(page)) return;
+				this.pages.add(page);
+				for (const family of [
+					"frames",
+					"workers",
+					"websockets",
+					"downloads"
+				]) if (this.enabled.has(family)) this.incompleteFamilies.add(family);
+				const opened = {
+					url: page.url() === "" ? null : this.safeUrl(page.url()),
+					name: null
+				};
+				if (this.enabled.has("popups")) {
+					this.push({
+						kind: "popup-opened",
+						...opened
+					});
+					page.on("close", () => this.push({
+						kind: "popup-closed",
+						url: page.url() === "" ? null : this.safeUrl(page.url()),
+						name: null
+					}));
+				}
+				this.observePage(page);
+			}
+			download(download) {
+				this.push({
+					kind: "download-cancelled",
+					suggested_filename: this.secrets.redact(download.suggestedFilename()),
+					url: this.safeUrl(download.url())
+				});
+				void download.cancel().catch((cause) => {
+					void cause;
+				});
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioStorage.js
+var breakpointResponse, scriptIdentifierResponse, storageKeyResponse, targetInfoResponse, STORAGE_EVENT_METHODS, attachedTargetEvent, targetSessionEvent, nestedMessageEvent, nestedProtocolMessage, executionContextEvent, scriptParsedEvent, pausedEvent, evaluationResponse, STORAGE_CLEANUP_TIMEOUT_MS, PlaywrightScenarioStorage;
+function init_PlaywrightScenarioStorage() {
+	return (init_PlaywrightScenarioStorage = __esmMin((() => {
+		init_browserObservationError();
+		init_PlaywrightExecutionBoundary();
+		breakpointResponse = z.object({ breakpointId: z.string() });
+		scriptIdentifierResponse = z.object({ identifier: z.string() });
+		storageKeyResponse = z.object({ storageKey: z.string() });
+		targetInfoResponse = z.object({ targetInfo: z.object({ targetId: z.string() }) });
+		STORAGE_EVENT_METHODS = new Set([
+			"Runtime.executionContextCreated",
+			"Runtime.executionContextDestroyed",
+			"Runtime.executionContextsCleared",
+			"Debugger.scriptParsed",
+			"Debugger.paused",
+			"Target.attachedToTarget",
+			"Target.detachedFromTarget",
+			"Target.receivedMessageFromTarget"
+		]);
+		attachedTargetEvent = z.object({
+			sessionId: z.string(),
+			targetInfo: z.object({
+				type: z.string(),
+				targetId: z.string()
+			})
+		});
+		targetSessionEvent = z.object({ sessionId: z.string() });
+		nestedMessageEvent = z.object({
+			sessionId: z.string(),
+			message: z.string()
+		});
+		nestedProtocolMessage = z.object({
+			id: z.number().optional(),
+			method: z.string().optional(),
+			params: z.unknown().optional(),
+			result: z.unknown().optional(),
+			error: z.object({ message: z.string() }).optional()
+		});
+		executionContextEvent = z.object({ context: z.object({
+			id: z.number(),
+			origin: z.string(),
+			name: z.string(),
+			auxData: z.object({ frameId: z.string().optional() }).optional()
+		}) });
+		scriptParsedEvent = z.object({
+			scriptId: z.string(),
+			executionContextId: z.number(),
+			url: z.string()
+		});
+		pausedEvent = z.object({ callFrames: z.array(z.object({
+			callFrameId: z.string(),
+			location: z.object({ scriptId: z.string() })
+		})) });
+		evaluationResponse = z.object({ exceptionDetails: z.unknown().optional() });
+		STORAGE_CLEANUP_TIMEOUT_MS = 1e3;
+		PlaywrightScenarioStorage = class PlaywrightScenarioStorage {
+			cdp;
+			signal;
+			#seeds = new Map();
+			#initializedLocal = new Set();
+			#initializedSession = new Set();
+			#targets = new Map();
+			#replies = new Map();
+			#sourceUrl = `rea-storage-${randomUUID()}`;
+			#listeners = [];
+			#sequence = 0;
+			#generation = 0;
+			#closed = false;
+			#cleanupCompleted = false;
+			#failure;
+			#closePromise;
+			#detachPromise;
+			#rootInitialization;
+			#work = Promise.resolve();
+			#removeListeners = () => undefined;
+			constructor(cdp, signal) {
+				this.cdp = cdp;
+				this.signal = signal;
+			}
+			static async create(storagePage, scenario, secrets, options = {}) {
+				const { signal, retainCleanup } = options;
+				const { context, page } = storagePage;
+				if (scenario.storage.local_storage.length === 0 && scenario.storage.session_storage.length === 0) return undefined;
+				const connection = context.newCDPSession(page);
+				let cdp;
+				try {
+					cdp = await withPlaywrightExecutionBoundary(() => connection, undefined, signal);
+				} catch (cause) {
+					if (signal?.aborted === true) {
+						let detached = false;
+						const lateCleanup = async () => {
+							let session;
+							try {
+								session = await connection;
+							} catch {
+								return;
+							}
+							if (!detached) {
+								await session.detach();
+								detached = true;
+							}
+						};
+						retainCleanup?.(lateCleanup);
+						void withPlaywrightExecutionBoundary(lateCleanup, STORAGE_CLEANUP_TIMEOUT_MS).catch(() => undefined);
+					}
+					throw cause;
+				}
+				const owner = new PlaywrightScenarioStorage(cdp, signal);
+				owner.addSeeds(scenario.storage.local_storage, "local", secrets);
+				owner.addSeeds(scenario.storage.session_storage, "session", secrets);
+				return owner;
+			}
+			async initialize(page, context) {
+				const initialization = this.initializeRoot(page, context);
+				this.#rootInitialization = initialization;
+				await withPlaywrightExecutionBoundary(() => initialization, undefined, this.signal);
+			}
+			async initializeRoot(page, context) {
+				const rootInfo = targetInfoResponse.parse(await this.cdp.send("Target.getTargetInfo"));
+				const root = this.createTarget(undefined, rootInfo.targetInfo.targetId, (method, params) => this.cdp.send(method, params));
+				this.#targets.set("", root);
+				if (this.#closed) return;
+				this.listen(page, context);
+				const ready = this.initializeTarget(root);
+				root.ready = ready;
+				await ready;
+			}
+			addSeeds(blocks, kind, secrets) {
+				for (const { origin, entries } of blocks) {
+					const seed = this.#seeds.get(origin) ?? {
+						local: [],
+						session: []
+					};
+					seed[kind].push(...entries.map(({ name, value }) => [name, secrets.value(value)]));
+					this.#seeds.set(origin, seed);
+				}
+			}
+			listen(page, context) {
+				const browser = context.browser();
+				const detached = () => this.targetDetached("");
+				page.on("close", detached);
+				context.on("close", detached);
+				browser?.on("disconnected", detached);
+				this.#removeListeners = () => {
+					page.off("close", detached);
+					context.off("close", detached);
+					browser?.off("disconnected", detached);
+				};
+				for (const method of [
+					"Runtime.executionContextCreated",
+					"Runtime.executionContextDestroyed",
+					"Runtime.executionContextsCleared",
+					"Debugger.scriptParsed",
+					"Debugger.paused",
+					"Target.attachedToTarget",
+					"Target.detachedFromTarget",
+					"Target.receivedMessageFromTarget"
+				]) {
+					const listener = (params) => this.event("", method, params);
+					this.#listeners.push({
+						method,
+						listener
+					});
+					this.cdp.on(method, listener);
+				}
+			}
+			createTarget(parentId, topLevelTargetId, send) {
+				return {
+					parentId,
+					topLevelTargetId,
+					send,
+					contexts: new Map(),
+					scripts: new Map(),
+					ready: Promise.resolve(),
+					waitingForDebugger: false
+				};
+			}
+			async initializeTarget(target) {
+				if (this.#closed) return;
+				await target.send("Page.enable");
+				if (this.#closed) return;
+				await target.send("Runtime.enable");
+				if (this.#closed) return;
+				await target.send("Debugger.enable");
+				if (this.#closed) return;
+				breakpointResponse.parse(await target.send("Debugger.setBreakpointByUrl", {
+					url: this.#sourceUrl,
+					lineNumber: 1
+				}));
+				if (this.#closed) return;
+				scriptIdentifierResponse.parse(await target.send("Page.addScriptToEvaluateOnNewDocument", {
+					worldName: this.#sourceUrl,
+					source: `(() => {\n  void 0;\n})()\n//# sourceURL=${this.#sourceUrl}`
+				}));
+				if (this.#closed) return;
+				await target.send("Target.setAutoAttach", {
+					autoAttach: true,
+					waitForDebuggerOnStart: true,
+					flatten: false
+				});
+			}
+			sendObserved(target, method, params) {
+				return withPlaywrightExecutionBoundary(() => target.send(method, params), undefined, this.signal);
+			}
+			event(sessionId, method, params) {
+				if (this.#closed) return;
+				const target = this.#targets.get(sessionId);
+				if (target === undefined) return;
+				try {
+					if (method === "Runtime.executionContextCreated") {
+						const { context } = executionContextEvent.parse(params);
+						if (context.name === this.#sourceUrl) target.contexts.set(context.id, context);
+					} else if (method === "Runtime.executionContextDestroyed") {
+						const { executionContextId } = z.object({ executionContextId: z.number() }).parse(params);
+						target.contexts.delete(executionContextId);
+					} else if (method === "Runtime.executionContextsCleared") {
+						target.contexts.clear();
+						target.scripts.clear();
+					} else if (method === "Debugger.scriptParsed") {
+						const script = scriptParsedEvent.parse(params);
+						if (script.url === this.#sourceUrl) target.scripts.set(script.scriptId, script.executionContextId);
+					} else if (method === "Debugger.paused") {
+						const pause = pausedEvent.parse(params);
+						const frame = pause.callFrames[0];
+						if (frame === undefined || !target.scripts.has(frame.location.scriptId)) return;
+						this.#generation += 1;
+						this.#work = this.#work.then(() => this.seed(target, pause)).catch((cause) => {
+							if (sessionId === "" || this.#targets.get(sessionId) === target) this.fail(cause);
+						});
+					} else if (method === "Target.attachedToTarget") {
+						this.#generation += 1;
+						this.attach(sessionId, attachedTargetEvent.parse(params));
+					} else if (method === "Target.detachedFromTarget") {
+						this.#generation += 1;
+						this.targetDetached(targetSessionEvent.parse(params).sessionId);
+					} else if (method === "Target.receivedMessageFromTarget") {
+						this.nestedMessage(nestedMessageEvent.parse(params));
+					}
+				} catch (cause) {
+					this.fail(cause);
+				}
+			}
+			nestedMessage(event) {
+				const reply = nestedProtocolMessage.parse(JSON.parse(event.message));
+				if (reply.id !== undefined) {
+					const waiter = this.#replies.get(reply.id);
+					if (waiter?.sessionId !== event.sessionId) return;
+					this.#replies.delete(reply.id);
+					if (reply.error !== undefined) waiter.reject(new Error(reply.error.message));
+					else waiter.resolve(reply.result);
+					return;
+				}
+				if (reply.method !== undefined && STORAGE_EVENT_METHODS.has(reply.method)) this.event(event.sessionId, reply.method, reply.params);
+			}
+			fail(cause) {
+				this.#generation += 1;
+				this.#failure ??= new BrowserObservationError("capture_browser_scenario", "protocol_error", { cause });
+			}
+			async seedPausedFrame(target, frame) {
+				const contextId = target.scripts.get(frame.location.scriptId);
+				const context = contextId === undefined ? undefined : target.contexts.get(contextId);
+				const seed = context === undefined ? undefined : this.#seeds.get(context.origin);
+				if (this.#closed || seed === undefined || context?.auxData?.frameId === undefined) return;
+				const storageKey = storageKeyResponse.parse(await this.sendObserved(target, "Storage.getStorageKey", { frameId: context.auxData.frameId })).storageKey;
+				const sessionKey = JSON.stringify([target.topLevelTargetId, storageKey]);
+				const local = this.#initializedLocal.has(storageKey) || seed.local.length === 0 ? [] : seed.local;
+				const session = this.#initializedSession.has(sessionKey) || seed.session.length === 0 ? [] : seed.session;
+				if (local.length === 0 && session.length === 0) return;
+				const payload = JSON.stringify({
+					local,
+					session
+				}).replaceAll("<", "\\u003c");
+				const response = evaluationResponse.parse(await this.sendObserved(target, "Debugger.evaluateOnCallFrame", {
+					callFrameId: frame.callFrameId,
+					expression: `(() => { const seed = ${payload}; for (const [name, value] of seed.local) localStorage.setItem(name, value); for (const [name, value] of seed.session) sessionStorage.setItem(name, value); })()`,
+					returnByValue: true
+				}));
+				if (response.exceptionDetails !== undefined) throw new BrowserObservationError("capture_browser_scenario", "protocol_error", { detail: "The browser denied initial storage initialization." });
+				if (local.length > 0) this.#initializedLocal.add(storageKey);
+				if (session.length > 0) this.#initializedSession.add(sessionKey);
+			}
+			async seed(target, pause) {
+				const frame = pause.callFrames[0];
+				if (frame === undefined) return;
+				let primaryFailure;
+				let hasPrimaryFailure = false;
+				try {
+					await this.seedPausedFrame(target, frame);
+				} catch (cause) {
+					primaryFailure = cause;
+					hasPrimaryFailure = true;
+				}
+				let resumeFailure;
+				try {
+					await withPlaywrightExecutionBoundary(() => target.send("Debugger.resume"), STORAGE_CLEANUP_TIMEOUT_MS);
+				} catch (cause) {
+					resumeFailure = cause;
+				}
+				if (hasPrimaryFailure && resumeFailure !== undefined) throw new AggregateError([primaryFailure, resumeFailure], "Storage initialization and debugger resume both failed", { cause: primaryFailure });
+				if (this.signal?.aborted === true && resumeFailure === undefined) return;
+				if (hasPrimaryFailure) throw primaryFailure;
+				if (resumeFailure !== undefined) throw resumeFailure;
+			}
+			attach(parentId, event) {
+				const parent = this.#targets.get(parentId);
+				if (parent === undefined) return;
+				const { sessionId, targetInfo } = event;
+				const target = this.createTarget(parentId, event.targetInfo.type === "iframe" ? parent.topLevelTargetId : event.targetInfo.targetId, async (method, params = {}) => {
+					const id = ++this.#sequence;
+					const reply = new Promise((resolve, reject) => this.#replies.set(id, {
+						sessionId,
+						resolve,
+						reject
+					}));
+					try {
+						const sent = parent.send("Target.sendMessageToTarget", {
+							sessionId,
+							message: JSON.stringify({
+								id,
+								method,
+								params
+							})
+						});
+						const [, result] = await Promise.all([sent, reply]);
+						return result;
+					} finally {
+						this.#replies.delete(id);
+					}
+				});
+				target.waitingForDebugger = true;
+				this.#targets.set(sessionId, target);
+				target.ready = (async () => {
+					try {
+						if (!this.#closed && (targetInfo.type === "iframe" || targetInfo.type === "page")) await this.initializeTarget(target);
+					} catch (cause) {
+						if (this.signal?.aborted !== true && !this.#closed && this.#targets.get(sessionId) === target) this.fail(cause);
+					}
+					if (this.#targets.get(sessionId) !== target) return;
+					try {
+						await withPlaywrightExecutionBoundary(() => target.send("Runtime.runIfWaitingForDebugger"), STORAGE_CLEANUP_TIMEOUT_MS);
+						target.waitingForDebugger = false;
+					} catch (cause) {
+						if (this.signal?.aborted !== true && !this.#closed && this.#targets.get(sessionId) === target) this.fail(cause);
+					}
+				})();
+			}
+			targetDetached(sessionId) {
+				for (const [id, target] of this.#targets) if (target.parentId === sessionId) this.targetDetached(id);
+				this.#targets.delete(sessionId);
+				for (const [id, reply] of this.#replies) if (reply.sessionId === sessionId) {
+					this.#replies.delete(id);
+					reply.reject(new BrowserObservationError("capture_browser_scenario", "disconnected"));
+				}
+				this.#generation += 1;
+			}
+			async settle() {
+				for (;;) {
+					const generation = this.#generation;
+					const work = this.#work;
+					const targets = [...this.#targets.entries()];
+					await withPlaywrightExecutionBoundary(() => Promise.all(targets.map(([, target]) => target.ready)), undefined, this.signal);
+					await withPlaywrightExecutionBoundary(() => work, undefined, this.signal);
+					await Promise.resolve();
+					if (this.#failure !== undefined) throw this.#failure;
+					if (generation === this.#generation && work === this.#work && targets.every(([id, target]) => this.#targets.get(id) === target)) return;
+				}
+			}
+			close(stopLoading = false) {
+				if (this.#cleanupCompleted) return Promise.resolve();
+				if (this.#closePromise !== undefined) return this.#closePromise;
+				const closing = this.closeResources(stopLoading).catch((cause) => {
+					throw new BrowserObservationError("capture_browser_scenario", "cleanup_failed", {
+						cause,
+						cleanup: {
+							reason: cause instanceof Error ? cause.message : String(cause),
+							resources: ["browser_transport", "browser_storage_bootstrap"]
+						}
+					});
+				});
+				this.#closePromise = closing;
+				void closing.catch(() => {
+					if (this.#closePromise === closing) this.#closePromise = undefined;
+				});
+				return closing;
+			}
+			async closeResources(stopLoading) {
+				this.#closed = true;
+				let stopLoadingFailure;
+				if (stopLoading) {
+					try {
+						const root = this.#targets.get("");
+						if (root !== undefined) await withPlaywrightExecutionBoundary(() => root.send("Page.stopLoading"), STORAGE_CLEANUP_TIMEOUT_MS);
+					} catch (cause) {
+						stopLoadingFailure = { cause };
+					}
+				}
+				const work = this.#work;
+				const rootInitialization = this.#rootInitialization;
+				const targets = [...this.#targets.values()];
+				try {
+					await withPlaywrightExecutionBoundary(() => Promise.all([
+						work.catch(() => undefined),
+						...rootInitialization === undefined ? [] : [rootInitialization.catch(() => undefined)],
+						...targets.map((target) => target.ready.catch(() => undefined))
+					]), STORAGE_CLEANUP_TIMEOUT_MS);
+				} catch {}
+				let detach = this.#detachPromise;
+				if (detach === undefined) {
+					detach = Promise.resolve().then(() => this.cdp.detach());
+					this.#detachPromise = detach;
+					void detach.catch(() => {
+						if (this.#detachPromise === detach) this.#detachPromise = undefined;
+					});
+				}
+				await withPlaywrightExecutionBoundary(() => detach, STORAGE_CLEANUP_TIMEOUT_MS);
+				for (const { method, listener } of this.#listeners) this.cdp.off(method, listener);
+				this.#removeListeners();
+				for (const reply of this.#replies.values()) reply.reject(new BrowserObservationError("capture_browser_scenario", "disconnected"));
+				this.#targets.clear();
+				this.#replies.clear();
+				this.#cleanupCompleted = true;
+				if (stopLoadingFailure !== undefined) throw stopLoadingFailure.cause;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/browser/PlaywrightScenarioSession.js
+var OPERATION, throwIfScenarioCancelled, throwCleanupFailures, installCookies, blockAttachedServiceWorkers, initializePage, PlaywrightScenarioSession;
+function init_PlaywrightScenarioSession() {
+	return (init_PlaywrightScenarioSession = __esmMin((() => {
+		init_browserObservationError();
+		init_BrowserScenarioSecrets();
+		init_PlaywrightScenarioBrowser();
+		init_PlaywrightScenarioActions();
+		init_PlaywrightScenarioArtifacts();
+		init_PlaywrightScenarioEvents();
+		init_PlaywrightScenarioStorage();
+		init_PlaywrightExecutionBoundary();
+		init_BrowserScenarioPartialObservation();
+		OPERATION = "capture_browser_scenario";
+		throwIfScenarioCancelled = (signal) => {
+			if (signal?.aborted === true) throw new BrowserObservationError(OPERATION, "cancelled");
+		};
+		throwCleanupFailures = (failures) => {
+			if (failures.length === 1) throw failures[0];
+			if (failures.length > 1) throw new AggregateError(failures, "Browser scenario cleanup failed");
+		};
+		installCookies = async (context, scenario, secrets) => {
+			await context.addCookies(scenario.storage.cookies.map((cookie) => ({
+				name: cookie.name,
+				value: secrets.value(cookie.value),
+				url: secrets.url(cookie.destination),
+				httpOnly: cookie.http_only,
+				secure: cookie.secure,
+				sameSite: cookie.same_site
+			})));
+		};
+		blockAttachedServiceWorkers = async (page) => {
+			const controller = await page.evaluate("Boolean(navigator.serviceWorker?.controller)");
+			if (controller) throw new BrowserObservationError(OPERATION, "target_not_allowed");
+			const blockRegistration = `(() => {
+    if (!("serviceWorker" in navigator)) return;
+    void navigator.serviceWorker.getRegistrations()
+      .then((registrations) => Promise.all(registrations.map((item) => item.unregister())));
+    Object.defineProperty(ServiceWorkerContainer.prototype, "register", {
+      configurable: false,
+      value: () => Promise.reject(new Error("service workers are blocked by scenario policy"))
+    });
+  })()`;
+			await page.addInitScript(blockRegistration);
+			await page.evaluate(blockRegistration);
+		};
+		initializePage = async (context, page, scenario, secrets) => {
+			context.setDefaultTimeout(0);
+			context.setDefaultNavigationTimeout(0);
+			if (scenario.browser.mode === "connect") await blockAttachedServiceWorkers(page);
+			await installCookies(context, scenario, secrets);
+		};
+		PlaywrightScenarioSession = class PlaywrightScenarioSession {
+			opened;
+			mode;
+			processOwnership;
+			product = "Chromium";
+			version;
+			initialUrl;
+			secrets;
+			eventCapture;
+			storage;
+			signal;
+			#storageReleased = false;
+			constructor(opened, options) {
+				this.opened = opened;
+				this.mode = options.mode;
+				this.processOwnership = options.mode === "launch" ? "provider-owned" : "external";
+				this.secrets = options.secrets;
+				this.eventCapture = options.eventCapture;
+				this.storage = options.storage;
+				this.signal = options.signal;
+				this.version = opened.browser.version();
+				this.initialUrl = opened.page.url();
+			}
+			static async open(scenario, environment, options) {
+				throwIfScenarioCancelled(options.signal);
+				const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
+				if (secrets === undefined) throw new BrowserObservationError(OPERATION, "secret_unavailable");
+				const startedAt = Date.now();
+				const opening = openPlaywrightScenarioBrowser(scenario, environment, {
+					signal: options.signal,
+					...options.retainCleanup === undefined ? {} : { retainCleanup: options.retainCleanup }
+				});
+				let opened;
+				try {
+					opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
+				} catch (cause) {
+					const lateCleanup = () => opening.then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal), () => undefined);
+					options.retainCleanup?.(() => withPlaywrightExecutionBoundary(lateCleanup, 1e3));
+					void lateCleanup().catch((cleanupCause) => {
+						void cleanupCause;
+					});
+					throw cause;
+				}
+				const session = await this.initializeSession(opened, scenario, secrets, options);
+				try {
+					await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
+						waitUntil: "load",
+						timeout: 0
+					}), undefined, options.signal);
+					await withPlaywrightExecutionBoundary(() => session.storage?.settle() ?? Promise.resolve(), undefined, options.signal);
+					return session;
+				} catch (cause) {
+					let cleanup;
+					let cleanupFailure;
+					try {
+						cleanup = await session.close(true);
+					} catch (failure) {
+						cleanup = "incomplete";
+						cleanupFailure = { cause: failure };
+						options.retainCleanup?.(() => session.close());
+					}
+					throw browserScenarioOperationFailure(cause, {
+						kind: "browser-scenario-observation",
+						capture: browserScenarioCaptureData({
+							session,
+							scenario,
+							startedAt,
+							steps: [],
+							cleanup,
+							limitations: ["Scenario navigation failed before the initial state was captured."]
+						})
+					}, cleanupFailure);
+				}
+			}
+			static async initializeSession(opened, scenario, secrets, options) {
+				let events;
+				let storage;
+				try {
+					await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
+					storage = await PlaywrightScenarioStorage.create(opened, scenario, secrets, {
+						...options.signal === undefined ? {} : { signal: options.signal },
+						...options.retainCleanup === undefined ? {} : { retainCleanup: options.retainCleanup }
+					});
+					await storage?.initialize(opened.page, opened.context);
+					throwIfScenarioCancelled(options.signal);
+					events = new PlaywrightScenarioEvents({
+						page: opened.page,
+						context: opened.context,
+						ownsContext: scenario.browser.mode === "launch",
+						enabled: new Set(scenario.capture.events),
+						secrets,
+						network: scenario.capture.network,
+						...options.signal === undefined ? {} : { signal: options.signal }
+					});
+					return new PlaywrightScenarioSession(opened, {
+						mode: scenario.browser.mode,
+						secrets,
+						eventCapture: events,
+						storage,
+						signal: options.signal
+					});
+				} catch (cause) {
+					let storageReleased = false;
+					const cleanup = async () => {
+						let storageFailure;
+						let browserFailure;
+						if (!storageReleased) {
+							try {
+								await storage?.close(options.signal?.aborted === true);
+							} catch (failure) {
+								storageFailure = { cause: failure };
+							}
+						}
+						try {
+							await opened.cleanup.close(events === undefined ? undefined : () => events?.finish() ?? Promise.resolve(), options.signal);
+						} catch (failure) {
+							browserFailure = { cause: failure };
+						}
+						if (opened.cleanup.browserClosed) storageReleased = true;
+						throwCleanupFailures([...storageReleased || storageFailure === undefined ? [] : [storageFailure.cause], ...browserFailure === undefined ? [] : [browserFailure.cause]]);
+					};
+					try {
+						return await failBrowserScenarioOperation(cleanup, cause);
+					} catch (failure) {
+						if (failure !== cause) options.retainCleanup?.(cleanup);
+						throw failure;
+					}
+				}
+			}
+			currentUrl() {
+				return this.opened.page.url();
+			}
+			sanitizeUrl(value) {
+				return this.secrets.sanitizeUrl(value);
+			}
+			setStep(index) {
+				this.eventCapture.setStep(index);
+			}
+			nextEventSequence() {
+				return this.eventCapture.nextSequence();
+			}
+			lastEventSequence() {
+				return this.eventCapture.lastSequence();
+			}
+			events() {
+				return this.eventCapture.result();
+			}
+			/** Preserve event coverage gaps for the aggregate capture's completeness. */
+			eventLimitations() {
+				return this.eventCapture.limitations();
+			}
+			async perform(action, signal) {
+				await withPlaywrightExecutionBoundary(() => performPlaywrightScenarioAction({
+					page: this.opened.page,
+					action,
+					secrets: this.secrets
+				}), "timeout_ms" in action ? action.timeout_ms : undefined, signal);
+				await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
+			}
+			async capture(requested, signal) {
+				await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
+				return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
+					context: this.opened.context,
+					page: this.opened.page,
+					secrets: this.secrets,
+					requested
+				}), undefined, signal);
+			}
+			async close(stopLoading = this.signal?.aborted === true) {
+				let storageFailure;
+				let browserFailure;
+				if (!this.#storageReleased) {
+					try {
+						await this.storage?.close(stopLoading);
+					} catch (failure) {
+						storageFailure = { cause: failure };
+					}
+				}
+				try {
+					await this.opened.cleanup.close(() => this.eventCapture.finish());
+				} catch (failure) {
+					browserFailure = { cause: failure };
+				}
+				if (this.opened.cleanup.browserClosed) this.#storageReleased = true;
+				throwCleanupFailures([...this.#storageReleased || storageFailure === undefined ? [] : [storageFailure.cause], ...browserFailure === undefined ? [] : [browserFailure.cause]]);
+				return this.mode === "launch" ? "terminated-owned-process" : "disconnected-external";
+			}
+			redactError(error) {
+				return this.secrets.redact(error instanceof Error ? error.message : "browser action failed");
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/composition/browserScenario.js
+var createBrowserScenarioProvider;
+function init_browserScenario() {
+	return (init_browserScenario = __esmMin((() => {
+		init_PlaywrightBrowserScenarioProvider();
+		init_PlaywrightScenarioSession();
+		createBrowserScenarioProvider = (environment) => new PlaywrightBrowserScenarioProvider((scenario, options) => PlaywrightScenarioSession.open(scenario, environment, options));
+	})))();
+}
+
+//#endregion
+init_browserScenario();
+export { createBrowserScenarioProvider };