@effect-agent/platform-cloudflare 0.1.0-beta.13 → 0.1.0-beta.131

package/dist/BrowserSession-DP6b-cpL.d.mts

@@ -0,0 +1,125 @@
+import { BrowserCredentialAccess, CredentialFillError, CredentialFillResult, FillCredentialRequest } from "./BrowserCredentials.mjs";
+import { A as BrowserRunSessionLifecycle, O as BrowserRunCleanupError, _ as BrowserRunLiveViewRequest, i as BrowserRunHandoffState, k as BrowserRunLifecycleOptions, n as BrowserRunHandoffRequest, r as BrowserRunHandoffResult, v as BrowserRunLiveViewResult } from "./InteractiveBrowser-BnqY_Y-F.mjs";
+import { Cause, Context, Effect, ErrorReporter, Layer, Redacted, Schema, Scope } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { Browser, Page } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+//#region src/internal/browser-failure.d.ts
+declare const BrowserRunFailure_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "BrowserRunFailure";
+} & Readonly<A>;
+/** Source-authored stages and classifications only; never retain SDK text or session capabilities. */
+declare class BrowserRunFailure extends BrowserRunFailure_base<{
+  readonly operation: string;
+  readonly reason: "provider" | "timeout" | "malformed" | "configuration" | "authorization" | "rate-limited" | "pending";
+  readonly status?: number;
+  readonly cause?: BrowserRunFailure | {
+    readonly name: string;
+  };
+}> {
+  readonly [ErrorReporter.severity]: "Error";
+}
+//#endregion
+//#region src/internal/browser-binding.d.ts
+/** Private attachment ownership is available before asynchronous SDK initialization completes. */
+interface BrowserRunAttachment {
+  readonly browser: Promise<Browser>;
+  /** Fence SDK dispatch/callbacks and await local socket closure; never terminate the provider. */
+  readonly retire: Effect.Effect<void, BrowserRunFailure>;
+}
+declare const BrowserRunBinding_base: Context.ServiceClass<BrowserRunBinding, "@effect-agent/platform-cloudflare/internal/BrowserRunBinding", {
+  readonly acquire: (keepAliveMillis: number, operation: "interactive.acquire" | "session.acquire") => Promise<string>;
+  readonly connect: (sessionId: string, operation: string, signal?: AbortSignal) => BrowserRunAttachment;
+  readonly keepAlive: (sessionId: string) => Effect.Effect<void, BrowserRunFailure>;
+}>;
+/** Native transport port shared by both scoped adapters; the Layer owns the foreign binding. */
+declare class BrowserRunBinding extends BrowserRunBinding_base {
+  static layer(browser: Pick<BrowserRun, "fetch">): Layer.Layer<BrowserRunBinding, never, never>;
+}
+//#endregion
+//#region src/internal/browser-readonly-live-view.d.ts
+declare const BrowserRunReadonlyLiveView_base: Context.ServiceClass<BrowserRunReadonlyLiveView, "@effect-agent/platform-cloudflare/internal/BrowserRunReadonlyLiveView", {
+  readonly mint: (sessionId: Redacted.Redacted<string>, targetId: Redacted.Redacted<string>, request: BrowserRunLiveViewRequest) => Effect.Effect<BrowserRunLiveViewResult, BrowserRunFailure>;
+}>;
+/** Only the REST endpoint can mint provider-enforced read-only connections. */
+declare class BrowserRunReadonlyLiveView extends BrowserRunReadonlyLiveView_base {
+  static layer(options: BrowserRunLifecycleOptions): Layer.Layer<BrowserRunReadonlyLiveView, never, HttpClient.HttpClient>;
+}
+declare namespace BrowserSession_d_exports {
+  export { BrowserRunHandoffRequest, BrowserRunHandoffResult, BrowserRunHandoffState, BrowserRunLiveViewRequest, BrowserRunLiveViewResult, BrowserSession, BrowserSessionError, BrowserSessionOptions, BrowserSessionReference, BrowserSessions, BrowserSessionsOptions };
+}
+declare const BrowserSessionReference_base: Schema.Class<BrowserSessionReference, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly sessionId: Schema.Redacted<Schema.String>;
+  readonly contextId: Schema.Redacted<Schema.NonEmptyString>;
+  readonly targetId: Schema.Redacted<Schema.NonEmptyString>;
+  readonly expiresAt: Schema.Int;
+  readonly commandTimeoutMillis: Schema.Int;
+}>, {}>;
+/** Private host record, not a model capability. Persist together with the owner's controller state. */
+declare class BrowserSessionReference extends BrowserSessionReference_base {}
+declare const BrowserSessionOptions_base: Schema.Class<BrowserSessionOptions, Schema.Struct<{
+  readonly maxElapsedMillis: Schema.Int;
+  readonly keepAliveMillis: Schema.optionalKey<Schema.Int>;
+  readonly commandTimeoutMillis: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+declare class BrowserSessionOptions extends BrowserSessionOptions_base {}
+declare const BrowserSessionError_base: Schema.Class<BrowserSessionError, Schema.TaggedStruct<"BrowserSessionError", {
+  readonly reason: Schema.Literals<readonly ["invalid", "expired", "missing-page", "busy", "closed", "provider", "timeout", "cleanup"]>;
+  readonly dispatch: Schema.Literals<readonly ["not-dispatched", "possibly-dispatched"]>;
+  readonly cleanup: Schema.Literals<readonly ["not-requested", "confirmed", "unconfirmed"]>;
+}>, Cause.YieldableError>;
+/** No SDK text, selectors, page data, or credential values are retained in public failures. */
+declare class BrowserSessionError extends BrowserSessionError_base {}
+/**
+ * One local attachment to an application-owned browser. Scope release disconnects; it never
+ * transfers ownership or closes a healthy remote session. The owner serializes attachments,
+ * fences old attempts, authorizes human access, and calls BrowserSessions.close on expiry/stop.
+ * Native callbacks are trusted host code: never retain SDK handles or start unawaited work.
+ */
+interface BrowserSession {
+  readonly reference: BrowserSessionReference;
+  /**
+   * Check current authority under the lock before native dispatch. A settled SDK rejection leaves
+   * the session available for inspection, but may have changed the website; never retry blindly.
+   * Timeout/interruption fences outstanding SDK work and terminates the exact browser.
+   */
+  readonly run: <A, E, R>(authorize: Effect.Effect<void, E, R>, action: (page: Page) => Promise<A>) => Effect.Effect<A, E | BrowserSessionError, R>;
+  /**
+   * Resolves host-owned material under fresh credential grants. Never submits or retries a write.
+   * Credential timeouts retain acknowledged writes and dispatch evidence alongside cleanup.
+   */
+  readonly fillCredential: (request: FillCredentialRequest) => Effect.Effect<CredentialFillResult, CredentialFillError | BrowserSessionError, BrowserCredentialAccess>;
+  readonly handoff: <E, R>(authorize: Effect.Effect<void, E, R>, request: BrowserRunHandoffRequest) => Effect.Effect<BrowserRunHandoffResult, E | BrowserSessionError, R>;
+  readonly getLiveView: <E, R>(authorize: Effect.Effect<void, E, R>, request: BrowserRunLiveViewRequest) => Effect.Effect<BrowserRunLiveViewResult, E | BrowserSessionError, R>;
+  /**
+   * Mint a provider-enforced read-only connection to this exact page. Requires REST credentials;
+   * missing read-only confirmation fails closed, never falling back to an interactive URL.
+   * Expiry limits new connections, not established connections or access to visible page data.
+   */
+  readonly getReadOnlyLiveView: <E, R>(authorize: Effect.Effect<void, E, R>, request: BrowserRunLiveViewRequest) => Effect.Effect<BrowserRunLiveViewResult, E | BrowserSessionError, R>;
+  readonly getHandoffState: <E, R>(authorize: Effect.Effect<void, E, R>) => Effect.Effect<BrowserRunHandoffState, E | BrowserSessionError, R>;
+}
+interface BrowserSessionsOptions extends BrowserRunLifecycleOptions {
+  readonly browser: Pick<BrowserRun, "fetch">;
+}
+declare const BrowserSessions_base: Context.ServiceClass<BrowserSessions, "@effect-agent/platform-cloudflare/BrowserSessions", {
+  /**
+   * Allocate once and commit its private reference in retain. Failed/uncommitted creation closes
+   * the allocation. After retain succeeds the application owns remote cleanup, independent of
+   * attempt Scopes. A lost allocation reply can remain indeterminate until provider idle expiry.
+   */
+  readonly create: <E, R>(options: BrowserSessionOptions, retain: (reference: BrowserSessionReference) => Effect.Effect<void, E, R>) => Effect.Effect<BrowserSessionReference, E | BrowserSessionError, R>;
+  /** Attach only the exact saved context/page. Never recreate missing/expired state. */
+  readonly attach: (reference: BrowserSessionReference) => Effect.Effect<BrowserSession, BrowserSessionError, Scope.Scope>;
+  /** Refresh provider inactivity only; the owner must still enforce its expiresAt. */
+  readonly keepAlive: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, BrowserSessionError>;
+  readonly close: (sessionId: Redacted.Redacted<string>) => Effect.Effect<void, BrowserSessionError>;
+}>;
+/** Native Cloudflare sessions; no framework browser workflow, checkpoint transfer, or observation policy. */
+declare class BrowserSessions extends BrowserSessions_base {
+  static readonly layerNoDeps: Layer.Layer<BrowserSessions, never, BrowserRunBinding | BrowserRunReadonlyLiveView | BrowserRunSessionLifecycle>;
+  static layer(options: BrowserSessionsOptions): Layer.Layer<BrowserSessions, BrowserRunCleanupError, import("effect/unstable/http/HttpClient").HttpClient>;
+}
+//#endregion
+export { BrowserSession_d_exports as a, BrowserSessionReference as i, BrowserSessionError as n, BrowserSessions as o, BrowserSessionOptions as r, BrowserSessionsOptions as s, BrowserSession as t };
+//# sourceMappingURL=BrowserSession-DP6b-cpL.d.mts.map

package/dist/BrowserSession-DWoRC_iM.mjs

@@ -0,0 +1,505 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { BrowserCredentialAccess, CardCredential, CredentialFillError, CredentialFillResult, CredentialOrigin, CredentialTarget, FillCredentialRequest, LoginCredential } from "./BrowserCredentials.mjs";
+import { C as reportedBrowserError, S as reportBrowserCause, b as BrowserRunFailure, c as BrowserRunLiveViewResult, n as BrowserRunHandoffResult, r as BrowserRunHandoffState, s as BrowserRunLiveViewRequest, t as BrowserRunHandoffRequest, v as BrowserRunSessionLifecycle, x as browserFailure, y as BrowserRunBinding } from "./InteractiveBrowser-CxFT-Nwm.mjs";
+import { Cause, Clock, Context, Effect, Exit, Layer, Redacted, Schema, Scope, Semaphore, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+//#region src/internal/browser-credentials.ts
+/** Supplied only under the attachment lock, with the remaining command/session budget. */
+var BrowserSessionPage = class extends Context.Service()("@effect-agent/platform-cloudflare/internal/BrowserSessionPage") {};
+const TargetReply = Schema.Union([Schema.Struct({ action: Schema.String.check(Schema.isMaxLength(2048)) }), Schema.Struct({ reason: Schema.Literals(["stale-target", "unsupported"]) })]);
+const WriteReply = Schema.Literals([
+	"filled",
+	"stale-target",
+	"unsupported-before-write",
+	"unsupported"
+]);
+const prepareFields = `(() => {
+  const doc = document;
+  let fields = [];
+  let form;
+  let snapshots = [];
+  const describe = el => {
+    if (!el || !el.isConnected || el.ownerDocument !== doc || doc !== document) return null;
+    const native = el instanceof HTMLTextAreaElement ||
+      (el instanceof HTMLSelectElement && !el.multiple) ||
+      (el instanceof HTMLInputElement && ['text','email','password','tel','number','month','search','url','date','time','week','datetime-local'].includes(el.type));
+    if (!native || el.matches(':disabled') || el.readOnly || !el.form) return null;
+    const values = [el.form.action, el.form.method, el.form.enctype, el.name, el.type, el.autocomplete ?? ''];
+    if (values.some(value => value.length > 2048)) return null;
+    return JSON.stringify(values);
+  };
+  const validate = () => fields.length > 0 && fields.every((el, index) =>
+    el.form === form && describe(el) !== null && describe(el) === snapshots[index]);
+  return {
+    prepare(selectors) {
+      try {
+        fields = selectors.map(selector => {
+          const matches = doc.querySelectorAll(selector);
+          return matches.length === 1 ? matches[0] : null;
+        });
+      } catch { return {reason: 'stale-target'}; }
+      if (fields.some(el => !el) || new Set(fields).size !== fields.length) return {reason: 'stale-target'};
+      snapshots = fields.map(describe);
+      form = fields[0].form;
+      if (!form || snapshots.some(value => value === null) || fields.some(el => el.form !== form)) return {reason: 'unsupported'};
+      return {action: form.action};
+    },
+    target() { return validate() ? {action: form.action} : {reason: 'stale-target'}; },
+    fill(index, value) {
+      if (!validate()) return 'stale-target';
+      const el = fields[index];
+      if (el instanceof HTMLSelectElement) {
+        const options = [...el.options].filter(option => option.value === value);
+        if (options.length !== 1 || options[0].matches(':disabled')) return 'unsupported-before-write';
+      }
+      let prototype = Object.getPrototypeOf(el);
+      let setter;
+      while (prototype && !setter) { setter = Object.getOwnPropertyDescriptor(prototype, 'value')?.set; prototype = Object.getPrototypeOf(prototype); }
+      if (!setter) return 'unsupported-before-write';
+      setter.call(el, value);
+      if (el.value !== value) return 'unsupported';
+      el.dispatchEvent(new Event('input', {bubbles: true}));
+      el.dispatchEvent(new Event('change', {bubbles: true}));
+      return 'filled';
+    }
+  };
+})()`;
+const secretFor = (material, role) => {
+	if (material._tag === "LoginCredential") return role === "username" ? material.username : role === "password" ? material.password : void 0;
+	switch (role) {
+		case "card-name": return material.name;
+		case "card-number": return material.number;
+		case "card-expiry": return material.expiry;
+		case "card-expiry-month": return material.expiryMonth;
+		case "card-expiry-year": return material.expiryYear;
+		case "card-security-code": return material.securityCode;
+		case "username":
+		case "password": return;
+	}
+};
+/**
+* Fill explicit native fields on an existing page without submitting. The owning browser session
+* serializes operations and closes on timeout, interruption or uncertain dispatch; this function releases
+* only its local handles. Ordinary native observations remain available, including credential echoes.
+*/
+const fillCredential = Effect.fnUntraced(function* (input) {
+	const { page, commandTimeoutMillis } = yield* BrowserSessionPage;
+	let dispatch = "not-dispatched";
+	let filled = 0;
+	const fail = (reason) => new CredentialFillError({
+		reason,
+		dispatch,
+		filled,
+		cleanup: "not-requested"
+	});
+	const remote = (run) => Effect.tryPromise({
+		try: async (signal) => {
+			try {
+				return {
+					ok: true,
+					value: await run(signal)
+				};
+			} catch {
+				return { ok: false };
+			}
+		},
+		catch: () => fail("provider")
+	}).pipe(Effect.flatMap((result) => result.ok ? Effect.succeed(result.value) : Effect.fail(fail("provider"))));
+	const release = (handles) => Effect.promise(async () => {
+		await Promise.all(handles.map((handle) => handle.dispose().catch(() => {})));
+	}).pipe(Effect.interruptible, Effect.timeoutOption("1 second"), Effect.asVoid);
+	const acquire = (run) => Effect.acquireRelease(remote(async (signal) => {
+		const handles = await run();
+		if (signal.aborted) {
+			await Promise.all(handles.map((handle) => handle.dispose().catch(() => {})));
+			throw fail("provider");
+		}
+		return handles;
+	}).pipe(Effect.interruptible), release);
+	const origin = (value) => Effect.try({
+		try: () => {
+			const url = new URL(value);
+			if (url.username || url.password) throw fail("denied");
+			return url.origin;
+		},
+		catch: () => fail("denied")
+	}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(CredentialOrigin)), Effect.mapError(() => fail("denied")));
+	return yield* Effect.gen(function* () {
+		const request = yield* Schema.decodeEffect(FillCredentialRequest, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => fail("denied")));
+		const roles = request.fields.map((field) => field.role);
+		if (new Set(roles).size !== roles.length || roles.some((role) => request.kind === "login" !== (role === "username" || role === "password"))) return yield* fail("denied");
+		const access = yield* BrowserCredentialAccess;
+		let frame = page.mainFrame();
+		for (const selector of request.frame ?? []) {
+			const matches = yield* acquire(() => frame.$$(selector));
+			const element = matches[0];
+			if (matches.length !== 1 || element === void 0) return yield* fail("stale-target");
+			const child = yield* remote(() => element.contentFrame());
+			if (child === null) return yield* fail("unsupported");
+			frame = child;
+		}
+		const held = (yield* acquire(async () => [await frame.isolatedRealm().evaluateHandle(prepareFields)]))[0];
+		if (held === void 0) return yield* fail("provider");
+		const inspect = (raw) => Schema.decodeUnknownEffect(TargetReply)(raw).pipe(Effect.mapError(() => fail("provider")), Effect.flatMap((reply) => "reason" in reply ? Effect.fail(fail(reply.reason)) : Effect.succeed(reply.action)));
+		const action = yield* remote(() => held.evaluate((state, selectors) => {
+			if (typeof state !== "object" || state === null) return null;
+			return Reflect.apply(Reflect.get(state, "prepare"), state, [selectors]);
+		}, request.fields.map((field) => field.selector))).pipe(Effect.flatMap(inspect));
+		const target = CredentialTarget.make({
+			topOrigin: yield* origin(page.url()),
+			frameOrigin: yield* origin(frame.url()),
+			recipientOrigin: yield* origin(action)
+		});
+		const authorization = {
+			credential: request.credential,
+			kind: request.kind,
+			target,
+			roles
+		};
+		const authorize = Effect.suspend(() => access.authorize(authorization)).pipe(Effect.mapError((error) => fail(error.reason)));
+		const validate = Effect.gen(function* () {
+			if (frame.detached || (yield* origin(page.url())) !== target.topOrigin || (yield* origin(frame.url())) !== target.frameOrigin) return yield* fail("stale-target");
+			const current = yield* remote(() => held.evaluate((state) => {
+				if (typeof state !== "object" || state === null) return null;
+				return Reflect.apply(Reflect.get(state, "target"), state, []);
+			})).pipe(Effect.flatMap(inspect));
+			if ((yield* origin(current)) !== target.recipientOrigin) return yield* fail("stale-target");
+		});
+		yield* authorize;
+		yield* validate;
+		const raw = yield* access.resolve(authorization).pipe(Effect.mapError((error) => fail(error.reason)));
+		const material = yield* Schema.decodeEffect(request.kind === "login" ? LoginCredential : CardCredential)(raw).pipe(Effect.mapError(() => fail("resolver")));
+		for (const role of roles) if (secretFor(material, role) === void 0) return yield* fail("missing-credential");
+		for (const [index, role] of roles.entries()) {
+			yield* authorize;
+			yield* validate;
+			const value = secretFor(material, role);
+			if (value === void 0) return yield* fail("missing-credential");
+			const previous = dispatch;
+			const result = yield* remote((signal) => {
+				if (signal.aborted) return Promise.reject(fail("provider"));
+				dispatch = "possibly-dispatched";
+				return held.evaluate((state, field, secret) => {
+					if (typeof state !== "object" || state === null) return "stale-target";
+					return Reflect.apply(Reflect.get(state, "fill"), state, [field, secret]);
+				}, index, Redacted.value(value));
+			}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(WriteReply)), Effect.mapError(() => fail("provider")));
+			if (result === "stale-target" || result === "unsupported-before-write") {
+				dispatch = previous;
+				return yield* fail(result === "stale-target" ? "stale-target" : "unsupported");
+			}
+			if (result === "unsupported") return yield* fail("unsupported");
+			dispatch = "dispatched";
+			filled++;
+		}
+		return CredentialFillResult.make({
+			dispatch: "dispatched",
+			filled
+		});
+	}).pipe(Effect.scoped, Effect.timeoutOrElse({
+		duration: commandTimeoutMillis,
+		orElse: () => Effect.fail(fail("timeout"))
+	}), Effect.catchCause((cause) => {
+		if (Cause.hasInterrupts(cause)) return Effect.interrupt;
+		if (cause.reasons.some((reason) => reason._tag === "Die" || reason._tag === "Fail" && !Schema.is(CredentialFillError)(reason.error))) return Effect.fail(fail("provider"));
+		const expected = cause.reasons.find((reason) => reason._tag === "Fail" && Schema.is(CredentialFillError)(reason.error));
+		return Effect.fail(fail(expected?._tag === "Fail" && Schema.is(CredentialFillError)(expected.error) ? expected.error.reason : "provider"));
+	}), Effect.withTracerEnabled(false));
+});
+//#endregion
+//#region src/internal/browser-readonly-live-view.ts
+const Identity = Schema.Struct({
+	sessionId: Schema.String.check(Schema.isUUID()),
+	targetId: Schema.NonEmptyString.check(Schema.isMaxLength(256))
+});
+const Reply = Schema.fromJsonString(Schema.Struct({
+	id: Identity.fields.targetId,
+	options: Schema.Struct({
+		mode: Schema.Literal("tab"),
+		guardrails: Schema.Struct({ mode: Schema.Literal("readonly") })
+	}),
+	devtoolsFrontendUrl: Schema.String
+}));
+const operation = "session.readonlyLiveView";
+/** Only the REST endpoint can mint provider-enforced read-only connections. */
+var BrowserRunReadonlyLiveView = class extends Context.Service()("@effect-agent/platform-cloudflare/internal/BrowserRunReadonlyLiveView") {
+	static layer(options) {
+		return Layer.effect(this, Effect.gen(function* () {
+			const client = yield* HttpClient.HttpClient;
+			return { mint: Effect.fnUntraced(function* (sessionId, targetId, request) {
+				const identity = yield* Schema.decodeEffect(Identity)({
+					sessionId: Redacted.value(sessionId),
+					targetId: Redacted.value(targetId)
+				});
+				const input = yield* Schema.decodeEffect(BrowserRunLiveViewRequest)(request);
+				const response = yield* client.execute(HttpClientRequest.post(`https://api.cloudflare.com/client/v4/accounts/${options.accountId}/browser-rendering/devtools/browser/${identity.sessionId}/live_view`).pipe(HttpClientRequest.bearerToken(options.apiToken), HttpClientRequest.bodyJsonUnsafe({
+					mode: input.mode,
+					expiresInMs: input.expiresInMs,
+					targetId: identity.targetId,
+					guardrails: { mode: "readonly" }
+				}))).pipe(Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }));
+				if (response.status !== 200) return yield* new BrowserRunFailure({
+					operation,
+					reason: "provider",
+					status: response.status
+				});
+				const bytes = yield* Stream.runFoldEffect(response.stream, () => /* @__PURE__ */ new Uint8Array(), (body, chunk) => {
+					if (body.byteLength + chunk.byteLength > 16384) return Effect.fail(new BrowserRunFailure({
+						operation,
+						reason: "malformed"
+					}));
+					const combined = new Uint8Array(body.byteLength + chunk.byteLength);
+					combined.set(body);
+					combined.set(chunk, body.byteLength);
+					return Effect.succeed(combined);
+				});
+				const reply = yield* Schema.decodeEffect(Reply)(new TextDecoder().decode(bytes));
+				if (reply.id !== identity.targetId) return yield* new BrowserRunFailure({
+					operation,
+					reason: "malformed"
+				});
+				return yield* Schema.decodeEffect(BrowserRunLiveViewResult)({ devtoolsFrontendUrl: Redacted.make(reply.devtoolsFrontendUrl) });
+			}, Effect.mapError((cause) => browserFailure(operation, cause)), Effect.withTracerEnabled(false)) };
+		}));
+	}
+};
+//#endregion
+//#region src/BrowserSession.ts
+var BrowserSession_exports = /* @__PURE__ */ __exportAll({
+	BrowserRunHandoffRequest: () => BrowserRunHandoffRequest,
+	BrowserRunHandoffResult: () => BrowserRunHandoffResult,
+	BrowserRunHandoffState: () => BrowserRunHandoffState,
+	BrowserRunLiveViewRequest: () => BrowserRunLiveViewRequest,
+	BrowserRunLiveViewResult: () => BrowserRunLiveViewResult,
+	BrowserSessionError: () => BrowserSessionError,
+	BrowserSessionOptions: () => BrowserSessionOptions,
+	BrowserSessionReference: () => BrowserSessionReference,
+	BrowserSessions: () => BrowserSessions
+});
+const PositiveMillis = Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER));
+const SessionId = Schema.Redacted(Schema.String.check(Schema.isUUID()));
+const ProviderId = Schema.Redacted(Schema.NonEmptyString.check(Schema.isMaxLength(256)));
+/** Private host record, not a model capability. Persist together with the owner's controller state. */
+var BrowserSessionReference = class extends Schema.Class("BrowserSessionReference")({
+	version: Schema.Literal(1),
+	sessionId: SessionId,
+	contextId: ProviderId,
+	targetId: ProviderId,
+	expiresAt: PositiveMillis,
+	commandTimeoutMillis: PositiveMillis
+}) {};
+var BrowserSessionOptions = class extends Schema.Class("BrowserSessionOptions")({
+	maxElapsedMillis: PositiveMillis,
+	keepAliveMillis: Schema.optionalKey(PositiveMillis.check(Schema.isLessThanOrEqualTo(6e5))),
+	commandTimeoutMillis: Schema.optionalKey(PositiveMillis)
+}) {};
+/** No SDK text, selectors, page data, or credential values are retained in public failures. */
+var BrowserSessionError = class extends Schema.TaggedError()("BrowserSessionError", {
+	reason: Schema.Literals([
+		"invalid",
+		"expired",
+		"missing-page",
+		"busy",
+		"closed",
+		"provider",
+		"timeout",
+		"cleanup"
+	]),
+	dispatch: Schema.Literals(["not-dispatched", "possibly-dispatched"]),
+	cleanup: Schema.Literals([
+		"not-requested",
+		"confirmed",
+		"unconfirmed"
+	])
+}) {};
+const failure = (reason, dispatch = "not-dispatched", cleanup = "not-requested") => new BrowserSessionError({
+	reason,
+	dispatch,
+	cleanup
+});
+const decode = (schema, input) => Schema.decodeUnknownEffect(schema, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => failure("invalid")));
+const native = Effect.fnUntraced(function* (operation, action) {
+	const runReport = Effect.runPromiseWith(yield* Effect.context());
+	return yield* Effect.tryPromise({
+		try: async (signal) => {
+			try {
+				return {
+					ok: true,
+					value: await action(signal)
+				};
+			} catch (cause) {
+				if (!signal.aborted || cause !== signal.reason) await runReport(reportBrowserCause(operation, Cause.fail(cause)));
+				return { ok: false };
+			}
+		},
+		catch: () => failure("provider")
+	}).pipe(Effect.flatMap((result) => result.ok ? Effect.succeed(result.value) : Effect.fail(reportedBrowserError(failure("provider")))), Effect.withTracerEnabled(false));
+});
+const targetId = (page) => native("session.target", async () => {
+	const cdp = await page.createCDPSession();
+	try {
+		return (await cdp.send("Target.getTargetInfo")).targetInfo.targetId;
+	} finally {
+		await cdp.detach();
+	}
+});
+/** Native Cloudflare sessions; no framework browser workflow, checkpoint transfer, or observation policy. */
+var BrowserSessions = class BrowserSessions extends Context.Service()("@effect-agent/platform-cloudflare/BrowserSessions") {
+	static layerNoDeps = Layer.effect(this, Effect.gen(function* () {
+		const binding = yield* BrowserRunBinding;
+		const lifecycle = yield* BrowserRunSessionLifecycle;
+		const readonlyLiveView = yield* BrowserRunReadonlyLiveView;
+		const close = (sessionId) => decode(SessionId, sessionId).pipe(Effect.flatMap((id) => lifecycle.close(id).pipe(Effect.mapError(() => failure("cleanup", "not-dispatched", "unconfirmed")))));
+		const cleanup = (sessionId) => close(sessionId).pipe(Effect.as("confirmed"), Effect.catchCause((cause) => reportBrowserCause("session.close", cause).pipe(Effect.as("unconfirmed"))));
+		const connect = Effect.fnUntraced(function* (sessionId) {
+			let attachment;
+			const retire = Effect.suspend(() => attachment === void 0 ? Effect.void : attachment.retire.pipe(Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(failure("cleanup"))
+			}), Effect.catchCause((cause) => reportBrowserCause("session.disconnect", cause).pipe(Effect.andThen(Effect.die(failure("cleanup", "not-dispatched", "unconfirmed")))))));
+			yield* Effect.addFinalizer(() => retire);
+			return {
+				browser: yield* native("session.connect", (signal) => {
+					attachment = binding.connect(Redacted.value(sessionId), "session.connect", signal);
+					return attachment.browser;
+				}),
+				retire
+			};
+		});
+		const create = (input, retain) => Effect.gen(function* () {
+			const options = yield* decode(BrowserSessionOptions, input);
+			const expiresAt = (yield* Clock.currentTimeMillis) + options.maxElapsedMillis;
+			if (!Number.isSafeInteger(expiresAt)) return yield* failure("invalid");
+			let sessionId;
+			let retained = false;
+			const runCleanup = Effect.runPromiseWith(yield* Effect.context());
+			yield* Effect.addFinalizer(() => sessionId === void 0 || retained ? Effect.void : cleanup(sessionId));
+			sessionId = yield* native("session.acquire", async (signal) => {
+				const id = Redacted.make(await binding.acquire(options.keepAliveMillis ?? 6e5, "session.acquire"));
+				if (signal.aborted) {
+					await runCleanup(cleanup(id));
+					signal.throwIfAborted();
+				}
+				return id;
+			});
+			const { browser } = yield* connect(sessionId);
+			const page = yield* native("session.page", async () => {
+				return await (await browser.createBrowserContext()).newPage();
+			});
+			const reference = yield* decode(BrowserSessionReference, {
+				version: 1,
+				sessionId,
+				contextId: Redacted.make(page.browserContext().id ?? ""),
+				targetId: Redacted.make(yield* targetId(page)),
+				expiresAt,
+				commandTimeoutMillis: options.commandTimeoutMillis ?? 3e4
+			});
+			yield* Effect.uninterruptibleMask((restore) => restore(retain(reference)).pipe(Effect.tap(() => Effect.sync(() => {
+				retained = true;
+			}))));
+			return reference;
+		}).pipe(Effect.scoped, Effect.timeoutOrElse({
+			duration: "30 seconds",
+			orElse: () => Effect.fail(failure("timeout"))
+		}), Effect.withTracerEnabled(false));
+		const attachPage = Effect.fnUntraced(function* (input) {
+			const reference = yield* decode(BrowserSessionReference, input);
+			if (reference.expiresAt <= (yield* Clock.currentTimeMillis)) return yield* failure("expired");
+			const scope = yield* Effect.scope;
+			const { browser, retire } = yield* connect(reference.sessionId);
+			const context = browser.browserContexts().find((value) => value.id === Redacted.value(reference.contextId));
+			if (context === void 0) return yield* failure("missing-page");
+			let page;
+			for (const candidate of yield* native("session.pages", () => context.pages())) if ((yield* targetId(candidate)) === Redacted.value(reference.targetId)) {
+				page = candidate;
+				break;
+			}
+			if (page === void 0) return yield* failure("missing-page");
+			const currentPage = page;
+			const lock = yield* Semaphore.make(1);
+			let invalid = false;
+			const terminate = Effect.suspend(() => {
+				invalid = true;
+				return retire.pipe(Effect.catchCause((cause) => reportBrowserCause("session.disconnect", cause)), Effect.andThen(cleanup(reference.sessionId)));
+			});
+			const runEffect = (action) => lock.withPermitsIfAvailable(1)(Effect.gen(function* () {
+				if (invalid || scope.state._tag === "Closed" || !browser.isConnected()) return yield* failure("closed");
+				const remaining = reference.expiresAt - (yield* Clock.currentTimeMillis);
+				if (remaining <= 0) return yield* failure("expired", "not-dispatched", yield* terminate);
+				return yield* action(Math.min(remaining, reference.commandTimeoutMillis)).pipe(Effect.catchDefect((defect) => reportBrowserCause("session.command", Cause.die(defect)).pipe(Effect.andThen(terminate), Effect.flatMap((closed) => Effect.fail(failure("provider", "possibly-dispatched", closed))))), Effect.onInterrupt(() => terminate));
+			})).pipe(Effect.flatMap(Effect.fromOption(() => failure("busy"))), Effect.withTracerEnabled(false));
+			const run = (authorize, action, terminateOnError = false) => runEffect((commandTimeoutMillis) => authorize.pipe(Effect.andThen(() => native("session.command", () => action(currentPage)).pipe(Effect.catch((error) => Effect.gen(function* () {
+				const closed = terminateOnError ? yield* terminate : "not-requested";
+				return yield* reportedBrowserError(failure(error.reason, "possibly-dispatched", closed));
+			})))), Effect.timeoutOrElse({
+				duration: commandTimeoutMillis,
+				orElse: () => terminate.pipe(Effect.flatMap((closed) => Effect.fail(failure("timeout", "possibly-dispatched", closed))))
+			})));
+			const command = (authorize, method, parameters, schema) => run(authorize, async (page) => {
+				const cdp = await page.createCDPSession();
+				try {
+					const result = await Reflect.apply(cdp.send, cdp, [method, parameters]);
+					return Schema.decodeUnknownSync(schema)(result);
+				} finally {
+					await cdp.detach();
+				}
+			}, method === "Cloudflare.handoff");
+			return {
+				reference,
+				run,
+				fillCredential: (request) => runEffect((commandTimeoutMillis) => fillCredential(request).pipe(Effect.provideService(BrowserSessionPage, {
+					page: currentPage,
+					commandTimeoutMillis
+				}), Effect.catchIf((error) => error.reason === "timeout" || error.dispatch === "possibly-dispatched", (error) => terminate.pipe(Effect.flatMap((cleanup) => Effect.fail(CredentialFillError.make({
+					...error,
+					cleanup
+				}))))))),
+				handoff: (authorize, request) => decode(BrowserRunHandoffRequest, request).pipe(Effect.flatMap((value) => command(authorize, "Cloudflare.handoff", {
+					instructions: value.instructions,
+					timeout: value.timeout
+				}, Schema.Struct({ handoffId: Schema.NonEmptyString.check(Schema.isMaxLength(1024)) }))), Effect.map((value) => BrowserRunHandoffResult.make({ handoffId: Redacted.make(value.handoffId) }))),
+				getLiveView: (authorize, request) => decode(BrowserRunLiveViewRequest, request).pipe(Effect.flatMap((value) => command(authorize, "Cloudflare.getLiveView", {
+					mode: value.mode,
+					expiresInMs: value.expiresInMs
+				}, Schema.Struct({ devtoolsFrontendUrl: Schema.String }))), Effect.flatMap((value) => decode(BrowserRunLiveViewResult, { devtoolsFrontendUrl: Redacted.make(value.devtoolsFrontendUrl) }))),
+				getReadOnlyLiveView: (authorize, request) => decode(BrowserRunLiveViewRequest, request).pipe(Effect.flatMap((value) => runEffect((commandTimeoutMillis) => authorize.pipe(Effect.andThen(() => readonlyLiveView.mint(reference.sessionId, reference.targetId, value).pipe(Effect.tapCause((cause) => reportBrowserCause("session.readonlyLiveView", cause)), Effect.mapError(() => reportedBrowserError(failure("provider"))))), Effect.timeoutOrElse({
+					duration: commandTimeoutMillis,
+					orElse: () => Effect.fail(failure("timeout"))
+				}))))),
+				getHandoffState: (authorize) => command(authorize, "Cloudflare.getHandoffState", {}, Schema.Struct({
+					active: Schema.Boolean,
+					handoffId: Schema.optionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(1024))),
+					durationMs: Schema.optionalKey(Schema.Natural)
+				})).pipe(Effect.map((value) => BrowserRunHandoffState.make({
+					active: value.active,
+					...value.handoffId === void 0 ? {} : { handoffId: Redacted.make(value.handoffId) },
+					...value.durationMs === void 0 ? {} : { durationMs: value.durationMs }
+				})))
+			};
+		});
+		const attach = Effect.fnUntraced(function* (input) {
+			const reference = yield* decode(BrowserSessionReference, input);
+			const scope = yield* Scope.fork(yield* Effect.scope);
+			return yield* attachPage(reference).pipe(Effect.provideService(Scope.Scope, scope), Effect.timeoutOrElse({
+				duration: reference.commandTimeoutMillis,
+				orElse: () => reportBrowserCause("session.connect", Cause.fail(failure("timeout"))).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure("timeout")))))
+			}), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void));
+		});
+		return BrowserSessions.of({
+			create,
+			attach,
+			close,
+			keepAlive: (sessionId) => decode(SessionId, sessionId).pipe(Effect.flatMap((id) => binding.keepAlive(Redacted.value(id)).pipe(Effect.timeoutOrElse({
+				duration: "10 seconds",
+				orElse: () => Effect.fail(failure("timeout"))
+			}), Effect.catch((error) => reportBrowserCause("session.keepAlive", Cause.fail(error)).pipe(Effect.andThen(Effect.fail(reportedBrowserError(failure(error.reason === "timeout" ? "timeout" : "provider")))))))), Effect.withTracerEnabled(false))
+		});
+	}));
+	static layer(options) {
+		return this.layerNoDeps.pipe(Layer.provide(BrowserRunBinding.layer(options.browser)), Layer.provide(BrowserRunSessionLifecycle.layer(options)), Layer.provide(BrowserRunReadonlyLiveView.layer(options)));
+	}
+};
+//#endregion
+export { BrowserSessions as a, BrowserSession_exports as i, BrowserSessionOptions as n, BrowserSessionReference as r, BrowserSessionError as t };
+
+//# sourceMappingURL=BrowserSession-DWoRC_iM.mjs.map