@yielded/agent-platform-cloudflare 0.1.0-beta.166 → 0.1.0-beta.168

package/dist/CloudflareThreadClient.mjs

@@ -1,382 +1,2 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { ThreadObjectNamespace, callThreadObject } from "./CloudflareBindings.mjs";
-import { AdmissionLimitExceeded } from "./CloudflareConfig.mjs";
-import { r as safeCauseMessage, t as cloudflareFailureSignals } from "./boundary-BguazVkh.mjs";
-import { n as DurableAlarmError } from "./Alarm-B0ODr1NE.mjs";
-import { Receipt } from "@yielded/agent/durable-agent-runtime";
-import { AgentId } from "@yielded/agent/identifiers";
-import { AbortCommand, AbortIntent, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionPolicyError, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, IdempotencyKey, JoinedToHost, LedgerError, Principal, Settlement, SettlementConflict, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "@yielded/agent/submission-ledger";
-import { Context, Crypto, Duration, Effect, Layer, Schema } from "effect";
-import { RpcTracing } from "effect-cf";
-import { CanonicalRecordEnvelope, CanonicalSequence, DefinitionDigests, PersistedJson, WorkerAdmission } from "@yielded/agent/records";
-import { BrowserCrypto } from "@effect/platform-browser";
-import { AgentInputError } from "@yielded/agent/agent-error";
-import { DigestError } from "@yielded/agent/digest";
-import { DurableRuntimeFailpointError } from "@yielded/agent/durable-failpoint";
-import { InputMessage } from "@yielded/agent/messaging";
-import { OperationDenied } from "@yielded/agent/operation-authorizer";
-import { SubmissionStatus } from "@yielded/agent/submission-status";
-import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadStoreError } from "@yielded/agent/thread-store";
-//#region src/CloudflareThreadClient.ts
-var CloudflareThreadClient_exports = /* @__PURE__ */ __exportAll({
-	AbortRecorded: () => AbortRecorded,
-	ApprovalRecorded: () => ApprovalRecorded,
-	AwaitProgressRequest: () => AwaitProgressRequest,
-	CancelProgressRequest: () => CancelProgressRequest,
-	CloudflareThreadClient: () => CloudflareThreadClient,
-	HostFailed: () => HostFailed,
-	HostFailure: () => HostFailure,
-	HostProtocolError: () => HostProtocolError,
-	HostResponse: () => HostResponse,
-	ObservePageRequest: () => ObservePageRequest,
-	ObservedPage: () => ObservedPage,
-	ProgressCancelled: () => ProgressCancelled,
-	ProgressObserved: () => ProgressObserved,
-	SettlementReached: () => SettlementReached,
-	SubmissionStatusResponse: () => SubmissionStatusResponse,
-	SubmitRequest: () => SubmitRequest,
-	SubmitSucceeded: () => SubmitSucceeded,
-	ThreadClientError: () => ThreadClientError,
-	UnknownResolutionRecorded: () => UnknownResolutionRecorded,
-	boundHostDiagnostic: () => boundHostDiagnostic,
-	decodeAbortCommand: () => decodeAbortCommand,
-	decodeApprovalDecisionCommand: () => decodeApprovalDecisionCommand,
-	decodeAwaitProgressRequest: () => decodeAwaitProgressRequest,
-	decodeCancelProgressRequest: () => decodeCancelProgressRequest,
-	decodeHostResponse: () => decodeHostResponse,
-	decodeObservePageRequest: () => decodeObservePageRequest,
-	decodeReceipt: () => decodeReceipt,
-	decodeSubmitRequest: () => decodeSubmitRequest,
-	decodeUnknownResolutionCommand: () => decodeUnknownResolutionCommand,
-	encodeAbortCommand: () => encodeAbortCommand,
-	encodeApprovalDecisionCommand: () => encodeApprovalDecisionCommand,
-	encodeAwaitProgressRequest: () => encodeAwaitProgressRequest,
-	encodeCancelProgressRequest: () => encodeCancelProgressRequest,
-	encodeHostResponse: () => encodeHostResponse,
-	encodeObservePageRequest: () => encodeObservePageRequest,
-	encodeReceipt: () => encodeReceipt,
-	encodeSubmitRequest: () => encodeSubmitRequest,
-	encodeUnknownResolutionCommand: () => encodeUnknownResolutionCommand
-});
-/**
-* The Worker↔Thread-Object host protocol (plan §1.4): Schema envelopes for the host
-* entry points (`submitEncoded`, `awaitSettlementEncoded`, `observePage`, `abortEncoded`,
-* `resolveApprovalEncoded`, `resolveUnknownEncoded`) plus the Worker-side client that speaks
-* it. Mirrors the WP2 port protocol: requests and responses are closed Schema unions, typed
-* failures travel as their own tagged classes and RE-DECODE to identical tags on the caller
-* (error-tag fidelity), and protocol anomalies are answered typed instead of thrown.
-*/
-/** Ceiling for host protocol diagnostic strings. */
-const MAX_HOST_DIAGNOSTIC_LENGTH = 4096;
-const PROGRESS_CANCELLATION_TIMEOUT = "1 second";
-const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_HOST_DIAGNOSTIC_LENGTH));
-/** Truncate a diagnostic string to the host protocol's bounded length. */
-const boundHostDiagnostic = (value) => value.length > MAX_HOST_DIAGNOSTIC_LENGTH ? `${value.slice(0, 4093)}...` : value;
-/**
-* The envelope itself could not be honored: the Object could not decode the request, or a
-* response could not be encoded/decoded. Never carries operation semantics.
-*/
-var HostProtocolError = class extends Schema.TaggedError()("HostProtocolError", { message: BoundedDiagnostic }) {};
-/** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
-var ThreadClientError = class extends Schema.TaggedError()("ThreadClientError", {
-	threadId: Schema.String,
-	message: Schema.String,
-	cause: Schema.optionalKey(Schema.Defect()),
-	/** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
-	retryable: Schema.optionalKey(Schema.Boolean),
-	/** Cloudflare overloads are surfaced immediately instead of adding retry pressure. */
-	overloaded: Schema.optionalKey(Schema.Boolean)
-}) {};
-/**
-* One durable submission, input ALREADY encoded by the caller through the Agent Binding's
-* input schema (the Worker bundles the same Agent definitions as the Object, so schema
-* validation happens client-side; the resolved Binding re-validates at claim time). The
-* Thread identity is deliberately absent — the addressed Object IS the lane.
-*/
-var SubmitRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/SubmitRequest")({
-	agentId: AgentId,
-	principal: Principal,
-	idempotencyKey: IdempotencyKey,
-	admissionGroup: Schema.optionalKey(AdmissionGroup),
-	admissionFence: Schema.optionalKey(AdmissionFence),
-	workerAdmission: Schema.optionalKey(WorkerAdmission),
-	messageAdmission: Schema.optionalKey(InputMessage),
-	definitions: DefinitionDigests,
-	inputPayload: PersistedJson
-}) {};
-/** One bounded page of canonical records after an optional sequence. */
-var ObservePageRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/ObservePageRequest")({
-	afterSequence: Schema.optionalKey(CanonicalSequence),
-	limit: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1024))
-}) {};
-/** One event-driven wait for canonical progress strictly after this sequence. */
-var AwaitProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/AwaitProgressRequest")({
-	afterSequence: CanonicalSequence,
-	waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256))
-}) {};
-/** Best-effort cancellation of one in-flight progress RPC. */
-var CancelProgressRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/CancelProgressRequest")({ waiterId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)) }) {};
-/**
-* Every typed failure a host entry point can produce, plus the protocol's own errors. Same
-* closed-union discipline as the WP2 `PortFailure`: members re-decode to the SAME tagged
-* classes on the Worker side; `cause` chains travel as Schema defects without instance
-* fidelity (plan §2.8).
-*/
-const HostFailure = Schema.Union([
-	AgentInputError,
-	DigestError,
-	AdmissionConflict,
-	AdmissionPolicyError,
-	SettlementConflict,
-	ApprovalConflict,
-	UnknownResolutionConflict,
-	JoinedToHost,
-	LedgerError,
-	ThreadStoreError,
-	ThreadNotMaterialized,
-	AppendConflict,
-	FenceRejected,
-	DurableRuntimeFailpointError,
-	AdmissionLimitExceeded,
-	DurableAlarmError,
-	OperationDenied,
-	HostProtocolError
-]);
-var SubmitSucceeded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SubmitSucceeded")("SubmitSucceeded", { receipt: Receipt }) {};
-var SubmissionStatusResponse = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SubmissionStatusResponse")("SubmissionStatusResponse", { status: SubmissionStatus }) {};
-var SettlementReached = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/SettlementReached")("SettlementReached", { settlement: Settlement }) {};
-var ObservedPage = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ObservedPage")("ObservedPage", { records: Schema.Array(CanonicalRecordEnvelope).check(Schema.isMaxLength(1024)) }) {};
-/** A record was already committed or an incarnation-local hint says the caller should re-read. */
-var ProgressObserved = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressObserved")("ProgressObserved", {}) {};
-var ProgressCancelled = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ProgressCancelled")("ProgressCancelled", {}) {};
-var AbortRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/AbortRecorded")("AbortRecorded", { intent: AbortIntent }) {};
-var ApprovalRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ApprovalRecorded")("ApprovalRecorded", { intent: ApprovalDecisionIntent }) {};
-var UnknownResolutionRecorded = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/UnknownResolutionRecorded")("UnknownResolutionRecorded", { intent: UnknownResolutionIntent }) {};
-/** The entry point failed TYPED on the Object; the failure re-decodes verbatim. */
-var HostFailed = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/HostFailed")("HostFailed", { failure: HostFailure }) {};
-/** The uniform answer of one host entry point. Callers narrow by the tag their call implies. */
-const HostResponse = Schema.Union([
-	SubmitSucceeded,
-	SettlementReached,
-	SubmissionStatusResponse,
-	ObservedPage,
-	ProgressObserved,
-	ProgressCancelled,
-	AbortRecorded,
-	ApprovalRecorded,
-	UnknownResolutionRecorded,
-	HostFailed
-]);
-const decodeSubmitRequest = Schema.decodeUnknownEffect(SubmitRequest);
-const encodeSubmitRequest = Schema.encodeEffect(SubmitRequest);
-const decodeReceipt = Schema.decodeUnknownEffect(Receipt);
-const encodeReceipt = Schema.encodeEffect(Receipt);
-const decodeObservePageRequest = Schema.decodeUnknownEffect(ObservePageRequest);
-const encodeObservePageRequest = Schema.encodeEffect(ObservePageRequest);
-const decodeAwaitProgressRequest = Schema.decodeUnknownEffect(AwaitProgressRequest);
-const encodeAwaitProgressRequest = Schema.encodeEffect(AwaitProgressRequest);
-const decodeCancelProgressRequest = Schema.decodeUnknownEffect(CancelProgressRequest);
-const encodeCancelProgressRequest = Schema.encodeEffect(CancelProgressRequest);
-const decodeAbortCommand = Schema.decodeUnknownEffect(AbortCommand);
-const encodeAbortCommand = Schema.encodeEffect(AbortCommand);
-const decodeApprovalDecisionCommand = Schema.decodeUnknownEffect(ApprovalDecisionCommand);
-const encodeApprovalDecisionCommand = Schema.encodeEffect(ApprovalDecisionCommand);
-const decodeUnknownResolutionCommand = Schema.decodeUnknownEffect(UnknownResolutionCommand);
-const encodeUnknownResolutionCommand = Schema.encodeEffect(UnknownResolutionCommand);
-const encodeHostResponse = Schema.encodeEffect(HostResponse);
-const decodeHostResponse = Schema.decodeUnknownEffect(HostResponse);
-/** Failure surface of `CloudflareThreadClient.submit`. */
-const ClientSubmitHostFailure = Schema.Union([
-	AgentInputError,
-	DigestError,
-	AdmissionConflict,
-	AdmissionPolicyError,
-	LedgerError,
-	ThreadStoreError,
-	ThreadNotMaterialized,
-	AppendConflict,
-	FenceRejected,
-	DurableRuntimeFailpointError,
-	AdmissionLimitExceeded,
-	DurableAlarmError,
-	HostProtocolError
-]);
-const ClientAwaitHostFailure = Schema.Union([
-	LedgerError,
-	SettlementConflict,
-	OperationDenied,
-	HostProtocolError
-]);
-const ClientObserveHostFailure = Schema.Union([
-	ThreadStoreError,
-	ThreadNotMaterialized,
-	OperationDenied,
-	HostProtocolError
-]);
-const ClientAbortHostFailure = Schema.Union([
-	OperationDenied,
-	LedgerError,
-	SettlementConflict,
-	JoinedToHost,
-	DurableRuntimeFailpointError,
-	DurableAlarmError,
-	HostProtocolError
-]);
-const ClientApprovalHostFailure = Schema.Union([
-	LedgerError,
-	SettlementConflict,
-	ApprovalConflict,
-	OperationDenied,
-	DurableAlarmError,
-	HostProtocolError
-]);
-const ClientUnknownHostFailure = Schema.Union([
-	LedgerError,
-	SettlementConflict,
-	UnknownResolutionConflict,
-	JoinedToHost,
-	DurableRuntimeFailpointError,
-	OperationDenied,
-	DurableAlarmError,
-	HostProtocolError
-]);
-const outOfContract = (threadId, operation, observed) => ThreadClientError.make({
-	threadId,
-	message: boundHostDiagnostic(`The Thread Object answered ${operation} with the out-of-contract ${observed}.`)
-});
-const hostRpcMethods = {
-	submit: "submitEncoded",
-	awaitSettlement: "awaitSettlementEncoded",
-	submissionStatus: "submissionStatusEncoded",
-	awaitProgress: "awaitProgressEncoded",
-	cancelProgress: "cancelProgressEncoded",
-	observePage: "observePage",
-	abort: "abortEncoded",
-	resolveApproval: "resolveApprovalEncoded",
-	resolveUnknown: "resolveUnknownEncoded"
-};
-/** Worker-side client over the Thread Object namespace (DEPLOY-010). */
-var CloudflareThreadClient = class CloudflareThreadClient extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareThreadClient") {
-	/**
-	* Assemble the client from a resolved namespace and the platform Crypto implementation.
-	* rpcTracing is the binding name and remains opt-in. Caller authentication, principals,
-	* idempotency keys, and definition digests are still explicit submission inputs.
-	*/
-	static layerFromBinding(options) {
-		return CloudflareThreadClient.layer.pipe(Layer.provide([ThreadObjectNamespace.layer(options.namespace, options), BrowserCrypto.layer]));
-	}
-	static layer = Layer.effect(CloudflareThreadClient)(Effect.gen(function* () {
-		const namespace = yield* ThreadObjectNamespace;
-		const { rpcTracing } = namespace;
-		const crypto = yield* Crypto.Crypto;
-		const call = Effect.fn(function* (threadId, operation, encoded) {
-			const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
-			const raw = yield* callThreadObject(threadId, (stub) => stub[hostRpcMethods[operation]](encoded, ...traceArgs), (cause) => ThreadClientError.make({
-				threadId,
-				message: boundHostDiagnostic(`${operation} did not reach the Thread Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
-				cause,
-				...cloudflareFailureSignals(cause)
-			})).pipe(Effect.provideService(ThreadObjectNamespace, namespace));
-			return yield* decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })));
-		}, (effect, threadId, operation) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflareThreadClient.call", { attributes: {
-			threadId,
-			operation
-		} }) : RpcTracing.withRpcClientSpan(effect, rpcTracing, hostRpcMethods[operation]));
-		const expect = (threadId, operation, resultSchema, failureSchema) => {
-			const isExpectedResult = Schema.is(resultSchema);
-			const isExpectedFailure = Schema.is(failureSchema);
-			return (response) => {
-				if (response._tag === "HostFailed") {
-					const failure = response.failure;
-					return isExpectedFailure(failure) ? Effect.fail(failure) : Effect.fail(outOfContract(threadId, operation, `failure ${failure._tag}`));
-				}
-				if (!isExpectedResult(response)) return Effect.fail(outOfContract(threadId, operation, `result ${response._tag}`));
-				return Effect.succeed(response);
-			};
-		};
-		const readPage = (threadId, options) => Effect.gen(function* () {
-			const request = ObservePageRequest.make({
-				...options?.afterSequence === void 0 ? {} : { afterSequence: options.afterSequence },
-				limit: options?.limit ?? 256
-			});
-			const encoded = yield* encodeObservePageRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`observePage request encode failed: ${error.message}`) })));
-			const response = yield* call(threadId, "observePage", encoded);
-			return (yield* expect(threadId, "observePage", ObservedPage, ClientObserveHostFailure)(response)).records;
-		});
-		const cancelProgress = (threadId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(threadId, "cancelProgress", encoded)), Effect.interruptible, Effect.timeout(PROGRESS_CANCELLATION_TIMEOUT), Effect.asVoid, Effect.ignore);
-		return CloudflareThreadClient.of({
-			submit: (agent, input, options) => Effect.gen(function* () {
-				const encodedInput = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
-				const inputPayload = yield* Schema.decodeUnknownEffect(PersistedJson)(encodedInput).pipe(Effect.mapError(() => AgentInputError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
-				const request = SubmitRequest.make({
-					agentId: agent.definition.id,
-					principal: options.principal,
-					idempotencyKey: options.idempotencyKey,
-					...options.admissionGroup === void 0 ? {} : { admissionGroup: options.admissionGroup },
-					...options.admissionFence === void 0 ? {} : { admissionFence: options.admissionFence },
-					...options.workerAdmission === void 0 ? {} : { workerAdmission: options.workerAdmission },
-					...options.messageAdmission === void 0 ? {} : { messageAdmission: options.messageAdmission },
-					definitions: options.definitions,
-					inputPayload
-				});
-				const encoded = yield* encodeSubmitRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`submit request encode failed: ${error.message}`) })));
-				const response = yield* call(options.threadId, "submit", encoded);
-				return (yield* expect(options.threadId, "submit", SubmitSucceeded, ClientSubmitHostFailure)(response)).receipt;
-			}),
-			submissionStatus: (receipt) => Effect.gen(function* () {
-				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError(() => HostProtocolError.make({ message: "Invalid receipt" })));
-				const response = yield* call(receipt.threadId, "submissionStatus", encoded);
-				return (yield* expect(receipt.threadId, "submissionStatus", SubmissionStatusResponse, ClientAwaitHostFailure)(response)).status;
-			}),
-			awaitSettlement: (receipt) => Effect.gen(function* () {
-				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`receipt encode failed: ${error.message}`) })));
-				const response = yield* call(receipt.threadId, "awaitSettlement", encoded);
-				return (yield* expect(receipt.threadId, "awaitSettlement", SettlementReached, ClientAwaitHostFailure)(response)).settlement;
-			}),
-			awaitProgress: (threadId, afterSequence) => Effect.gen(function* () {
-				const waiterId = yield* crypto.randomUUIDv4.pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress cancellation identity generation failed: ${error.message}`) })));
-				const request = AwaitProgressRequest.make({
-					afterSequence,
-					waiterId
-				});
-				const encoded = yield* encodeAwaitProgressRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress request encode failed: ${error.message}`) })));
-				const attempt = (retry) => call(threadId, "awaitProgress", encoded).pipe(Effect.flatMap(expect(threadId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, Effect.catchTag("ThreadClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
-				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(threadId, waiterId)));
-			}),
-			readPage,
-			readAll: (threadId) => Effect.gen(function* () {
-				const all = [];
-				let after;
-				for (;;) {
-					const page = yield* readPage(threadId, {
-						afterSequence: after,
-						limit: 1024
-					});
-					all.push(...page);
-					const last = page.at(-1);
-					if (page.length < 1024 || last === void 0) return all;
-					after = last.sequence;
-				}
-			}),
-			abort: (threadId, command) => Effect.gen(function* () {
-				const encoded = yield* encodeAbortCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`abort command encode failed: ${error.message}`) })));
-				const response = yield* call(threadId, "abort", encoded);
-				return (yield* expect(threadId, "abort", AbortRecorded, ClientAbortHostFailure)(response)).intent;
-			}),
-			resolveApproval: (threadId, command) => Effect.gen(function* () {
-				const encoded = yield* encodeApprovalDecisionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`approval command encode failed: ${error.message}`) })));
-				const response = yield* call(threadId, "resolveApproval", encoded);
-				return (yield* expect(threadId, "resolveApproval", ApprovalRecorded, ClientApprovalHostFailure)(response)).intent;
-			}),
-			resolveUnknown: (threadId, command) => Effect.gen(function* () {
-				const encoded = yield* encodeUnknownResolutionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`resolution command encode failed: ${error.message}`) })));
-				const response = yield* call(threadId, "resolveUnknown", encoded);
-				return (yield* expect(threadId, "resolveUnknown", UnknownResolutionRecorded, ClientUnknownHostFailure)(response)).intent;
-			})
-		});
-	}));
-};
-//#endregion
-export { AbortRecorded, ApprovalRecorded, AwaitProgressRequest, CancelProgressRequest, CloudflareThreadClient, HostFailed, HostFailure, HostProtocolError, HostResponse, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, SubmissionStatusResponse, SubmitRequest, SubmitSucceeded, ThreadClientError, UnknownResolutionRecorded, boundHostDiagnostic, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, CloudflareThreadClient_exports as t };
-
-//# sourceMappingURL=CloudflareThreadClient.mjs.map
+import { A as decodeSubmitRequest, B as encodeUnknownResolutionCommand, C as decodeAbortCommand, D as decodeHostResponse, E as decodeCancelProgressRequest, F as encodeCancelProgressRequest, I as encodeHostResponse, L as encodeObservePageRequest, M as encodeAbortCommand, N as encodeApprovalDecisionCommand, O as decodeObservePageRequest, P as encodeAwaitProgressRequest, R as encodeReceipt, S as boundHostDiagnostic, T as decodeAwaitProgressRequest, V as Frame, _ as SubmissionStatusResponse, a as CloudflareThreadClient, b as ThreadClientError, c as HostFailure, d as ObservePageRequest, f as ObservedPage, g as SettlementRecordReached, h as SettlementReached, i as CancelProgressRequest, j as decodeUnknownResolutionCommand, k as decodeReceipt, l as HostProtocolError, m as ProgressObserved, n as ApprovalRecorded, p as ProgressCancelled, r as AwaitProgressRequest, s as HostFailed, t as AbortRecorded, u as HostResponse, v as SubmitRequest, w as decodeApprovalDecisionCommand, x as UnknownResolutionRecorded, y as SubmitSucceeded, z as encodeSubmitRequest } from "./CloudflareThreadClient-CZm0TvUe.mjs";
+export { AbortRecorded, ApprovalRecorded, AwaitProgressRequest, CancelProgressRequest, CloudflareThreadClient, HostFailed, HostFailure, HostProtocolError, HostResponse, Frame as LiveTextFrame, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, SettlementRecordReached, SubmissionStatusResponse, SubmitRequest, SubmitSucceeded, ThreadClientError, UnknownResolutionRecorded, boundHostDiagnostic, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand };

package/dist/{InteractiveBrowser-BbG3kGA9.mjs → InteractiveBrowser-LdKzQeLR.mjs}

@@ -1,3 +1,4 @@
+import { t as pageFunction } from "./page-function-CmUCcyNP.mjs";
 import { Cause, Clock, Context, Data, Duration, Effect, ErrorReporter, Layer, Option, Predicate, Redacted, Schema, Scope, Semaphore, Stream } from "effect";
 import { PageScreenshotResult } from "@yielded/agent/page-screenshot";
 import { SandboxImplementation } from "@yielded/agent/sandbox";
@@ -296,7 +297,7 @@ const makeFileSelection = (page) => async (request, signal) => {
 		throw cause;
 	}
 	const select = async (element) => {
-		if (session === void 0) return element.evaluate(setFileSelection, encoded, request.fileName, request.mediaType);
+		if (session === void 0) return element.evaluate(pageFunction(setFileSelection), encoded, request.fileName, request.mediaType);
 		let onOpened = () => {};
 		let onAbort = () => {};
 		let timer;
@@ -370,7 +371,7 @@ var BrowserRunSessionLifecycle = class extends Context.Service()("@effect-agent/
 		return Layer.effect(this, Effect.gen(function* () {
 			if (!Schema.is(Account)(options.accountId) || Redacted.value(options.apiToken).length === 0) return yield* new BrowserRunCleanupError({ reason: "configuration" });
 			const client = yield* HttpClient.HttpClient;
-			const request = Effect.fn("BrowserRunSessionLifecycle.request")(function* (method, sessionId) {
+			const request = Effect.fnUntraced(function* (method, sessionId) {
 				const path = method === "DELETE" ? "browser" : "session";
 				const response = yield* client.execute(HttpClientRequest.make(method)(`https://api.cloudflare.com/client/v4/accounts/${options.accountId}/browser-rendering/devtools/${path}/${sessionId}`).pipe(HttpClientRequest.bearerToken(options.apiToken))).pipe(Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }), Effect.mapError((cause) => new BrowserRunCleanupError({
 					reason: "provider",
@@ -425,7 +426,7 @@ var BrowserRunSessionLifecycle = class extends Context.Service()("@effect-agent/
 				if (result.sessionId !== sessionId) return yield* new BrowserRunCleanupError({ reason: "malformed" });
 				return result.endTime !== void 0 && result.endTime > 0;
 			});
-			return { close: Effect.fn("BrowserRunSessionLifecycle.close")(function* (sessionId) {
+			return { close: Effect.fnUntraced(function* (sessionId) {
 				const id = yield* Schema.decodeEffect(Identity)(Redacted.value(sessionId)).pipe(Effect.mapError(() => new BrowserRunCleanupError({ reason: "configuration" })));
 				if (yield* request("DELETE", id)) return;
 				for (let read = 0; read < 2; read++) if (yield* request("GET", id)) return;
@@ -785,7 +786,7 @@ const disposeActionHandles = async (handles) => {
 	await boundedBestEffort(Promise.allSettled(handles.map(async (handle) => handle.dispose())), ACTION_POST_STATE_MILLIS);
 };
 /** Runs entirely in the page realm for both observations and the last bound-element guard. */
-const observePage = (target, requestedSelector, maximum, maximumControls, input) => {
+const observePage = pageFunction((target, requestedSelector, maximum, maximumControls, input) => {
 	const pageDocument = Reflect.get(globalThis, "document");
 	const matches = requestedSelector === void 0 ? void 0 : Reflect.apply(Reflect.get(pageDocument, "querySelectorAll"), pageDocument, [requestedSelector]);
 	const selectorMatchCount = matches === void 0 || matches === null ? 1 : Math.min(1e4, Reflect.get(matches, "length"));
@@ -962,7 +963,7 @@ const observePage = (target, requestedSelector, maximum, maximumControls, input)
 		_tag: "Text",
 		text
 	};
-};
+});
 const runObservedPageAction = async (page, selector, signal, onDispatch, action, validate, onComplete) => {
 	if (signal.aborted) throw new BrowserRunActionUndispatched(0);
 	const before = Schema.decodeUnknownSync(ActionTargetState)(await readActionTarget(page, selector));
@@ -1219,7 +1220,7 @@ const causeText = (cause) => {
 const isCapacityRefusal = (cause) => cause instanceof BrowserRunFailure && cause.status === 429;
 const isRemoteClosure = (cause) => /target closed|browser.*closed|session.*closed|connection.*closed|not connected|websocket.*closed/i.test(causeText(cause));
 const inputMayStillRun = (cause) => isRemoteClosure(cause) || cause instanceof Error && cause.name === "TimeoutError" || cause instanceof BrowserRunFailure && cause.reason === "timeout";
-const snapshotPolicy = Effect.fn("BrowserRunInteractive.snapshotPolicy")(function* (input) {
+const snapshotPolicy = Effect.fnUntraced(function* (input) {
 	const decoded = yield* Schema.decodeEffect(InteractiveBrowserPolicy, { onExcessProperty: "error" })(input).pipe(Effect.mapError(() => policyError("The interactive browser policy is malformed")));
 	if (decoded.network._tag === "PublicWeb") return yield* InteractiveBrowserUnsupportedError.make({
 		implementation: browserRunInteractiveImplementation,
@@ -1262,7 +1263,7 @@ const closeWithWarning = (close, warning) => Effect.tryPromise({
 	duration: Duration.millis(CLEANUP_STEP_TIMEOUT_MILLIS),
 	orElse: () => Effect.fail(protocolError(warning))
 }), Effect.catchCause((cause) => reportBrowserCause("interactive.cleanup", cause).pipe(Effect.andThen(Effect.logWarning(warning)))));
-const deadlineError = Effect.fn("BrowserRunInteractive.deadlineError")(function* (policy, startedAt) {
+const deadlineError = Effect.fnUntraced(function* (policy, startedAt) {
 	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 	return yield* InteractiveBrowserLimitError.make({
 		implementation: browserRunInteractiveImplementation,
@@ -1272,7 +1273,7 @@ const deadlineError = Effect.fn("BrowserRunInteractive.deadlineError")(function*
 		message: "The browser elapsed-time limit was reached"
 	});
 });
-const withinDeadline = Effect.fn("BrowserRunInteractive.withinDeadline")(function* (effect, policy, startedAt, onTimeout) {
+const withinDeadline = Effect.fnUntraced(function* (effect, policy, startedAt, onTimeout) {
 	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 	const elapsed = Math.max(0, now - startedAt);
 	const remaining = policy.maxElapsedMillis - elapsed;
@@ -1315,7 +1316,7 @@ const awaitPendingRequests = (state) => Effect.suspend(() => {
 	const pending = [...state.pendingRequests];
 	return pending.length === 0 ? Effect.void : Effect.promise(() => Promise.all(pending)).pipe(Effect.asVoid, Effect.andThen(awaitPendingRequests(state)));
 });
-const decodeNavigationResult = Effect.fn("BrowserRunInteractive.decodeNavigationResult")(function* (page, policy) {
+const decodeNavigationResult = Effect.fnUntraced(function* (page, policy) {
 	const url = yield* Effect.try({
 		try: page.url,
 		catch: (cause) => protocolError("Reading the browser navigation URL failed", cause)
@@ -1324,7 +1325,7 @@ const decodeNavigationResult = Effect.fn("BrowserRunInteractive.decodeNavigation
 	if (!hostAllowed(policy, result.url)) return yield* policyError("The browser returned an off-policy page URL");
 	return result;
 });
-const decodeActionResult = Effect.fn("BrowserRunInteractive.decodeActionResult")(function* (page, policy) {
+const decodeActionResult = Effect.fnUntraced(function* (page, policy) {
 	const url = yield* Effect.try({
 		try: page.url,
 		catch: (cause) => protocolError("Reading the browser page URL failed", cause)
@@ -1355,7 +1356,7 @@ const makeRequestListener = (policy, state) => (request) => {
 	});
 	state.pendingRequests.add(observed);
 };
-const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page, policy, startedAt, state, close) {
+const makeHandle = Effect.fnUntraced(function* (page, policy, startedAt, state, close) {
 	const permits = yield* Semaphore.make(1);
 	let currentOperation;
 	let generation = 0;
@@ -1436,9 +1437,7 @@ const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page
 		"browser.action_dispatched": evidence.dispatch !== "not-dispatched",
 		"browser.action_outcome_unknown": evidence.dispatch === "running" || evidence.dispatch === "unknown"
 	}))));
-	const decodeActionObservation = Effect.fn("BrowserRunInteractive.decodeActionObservation")(function* (raw) {
-		return yield* Schema.decodeUnknownEffect(ActionObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed action observation", cause)));
-	});
+	const decodeActionObservation = (raw) => Schema.decodeUnknownEffect(ActionObservation)(raw).pipe(Effect.mapError((cause) => protocolError("The browser returned a malformed action observation", cause)));
 	const logActionObservation = (operation, observation) => Effect.logInfo("Browser interactive action observed").pipe(Effect.annotateLogs({
 		"browser.action": operation,
 		"browser.input_millis": observation.inputMillis,
@@ -1605,7 +1604,7 @@ const makeHandle = Effect.fn("BrowserRunInteractive.makeHandle")(function* (page
 		run
 	};
 });
-const remainingMillis = Effect.fn("BrowserRunInteractive.remainingMillis")(function* (policy, startedAt) {
+const remainingMillis = Effect.fnUntraced(function* (policy, startedAt) {
 	const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
 	return Math.max(0, policy.maxElapsedMillis - Math.max(0, now - startedAt));
 });
@@ -1663,7 +1662,7 @@ const makeHostService = (binding) => {
 	const closeSession = (sessionId) => binding.closeSession(sessionId).pipe(Effect.tap(() => Effect.sync(() => {
 		owners.delete(Redacted.value(sessionId));
 	})));
-	const terminate = Effect.fn("BrowserRunInteractiveHost.terminate")(function* (sessionId, entries) {
+	const terminate = Effect.fnUntraced(function* (sessionId, entries) {
 		const deadline = (yield* Clock.currentTimeMillis) + 1e4;
 		yield* closeSession(sessionId).pipe(Effect.interruptible, Effect.timeoutOrElse({
 			duration: "10 seconds",
@@ -1673,14 +1672,14 @@ const makeHostService = (binding) => {
 		if (remaining <= 0) return yield* Effect.logWarning("Local browser teardown skipped after confirmed termination deadline");
 		yield* runTeardown(entries).pipe(Effect.flatMap((failures) => Effect.forEach(failures, (failure) => reportBrowserCause("interactive.cleanup", Cause.fail(failure.error)).pipe(Effect.andThen(Effect.logWarning(failure.warning))), { discard: true })), Effect.interruptible, Effect.timeout(`${remaining} millis`), Effect.catchCause((cause) => reportBrowserCause("interactive.cleanup", cause).pipe(Effect.andThen(Effect.logWarning("Local browser teardown incomplete after confirmed termination")))));
 	});
-	const closeAcquired = Effect.fn("BrowserRunInteractiveHost.closeAcquired")(function* (browser) {
+	const closeAcquired = Effect.fnUntraced(function* (browser) {
 		const sessionId = yield* Effect.try({
 			try: browser.sessionId,
 			catch: (cause) => actionError("close", cause)
 		}).pipe(Effect.flatMap(Schema.decodeUnknownEffect(BrowserRunSessionId)), Effect.mapError((cause) => actionError("close", cause)), Effect.onError(() => closeWithWarning(browser.close, "Closing an unidentified browser failed")));
 		yield* terminate(Redacted.make(sessionId), [closeEntry(browser.close, "Closing the local browser connection failed")]);
 	});
-	const acquire = Effect.fn("BrowserRunInteractiveHost.acquire")(function* (policy, resume, pendingInput = false) {
+	const acquire = Effect.fnUntraced(function* (policy, resume, pendingInput = false) {
 		const scope = yield* Scope.Scope;
 		const fixedPolicy = yield* snapshotPolicy(policy);
 		const startedAt = resume?.startedAt ?? (yield* Clock.currentTimeMillis);
@@ -1931,4 +1930,4 @@ const CloudflareInteractiveBrowser = {
 //#endregion
 export { reportedBrowserError as C, reportBrowserCause as S, BrowserRunCleanupError as _, BrowserRunInteractiveCheckpoint as a, BrowserRunFailure as b, BrowserRunLiveViewResult as c, BrowserRunViewport as d, CloudflareInteractiveBrowser as f, isBrowserRunUndispatchedActionError as g, browserRunInteractiveLayer as h, BrowserRunInteractiveBinding as i, BrowserRunPageIdentity as l, browserRunInteractiveImplementation as m, BrowserRunHandoffResult as n, BrowserRunInteractiveHost as o, browserRunInteractiveHostLayer as p, BrowserRunHandoffState as r, BrowserRunLiveViewRequest as s, BrowserRunHandoffRequest as t, BrowserRunPageObservation as u, BrowserRunSessionLifecycle as v, browserFailure as x, BrowserRunBinding as y };
 
-//# sourceMappingURL=InteractiveBrowser-BbG3kGA9.mjs.map
+//# sourceMappingURL=InteractiveBrowser-LdKzQeLR.mjs.map