@effect-agent/platform-cloudflare 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/CloudflareBindings.mjs

@@ -0,0 +1,113 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Predicate, Schema } from "effect";
+import "effect-agent/identifiers";
+import "effect-agent/records";
+import { RpcTargets } from "effect-cf";
+//#region src/CloudflareBindings.ts
+var CloudflareBindings_exports = /* @__PURE__ */ __exportAll({
+	CloudflareBindingError: () => CloudflareBindingError,
+	DurableObjectContext: () => DurableObjectContext,
+	ThreadObjectIdentity: () => ThreadObjectIdentity,
+	ThreadObjectNamespace: () => ThreadObjectNamespace,
+	ThreadObjectPlacement: () => ThreadObjectPlacement,
+	callThreadObject: () => callThreadObject,
+	threadNamespaceFromEnv: () => threadNamespaceFromEnv,
+	threadNamespaceLayer: () => threadNamespaceLayer
+});
+/**
+* Cloudflare platform bindings as Effect services (DEPLOY-010: "Cloudflare platform bindings
+* are supplied as Effect services/Layers"). Application code never reads `env` or touches a
+* `DurableObjectState` directly — the Thread Object class constructs these Layers once
+* per incarnation and everything downstream consumes the services.
+*/
+/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */
+var CloudflareBindingError = class extends Schema.TaggedError()("CloudflareBindingError", {
+	binding: Schema.String,
+	message: Schema.String
+}) {};
+/**
+* Deterministic logical Thread placement. The native adapter uses `idFromName(threadId)`;
+* a shared application owner can bind that logical identity into its RPC adapter instead.
+* Lookup performs no I/O and grants no authority. Calls reuse a native target within
+* one invocation; incoming requests and durable retries acquire their own targets.
+*/
+var ThreadObjectNamespace = class ThreadObjectNamespace extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectNamespace") {
+	static layer(namespace, options = {}) {
+		return Layer.succeed(ThreadObjectNamespace)({
+			get: (threadId) => namespace.get(namespace.idFromName(threadId)),
+			...options.rpcTracing === void 0 ? {} : { rpcTracing: options.rpcTracing }
+		});
+	}
+};
+/** Invoke a placed Thread using the current invocation's native RPC channel. */
+const callThreadObject = Effect.fn("callThreadObject")(function* (threadId, invoke, onError) {
+	const namespace = yield* ThreadObjectNamespace;
+	const target = yield* RpcTargets.get(namespace, threadId, () => namespace.get(threadId)).pipe(Effect.mapError(onError));
+	return yield* Effect.tryPromise({
+		try: () => invoke(target),
+		catch: onError
+	}).pipe(Effect.tapCause(() => RpcTargets.invalidate(target)));
+});
+/**
+* Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,
+* and a namespace binding is a host object no Schema can decode, so this is the documented
+* narrowest-boundary check (structural probe for the namespace surface the transport uses);
+* a missing or misshaped binding fails typed before any Layer is built.
+*/
+const threadNamespaceFromEnv = Effect.fn("threadNamespaceFromEnv")(function* (env, binding) {
+	if (!Predicate.isObjectKeyword(env)) return yield* CloudflareBindingError.make({
+		binding,
+		message: "The Worker environment is not an object; no bindings are available."
+	});
+	const candidate = yield* Effect.try({
+		try: () => {
+			const value = Reflect.get(env, binding);
+			if (!Predicate.isObjectKeyword(value)) return void 0;
+			const idFromName = Reflect.get(value, "idFromName");
+			const get = Reflect.get(value, "get");
+			return typeof idFromName === "function" && typeof get === "function" ? value : void 0;
+		},
+		catch: () => CloudflareBindingError.make({
+			binding,
+			message: `env.${binding} could not be inspected as a DurableObjectNamespace binding.`
+		})
+	});
+	if (candidate !== void 0) return candidate;
+	return yield* CloudflareBindingError.make({
+		binding,
+		message: `env.${binding} is not a DurableObjectNamespace binding; declare the Thread Object class under this binding in the Worker configuration.`
+	});
+});
+/**
+* Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the
+* receiver also opts into the effect-cf native RPC trace-context contract.
+*/
+const threadNamespaceLayer = (env, binding, options = {}) => Layer.effect(ThreadObjectNamespace)(Effect.map(threadNamespaceFromEnv(env, binding), (namespace) => ({
+	get: (threadId) => namespace.get(namespace.idFromName(threadId)),
+	...options.rpcTracing === true ? { rpcTracing: binding } : {}
+})));
+/**
+* The live Durable Object execution context of THIS incarnation. Only Layer construction and
+* the alarm service consume it; important state never lives on it (`ctx.storage` is truth,
+* everything in memory is a cache — deployment spec §11).
+*/
+var DurableObjectContext = class DurableObjectContext extends Context.Service()("@effect-agent/platform-cloudflare/DurableObjectContext") {
+	static layer(ctx, env) {
+		return Layer.succeed(DurableObjectContext)({
+			ctx,
+			env
+		});
+	}
+};
+/**
+* The Thread identity this Object serializes and the producer identity its Attempts
+* write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation
+* from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.
+*/
+var ThreadObjectIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectIdentity") {};
+/** Logical Threads whose canonical stores and admission ledger live in this physical Object. */
+var ThreadObjectPlacement = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectPlacement") {};
+//#endregion
+export { CloudflareBindingError, DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement, callThreadObject, CloudflareBindings_exports as t, threadNamespaceFromEnv, threadNamespaceLayer };
+
+//# sourceMappingURL=CloudflareBindings.mjs.map

package/dist/CloudflareBindings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudflareBindings.mjs","names":[],"sources":["../src/CloudflareBindings.ts"],"sourcesContent":["import { Context, Effect, Layer, Predicate, Schema } from \"effect\";\nimport { type ThreadId } from \"effect-agent/identifiers\";\nimport { type ProducerId } from \"effect-agent/records\";\nimport { RpcTargets } from \"effect-cf\";\n\n/**\n * Cloudflare platform bindings as Effect services (DEPLOY-010: \"Cloudflare platform bindings\n * are supplied as Effect services/Layers\"). Application code never reads `env` or touches a\n * `DurableObjectState` directly — the Thread Object class constructs these Layers once\n * per incarnation and everything downstream consumes the services.\n */\n\n/** A Cloudflare platform binding was missing or carried the wrong shape (DEPLOY-003/010). */\nexport class CloudflareBindingError extends Schema.TaggedError<CloudflareBindingError>()(\n  \"CloudflareBindingError\",\n  {\n    binding: Schema.String,\n    message: Schema.String,\n  },\n) {}\n\n/**\n * The RPC surface one Thread Durable Object exposes to Workers and to sibling\n * Thread Objects. `ThreadObject.make` implements it; the Worker-side client\n * and the cross-Object transport call it through `DurableObjectNamespace` stubs. Every\n * `encoded` value is a Schema-encoded envelope (`client.ts` wire schemas for host entry\n * points, `@effect-agent/storage-cloudflare` port envelopes for `portCall`), so the RPC\n * boundary carries only structured-cloneable JSON. The optional trailing trace context is\n * transient native RPC metadata, stripped by an opted-in effect-cf receiver before decoding\n * the host envelope. It never enters durable state.\n */\nexport interface ThreadObjectRpc extends Rpc.DurableObjectBranded {\n  /** Admission-limits gate + `DurableAgentRuntime.submit`; answers a `SubmitResponse`. */\n  submitEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Wake-hinted, poll-guaranteed settlement wait; answers an `AwaitSettlementResponse`. */\n  submissionStatusEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  awaitSettlementEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Event-driven durable progress wait; answers a `ProgressObserved` host response. */\n  awaitProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Best-effort cancellation for one in-flight progress wait. */\n  cancelProgressEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** One bounded page of canonical records; answers an `ObservePageResponse`. */\n  observePage(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Durable abort intent; answers an `AbortResponse`. */\n  abortEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Durable approval decision (plan §2.6); answers a `ResolveApprovalResponse`. */\n  resolveApprovalEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Authorized DUR-017 Unknown-Outcome resolution; answers a `ResolveUnknownResponse`. */\n  resolveUnknownEncoded(encoded: unknown, traceContext?: unknown): Promise<unknown>;\n  /** Owner-side cross-Object port endpoint (WP2 envelopes, executed on LOCAL facets). */\n  portCall(encoded: unknown): Promise<unknown>;\n  /** Droppable liveness hint from another Object: arms an immediate alarm. */\n  wake(): Promise<void>;\n}\n\n/** A logical Thread endpoint may be bound to an application Object without forging its brand. */\nexport type ThreadObjectClient = Omit<ThreadObjectRpc, keyof Rpc.DurableObjectBranded>;\n\n/**\n * Deterministic logical Thread placement. The native adapter uses `idFromName(threadId)`;\n * a shared application owner can bind that logical identity into its RPC adapter instead.\n * Lookup performs no I/O and grants no authority. Calls reuse a native target within\n * one invocation; incoming requests and durable retries acquire their own targets.\n */\nexport class ThreadObjectNamespace extends Context.Service<\n  ThreadObjectNamespace,\n  {\n    readonly get: (threadId: ThreadId) => ThreadObjectClient;\n    /** Stable binding name for opted-in native RPC tracing; absent by default. */\n    readonly rpcTracing?: string;\n  }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectNamespace\") {\n  static layer(\n    namespace: DurableObjectNamespace<ThreadObjectRpc>,\n    options: { readonly rpcTracing?: string } = {},\n  ): Layer.Layer<ThreadObjectNamespace> {\n    return Layer.succeed(ThreadObjectNamespace)({\n      get: (threadId) => namespace.get(namespace.idFromName(threadId)),\n      ...(options.rpcTracing === undefined ? {} : { rpcTracing: options.rpcTracing }),\n    });\n  }\n}\n\n/** Invoke a placed Thread using the current invocation's native RPC channel. */\nexport const callThreadObject = Effect.fn(\"callThreadObject\")(function* <A, E>(\n  threadId: ThreadId,\n  invoke: (target: ThreadObjectClient) => Promise<A>,\n  onError: (cause: unknown) => E,\n): Effect.fn.Return<A, E, ThreadObjectNamespace> {\n  const namespace = yield* ThreadObjectNamespace;\n\n  const target = yield* RpcTargets.get(namespace, threadId, () => namespace.get(threadId)).pipe(\n    Effect.mapError(onError),\n  );\n\n  return yield* Effect.tryPromise({ try: () => invoke(target), catch: onError }).pipe(\n    Effect.tapCause(() => RpcTargets.invalidate(target)),\n  );\n});\n\n/**\n * Narrow one `env` member to a `DurableObjectNamespace`. `env` is an untyped platform value,\n * and a namespace binding is a host object no Schema can decode, so this is the documented\n * narrowest-boundary check (structural probe for the namespace surface the transport uses);\n * a missing or misshaped binding fails typed before any Layer is built.\n */\nexport const threadNamespaceFromEnv = Effect.fn(\"threadNamespaceFromEnv\")(function* (\n  env: unknown,\n  binding: string,\n): Effect.fn.Return<DurableObjectNamespace<ThreadObjectRpc>, CloudflareBindingError> {\n  if (!Predicate.isObjectKeyword(env)) {\n    return yield* CloudflareBindingError.make({\n      binding,\n      message: \"The Worker environment is not an object; no bindings are available.\",\n    });\n  }\n\n  const candidate = yield* Effect.try({\n    try: () => {\n      const value: unknown = Reflect.get(env, binding);\n\n      if (!Predicate.isObjectKeyword(value)) return undefined;\n      const idFromName: unknown = Reflect.get(value, \"idFromName\");\n      const get: unknown = Reflect.get(value, \"get\");\n\n      return typeof idFromName === \"function\" && typeof get === \"function\" ? value : undefined;\n    },\n    catch: () =>\n      CloudflareBindingError.make({\n        binding,\n        message: `env.${binding} could not be inspected as a DurableObjectNamespace binding.`,\n      }),\n  });\n\n  if (candidate !== undefined) {\n    // The structural probe above is the entire runtime contract this package relies on;\n    // the assertion records that `idFromName`/`get` name a DurableObjectNamespace.\n    return candidate as unknown as DurableObjectNamespace<ThreadObjectRpc>;\n  }\n\n  return yield* CloudflareBindingError.make({\n    binding,\n    message:\n      `env.${binding} is not a DurableObjectNamespace binding; declare the Thread ` +\n      \"Object class under this binding in the Worker configuration.\",\n  });\n});\n\n/**\n * Build the namespace from Worker `env` (fails typed). Enable `rpcTracing` only when the\n * receiver also opts into the effect-cf native RPC trace-context contract.\n */\nexport const threadNamespaceLayer = (\n  env: unknown,\n  binding: string,\n  options: { readonly rpcTracing?: boolean } = {},\n): Layer.Layer<ThreadObjectNamespace, CloudflareBindingError> =>\n  Layer.effect(ThreadObjectNamespace)(\n    Effect.map(threadNamespaceFromEnv(env, binding), (namespace) => ({\n      get: (threadId) => namespace.get(namespace.idFromName(threadId)),\n      ...(options.rpcTracing === true ? { rpcTracing: binding } : {}),\n    })),\n  );\n\n/**\n * The live Durable Object execution context of THIS incarnation. Only Layer construction and\n * the alarm service consume it; important state never lives on it (`ctx.storage` is truth,\n * everything in memory is a cache — deployment spec §11).\n */\nexport class DurableObjectContext extends Context.Service<\n  DurableObjectContext,\n  {\n    readonly ctx: DurableObjectState;\n    readonly env: unknown;\n  }\n>()(\"@effect-agent/platform-cloudflare/DurableObjectContext\") {\n  static layer(ctx: DurableObjectState, env: unknown): Layer.Layer<DurableObjectContext> {\n    return Layer.succeed(DurableObjectContext)({ ctx, env });\n  }\n}\n\n/**\n * The Thread identity this Object serializes and the producer identity its Attempts\n * write with (`{producerPrefix}:{threadId}`, plan §1.4). Derived once per incarnation\n * from `ctx.id.name` — the Object identity rule guarantees the name IS the Thread ID.\n */\nexport class ThreadObjectIdentity extends Context.Service<\n  ThreadObjectIdentity,\n  {\n    readonly threadId: ThreadId;\n    readonly producerId: ProducerId;\n  }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectIdentity\") {}\n\n/** Logical Threads whose canonical stores and admission ledger live in this physical Object. */\nexport class ThreadObjectPlacement extends Context.Service<\n  ThreadObjectPlacement,\n  { readonly ownsThread: (threadId: ThreadId) => boolean }\n>()(\"@effect-agent/platform-cloudflare/ThreadObjectPlacement\") {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAaA,IAAa,yBAAb,cAA4C,OAAO,YAAoC,CAAC,CACtF,0BACA;CACE,SAAS,OAAO;CAChB,SAAS,OAAO;AAClB,CACF,CAAC,CAAC,CAAC;;;;;;;AA6CH,IAAa,wBAAb,MAAa,8BAA8B,QAAQ,QAOjD,CAAC,CAAC,yDAAyD,CAAC,CAAC;CAC7D,OAAO,MACL,WACA,UAA4C,CAAC,GACT;EACpC,OAAO,MAAM,QAAQ,qBAAqB,CAAC,CAAC;GAC1C,MAAM,aAAa,UAAU,IAAI,UAAU,WAAW,QAAQ,CAAC;GAC/D,GAAI,QAAQ,eAAe,KAAA,IAAY,CAAC,IAAI,EAAE,YAAY,QAAQ,WAAW;EAC/E,CAAC;CACH;AACF;;AAGA,MAAa,mBAAmB,OAAO,GAAG,kBAAkB,CAAC,CAAC,WAC5D,UACA,QACA,SAC+C;CAC/C,MAAM,YAAY,OAAO;CAEzB,MAAM,SAAS,OAAO,WAAW,IAAI,WAAW,gBAAgB,UAAU,IAAI,QAAQ,CAAC,CAAC,CAAC,KACvF,OAAO,SAAS,OAAO,CACzB;CAEA,OAAO,OAAO,OAAO,WAAW;EAAE,WAAW,OAAO,MAAM;EAAG,OAAO;CAAQ,CAAC,CAAC,CAAC,KAC7E,OAAO,eAAe,WAAW,WAAW,MAAM,CAAC,CACrD;AACF,CAAC;;;;;;;AAQD,MAAa,yBAAyB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WACxE,KACA,SACmF;CACnF,IAAI,CAAC,UAAU,gBAAgB,GAAG,GAChC,OAAO,OAAO,uBAAuB,KAAK;EACxC;EACA,SAAS;CACX,CAAC;CAGH,MAAM,YAAY,OAAO,OAAO,IAAI;EAClC,WAAW;GACT,MAAM,QAAiB,QAAQ,IAAI,KAAK,OAAO;GAE/C,IAAI,CAAC,UAAU,gBAAgB,KAAK,GAAG,OAAO,KAAA;GAC9C,MAAM,aAAsB,QAAQ,IAAI,OAAO,YAAY;GAC3D,MAAM,MAAe,QAAQ,IAAI,OAAO,KAAK;GAE7C,OAAO,OAAO,eAAe,cAAc,OAAO,QAAQ,aAAa,QAAQ,KAAA;EACjF;EACA,aACE,uBAAuB,KAAK;GAC1B;GACA,SAAS,OAAO,QAAQ;EAC1B,CAAC;CACL,CAAC;CAED,IAAI,cAAc,KAAA,GAGhB,OAAO;CAGT,OAAO,OAAO,uBAAuB,KAAK;EACxC;EACA,SACE,OAAO,QAAQ;CAEnB,CAAC;AACH,CAAC;;;;;AAMD,MAAa,wBACX,KACA,SACA,UAA6C,CAAC,MAE9C,MAAM,OAAO,qBAAqB,CAAC,CACjC,OAAO,IAAI,uBAAuB,KAAK,OAAO,IAAI,eAAe;CAC/D,MAAM,aAAa,UAAU,IAAI,UAAU,WAAW,QAAQ,CAAC;CAC/D,GAAI,QAAQ,eAAe,OAAO,EAAE,YAAY,QAAQ,IAAI,CAAC;AAC/D,EAAE,CACJ;;;;;;AAOF,IAAa,uBAAb,MAAa,6BAA6B,QAAQ,QAMhD,CAAC,CAAC,wDAAwD,CAAC,CAAC;CAC5D,OAAO,MAAM,KAAyB,KAAiD;EACrF,OAAO,MAAM,QAAQ,oBAAoB,CAAC,CAAC;GAAE;GAAK;EAAI,CAAC;CACzD;AACF;;;;;;AAOA,IAAa,uBAAb,cAA0C,QAAQ,QAMhD,CAAC,CAAC,wDAAwD,CAAC,CAAC,CAAC;;AAG/D,IAAa,wBAAb,cAA2C,QAAQ,QAGjD,CAAC,CAAC,yDAAyD,CAAC,CAAC,CAAC"}

package/dist/CloudflareBrowser-DV6kya1H.mjs

@@ -0,0 +1,495 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Option, Schema } from "effect";
+import { PageCapture, PageCaptureInferencePolicyError, PageCaptureInferenceUse, PageCaptureNavigationError, PageCaptureOutputLimitError, PageCaptureProtocolError, PageCaptureRateLimitedError, PageCaptureResourceUse, PageCaptureResult, PageCaptureUnsupportedError, PageContentCaptured, PageLinksCaptured, PageMarkdownCaptured, PageScrapeCaptured, PageStructuredCaptured } from "effect-agent/page-capture";
+import { PageScreenshot, PageScreenshotOutputLimitError, PageScreenshotResult } from "effect-agent/page-screenshot";
+import { SandboxImplementation } from "effect-agent/sandbox";
+//#region src/internal/browser-quick-action.ts
+/**
+* The Cloudflare Browser Run Quick Action `PageCapture` adapter (capability
+* spec §9.2). Each capture is one stateless `quickAction()` RPC on the
+* Wrangler `browser` binding: the platform renders the target in a managed
+* headless browser and returns one bounded output; the adapter holds no
+* session and no state between passes. The binding requires a Worker
+* compatibility date of `2026-03-24` or later, and local `wrangler dev` needs
+* remote mode (`"remote": true` on the binding) because `quickAction` has no
+* local implementation.
+*
+* Rendered output is untrusted, attacker-influenced content; this adapter
+* only bounds and types it. Deployment class `E` only: no durability claim.
+*/
+const browserQuickActionImplementation = SandboxImplementation.make({
+	isolation: "isolated",
+	identity: "cloudflare-browser-quick-action"
+});
+/** A native binding RPC rejected before it returned an HTTP response. */
+var BrowserQuickActionRpcError = class extends Schema.TaggedError()("BrowserQuickActionRpcError", {
+	action: Schema.Literals([
+		"screenshot",
+		"content",
+		"markdown",
+		"links",
+		"scrape",
+		"json"
+	]),
+	cause: Schema.Defect()
+}) {};
+/** Host-owned browser binding authority, supplied explicitly at the composition root. */
+var BrowserQuickActionBrowserBinding = class BrowserQuickActionBrowserBinding extends Context.Service()("@effect-agent/platform-cloudflare/BrowserQuickActionBrowserBinding") {
+	static layer(options) {
+		const browser = options.browser;
+		const invoke = Effect.fn("BrowserQuickActionBrowserBinding.invoke")(function* (action, evaluate) {
+			return yield* Effect.tryPromise({
+				try: evaluate,
+				catch: (cause) => BrowserQuickActionRpcError.make({
+					action,
+					cause
+				})
+			});
+		});
+		return Layer.succeed(BrowserQuickActionBrowserBinding)({
+			screenshot: (request) => invoke("screenshot", () => browser.quickAction("screenshot", request)),
+			content: (request) => invoke("content", () => browser.quickAction("content", request)),
+			markdown: (request) => invoke("markdown", () => browser.quickAction("markdown", request)),
+			links: (request) => invoke("links", () => browser.quickAction("links", request)),
+			scrape: (request) => invoke("scrape", () => browser.quickAction("scrape", request)),
+			json: (request) => invoke("json", () => browser.quickAction("json", request))
+		});
+	}
+};
+/** Host-only diagnostic for a denied or unaccounted Workers AI extraction. */
+var BrowserQuickActionWorkersAiPolicyError = class extends Schema.TaggedError()("BrowserQuickActionWorkersAiPolicyError", {
+	reason: Schema.Literals(["authorization", "accounting"]),
+	message: Schema.String.check(Schema.isMaxLength(8e3)),
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/** Explicit host-owned authority and accounting for separately billed Workers AI extraction. */
+var BrowserQuickActionWorkersAi = class BrowserQuickActionWorkersAi extends Context.Service()("@effect-agent/platform-cloudflare/BrowserQuickActionWorkersAi") {
+	static layer(policy) {
+		return Layer.succeed(BrowserQuickActionWorkersAi)(policy);
+	}
+};
+const MAX_DIAGNOSTIC_LENGTH = 8e3;
+const boundedDiagnostic = (message) => message.slice(0, MAX_DIAGNOSTIC_LENGTH);
+const QuickActionSuccessEnvelope = Schema.Struct({
+	success: Schema.Literal(true),
+	result: Schema.Json
+});
+const QuickActionErrorEnvelope = Schema.Struct({
+	success: Schema.Literal(false),
+	errors: Schema.Array(Schema.Struct({
+		message: Schema.String,
+		code: Schema.optionalKey(Schema.Number),
+		detail: Schema.optionalKey(Schema.String),
+		path: Schema.optionalKey(Schema.String)
+	})),
+	rawAiResponse: Schema.optionalKey(Schema.String)
+});
+const QuickActionEnvelope = Schema.Union([QuickActionSuccessEnvelope, QuickActionErrorEnvelope]);
+const decodeEnvelope = Schema.decodeUnknownOption(Schema.fromJsonString(QuickActionEnvelope));
+/** Recognize only the provider's exact timeout grammar; never forward arbitrary error text. */
+const navigationFailureMessage = (bodyText, response) => {
+	const fallback = `The Browser Run Quick Action API answered HTTP ${response.status}; the destination status is unknown`;
+	if (!isJsonResponse(response)) return fallback;
+	const envelope = decodeEnvelope(bodyText);
+	if (Option.isNone(envelope) || envelope.value.success) return fallback;
+	for (const error of envelope.value.errors) {
+		if (error.code !== 6002) continue;
+		const timeout = /^Navigation timeout of ([1-9][0-9]{0,5}) ms exceeded$/.exec(error.detail ?? "");
+		if (timeout !== null) return `Browser Run navigation timed out after ${timeout[1]} ms (Quick Action API HTTP ${response.status}); the destination status is unknown`;
+	}
+	return fallback;
+};
+/** Project the schema-validated request onto Cloudflare's native common options. */
+const quickActionCommonOptions = (request) => {
+	const options = {};
+	const navigation = request.navigation;
+	if (navigation !== void 0) {
+		const goto = {};
+		if (navigation.waitUntil !== void 0) goto.waitUntil = navigation.waitUntil;
+		if (navigation.timeoutMillis !== void 0) goto.timeout = navigation.timeoutMillis;
+		if (Object.keys(goto).length > 0) options.gotoOptions = goto;
+		if (navigation.waitForSelector !== void 0) options.waitForSelector = {
+			selector: navigation.waitForSelector.selector,
+			...navigation.waitForSelector.timeoutMillis === void 0 ? {} : { timeout: navigation.waitForSelector.timeoutMillis }
+		};
+	}
+	if (request.viewport !== void 0) options.viewport = {
+		width: request.viewport.width,
+		height: request.viewport.height
+	};
+	if (request.resourcePolicy !== void 0) {
+		if (request.resourcePolicy.rejectResourceTypes !== void 0) options.rejectResourceTypes = [...request.resourcePolicy.rejectResourceTypes];
+		if (request.resourcePolicy.allowRequestPatterns !== void 0) options.allowRequestPattern = [...request.resourcePolicy.allowRequestPatterns];
+	}
+	return request.target._tag === "PageUrlTarget" ? {
+		...options,
+		url: request.target.url
+	} : {
+		...options,
+		html: request.target.html
+	};
+};
+/** Dispatch through Cloudflare's native action-specific overloads. */
+const executeQuickAction = (browser, request) => {
+	const options = quickActionCommonOptions(request);
+	switch (request.action._tag) {
+		case "CapturePageContent": return browser.content(options);
+		case "CapturePageMarkdown": return browser.markdown(options);
+		case "CapturePageLinks": return browser.links({
+			...options,
+			...request.action.visibleLinksOnly === void 0 ? {} : { visibleLinksOnly: request.action.visibleLinksOnly }
+		});
+		case "CapturePageScrape": return browser.scrape({
+			...options,
+			elements: request.action.selectors.map((selector) => ({ selector }))
+		});
+		case "CapturePageStructured": return browser.json({
+			...options,
+			response_format: {
+				type: "json_schema",
+				json_schema: request.action.responseFormat
+			},
+			...request.action.prompt === void 0 ? {} : { prompt: request.action.prompt }
+		});
+	}
+};
+const protocolError = (message, cause) => PageCaptureProtocolError.make({
+	implementation: browserQuickActionImplementation,
+	message: boundedDiagnostic(message),
+	...cause === void 0 ? {} : { cause }
+});
+const navigationError = (message, cause) => PageCaptureNavigationError.make({
+	implementation: browserQuickActionImplementation,
+	message: boundedDiagnostic(message),
+	...cause === void 0 ? {} : { cause }
+});
+/** Preserve bounded remote diagnostics for the host without exposing their text to a model. */
+const privateResponseCause = (bodyText, response) => new Error(boundedDiagnostic(bodyText), { cause: {
+	provider: "cloudflare-browser-run",
+	httpStatus: response.status,
+	httpStatusSource: "browser-api",
+	headers: Object.fromEntries([
+		"content-type",
+		"cf-ray",
+		"x-request-id",
+		"retry-after",
+		"x-browser-ms-used"
+	].flatMap((name) => {
+		const value = response.headers.get(name);
+		return value === null ? [] : [[name, boundedDiagnostic(value)]];
+	})),
+	bodyCharacters: bodyText.length,
+	bodyTruncated: bodyText.length > MAX_DIAGNOSTIC_LENGTH
+} });
+/** Foreign cancellation must not keep a response Scope open indefinitely. */
+const cancelResponse = (cancel, warning) => Effect.tryPromise({
+	try: cancel,
+	catch: () => void 0
+}).pipe(Effect.interruptible, Effect.timeoutOrElse({
+	duration: "1 second",
+	orElse: () => Effect.fail(void 0)
+}), Effect.catch(() => Effect.logWarning(warning)));
+const releaseResponseReader = (reader) => cancelResponse(() => reader.cancel(), "Canceling the Quick Action response failed").pipe(Effect.ensuring(Effect.try({
+	try: () => reader.releaseLock(),
+	catch: (cause) => protocolError("Releasing the Quick Action response failed", cause)
+}).pipe(Effect.catch((error) => Effect.logWarning(error.message)))));
+const readBoundedResponse = Effect.fn("BrowserQuickActionCapture.readResponse")(function* (response, request) {
+	const body = response.body;
+	if (body === null) return "";
+	const reader = yield* Effect.acquireRelease(Effect.try({
+		try: () => body.getReader(),
+		catch: (cause) => protocolError("Opening the Quick Action response failed", cause)
+	}), releaseResponseReader);
+	const decoder = new TextDecoder("utf-8", {
+		fatal: true,
+		ignoreBOM: false
+	});
+	let observedBytes = 0;
+	let bodyText = "";
+	while (true) {
+		const chunk = yield* Effect.tryPromise({
+			try: () => reader.read(),
+			catch: (cause) => protocolError("Reading the Quick Action response failed", cause)
+		});
+		if (chunk.done) break;
+		observedBytes += chunk.value.byteLength;
+		if (observedBytes > request.limits.maxOutputBytes) return yield* PageCaptureOutputLimitError.make({
+			implementation: browserQuickActionImplementation,
+			limit: request.limits.maxOutputBytes,
+			observed: observedBytes
+		});
+		bodyText += yield* Effect.try({
+			try: () => decoder.decode(chunk.value, { stream: true }),
+			catch: (cause) => protocolError("Decoding the Quick Action response failed", cause)
+		});
+	}
+	return bodyText + (yield* Effect.try({
+		try: () => decoder.decode(),
+		catch: (cause) => protocolError("Decoding the Quick Action response failed", cause)
+	}));
+}, Effect.scoped);
+/**
+* Retry-After arrives in whole seconds; a non-integer form (an HTTP date) is
+* dropped rather than guessed at.
+*/
+const retryAfterMillis = (response) => {
+	const header = response.headers.get("Retry-After");
+	if (header === null) return void 0;
+	const seconds = Number(header);
+	if (!Number.isSafeInteger(seconds) || seconds < 0) return void 0;
+	const millis = seconds * 1e3;
+	return Number.isSafeInteger(millis) ? millis : void 0;
+};
+const browserMillis = (response) => {
+	const header = response.headers.get("X-Browser-Ms-Used");
+	if (header === null) return void 0;
+	const millis = Number(header);
+	return Number.isSafeInteger(millis) && millis >= 0 ? millis : void 0;
+};
+/** Only trusted response metadata chooses transport framing; page text never does. */
+const isJsonResponse = (response) => {
+	const contentType = response.headers.get("Content-Type");
+	if (contentType === null) return false;
+	const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase();
+	return mediaType === "application/json" || mediaType?.endsWith("+json") === true;
+};
+const parseOutput = (action, bodyText, response) => {
+	if (!isJsonResponse(response)) return protocolError("The Quick Action success response was not a JSON response envelope", privateResponseCause(bodyText, response));
+	const envelope = decodeEnvelope(bodyText);
+	if (Option.isNone(envelope)) return protocolError("The JSON Quick Action response did not carry a valid response envelope", privateResponseCause(bodyText, response));
+	if (!envelope.value.success) return navigationError(navigationFailureMessage(bodyText, response), privateResponseCause(bodyText, response));
+	switch (action._tag) {
+		case "CapturePageContent":
+		case "CapturePageMarkdown":
+			if (typeof envelope.value.result !== "string") return protocolError("The Quick Action envelope carried a non-text result");
+			return action._tag === "CapturePageContent" ? PageContentCaptured.make({ html: envelope.value.result }) : PageMarkdownCaptured.make({ markdown: envelope.value.result });
+		case "CapturePageLinks": {
+			const decoded = Schema.decodeUnknownOption(PageLinksCaptured)({
+				_tag: "PageLinksCaptured",
+				links: envelope.value.result
+			});
+			if (Option.isNone(decoded)) return protocolError("The links Quick Action did not return a bounded array of valid URLs");
+			return decoded.value;
+		}
+		case "CapturePageScrape": {
+			const decoded = Schema.decodeUnknownOption(PageScrapeCaptured)({
+				_tag: "PageScrapeCaptured",
+				groups: envelope.value.result
+			});
+			if (Option.isNone(decoded)) return protocolError("The scrape Quick Action did not return bounded grouped element records");
+			return decoded.value;
+		}
+		case "CapturePageStructured": return PageStructuredCaptured.make({ value: envelope.value.result });
+	}
+};
+const isQuotaMessage = (text) => /time limit|daily|quota/i.test(text);
+const makeCapture = (browser, workersAi) => Effect.fn("BrowserQuickActionCapture.capture")(function* (request) {
+	if (request.engine !== "chromium") return yield* PageCaptureUnsupportedError.make({
+		implementation: browserQuickActionImplementation,
+		feature: "engine",
+		message: "The browser binding's quickAction() exposes no engine selector; kitesurf requires the REST or CDP surface"
+	});
+	const usesWorkersAi = request.action._tag === "CapturePageStructured";
+	if (usesWorkersAi) {
+		if (workersAi === void 0) return yield* PageCaptureUnsupportedError.make({
+			implementation: browserQuickActionImplementation,
+			feature: "action",
+			message: "Structured capture invokes separately billed Workers AI and requires an explicit authorization and accounting policy"
+		});
+		yield* workersAi.authorizeAndAccount(request).pipe(Effect.mapError((cause) => PageCaptureInferencePolicyError.make({
+			implementation: browserQuickActionImplementation,
+			provider: "cloudflare-workers-ai",
+			reason: cause.reason,
+			message: cause.reason === "authorization" ? "Workers AI extraction was not authorized" : "Workers AI extraction could not be accounted for",
+			cause
+		})));
+	}
+	const response = yield* executeQuickAction(browser, request).pipe(Effect.mapError((error) => protocolError("The browser binding rejected the Quick Action", error.cause)));
+	const bodyText = yield* readBoundedResponse(response, request);
+	if (response.status === 429) {
+		const retryAfter = retryAfterMillis(response);
+		const reason = isQuotaMessage(bodyText) ? "quota" : "rate";
+		const cause = privateResponseCause(bodyText, response);
+		return yield* PageCaptureRateLimitedError.make({
+			implementation: browserQuickActionImplementation,
+			reason,
+			...retryAfter === void 0 ? {} : { retryAfterMillis: retryAfter },
+			...cause === void 0 ? {} : { cause },
+			message: reason === "quota" ? "The Quick Action exceeded its browser quota" : "The Quick Action was rate limited"
+		});
+	}
+	if (!response.ok) {
+		const message = navigationFailureMessage(bodyText, response);
+		const cause = privateResponseCause(bodyText, response);
+		if (response.status >= 500) return yield* protocolError(message, cause);
+		return yield* navigationError(message, cause);
+	}
+	const output = parseOutput(request.action, bodyText, response);
+	if (output._tag === "PageCaptureNavigationError" || output._tag === "PageCaptureProtocolError") return yield* output;
+	const millis = browserMillis(response);
+	return PageCaptureResult.make({
+		implementation: browserQuickActionImplementation,
+		output,
+		resourceUse: PageCaptureResourceUse.make({
+			...millis === void 0 ? {} : { browserMillis: millis },
+			...usesWorkersAi ? { inference: PageCaptureInferenceUse.make({
+				provider: "cloudflare-workers-ai",
+				modelCalls: 1
+			}) } : {}
+		})
+	});
+});
+/**
+* Ordinary Quick Actions require host-owned browser binding authority. Workers
+* AI stays unavailable unless the host deliberately selects its separate Layer.
+*/
+const browserQuickActionCaptureLayer = () => Layer.effect(PageCapture, Effect.map(BrowserQuickActionBrowserBinding, (browser) => PageCapture.of({ capture: makeCapture(browser) })));
+/** Structured Quick Actions require host-owned browser and Workers AI authority. */
+const browserQuickActionWorkersAiCaptureLayer = () => Layer.effect(PageCapture, Effect.gen(function* () {
+	const browser = yield* BrowserQuickActionBrowserBinding;
+	const workersAi = yield* BrowserQuickActionWorkersAi;
+	return PageCapture.of({ capture: makeCapture(browser, workersAi) });
+}));
+/** Compose WebCapture handlers with the Cloudflare Quick Action adapter. */
+const CloudflareBrowser = { 
+/**
+* Supply a WebCapture definition and the resolved Worker browser binding.
+* Supports capture, scrape, and extraction definitions without importing capabilities.
+* Only PageCapture is provided; other handler requirements and errors stay visible.
+* Extraction fails closed unless workersAi explicitly authorizes and accounts for it.
+* Capture limits, typed failures, tracing, and scoped response cleanup are unchanged.
+*/
+layer: (definition, options) => {
+	const capture = options.workersAi === void 0 ? browserQuickActionCaptureLayer() : browserQuickActionWorkersAiCaptureLayer().pipe(Layer.provide(BrowserQuickActionWorkersAi.layer(options.workersAi)));
+	return definition.handlers.pipe(Layer.provide(capture.pipe(Layer.provide(BrowserQuickActionBrowserBinding.layer(options)))));
+} };
+const screenshotOptions = (request) => {
+	const options = {};
+	if (request.navigation?.waitUntil !== void 0 || request.navigation?.timeoutMillis !== void 0) options.gotoOptions = {
+		...request.navigation.waitUntil === void 0 ? {} : { waitUntil: request.navigation.waitUntil },
+		...request.navigation.timeoutMillis === void 0 ? {} : { timeout: request.navigation.timeoutMillis }
+	};
+	if (request.navigation?.waitForSelector !== void 0) options.waitForSelector = {
+		selector: request.navigation.waitForSelector.selector,
+		...request.navigation.waitForSelector.timeoutMillis === void 0 ? {} : { timeout: request.navigation.waitForSelector.timeoutMillis }
+	};
+	if (request.viewport !== void 0) options.viewport = {
+		width: request.viewport.width,
+		height: request.viewport.height
+	};
+	if (request.resourcePolicy?.rejectResourceTypes !== void 0) options.rejectResourceTypes = [...request.resourcePolicy.rejectResourceTypes];
+	if (request.resourcePolicy?.allowRequestPatterns !== void 0) options.allowRequestPattern = [...request.resourcePolicy.allowRequestPatterns];
+	return {
+		...options,
+		...request.target._tag === "PageUrlTarget" ? { url: request.target.url } : { html: request.target.html },
+		screenshotOptions: {
+			type: "png",
+			encoding: "binary",
+			fullPage: request.fullPage
+		}
+	};
+};
+const cancelBody = (body) => cancelResponse(() => body.cancel(), "Canceling the screenshot response failed");
+const releaseScreenshotReader = (reader) => cancelResponse(() => reader.cancel(), "Canceling the screenshot response failed").pipe(Effect.ensuring(Effect.try({
+	try: () => reader.releaseLock(),
+	catch: () => void 0
+}).pipe(Effect.catch(() => Effect.logWarning("Releasing the screenshot response failed")))));
+const pngResponse = (response) => response.headers.get("Content-Type")?.split(";", 1)[0]?.trim().toLowerCase() === "image/png";
+const declaredLength = (response) => {
+	const raw = response.headers.get("Content-Length");
+	if (raw === null || !/^(0|[1-9][0-9]*)$/.test(raw)) return void 0;
+	const length = Number(raw);
+	return Number.isSafeInteger(length) ? length : void 0;
+};
+const readScreenshot = Effect.fn("BrowserQuickActionScreenshot.read")(function* (response, request) {
+	const body = response.body;
+	if (body === null) return yield* protocolError("The screenshot response had no body");
+	if (!pngResponse(response)) {
+		yield* cancelBody(body);
+		return yield* protocolError("The screenshot response was not image/png");
+	}
+	const length = declaredLength(response);
+	if (length !== void 0 && length > request.limits.maxOutputBytes) {
+		yield* cancelBody(body);
+		return yield* PageScreenshotOutputLimitError.make({
+			implementation: browserQuickActionImplementation,
+			limit: request.limits.maxOutputBytes,
+			observed: length
+		});
+	}
+	const reader = yield* Effect.acquireRelease(Effect.try({
+		try: () => body.getReader(),
+		catch: (cause) => protocolError("Opening the screenshot response failed", cause)
+	}), releaseScreenshotReader);
+	const chunks = [];
+	let observed = 0;
+	while (true) {
+		const next = yield* Effect.tryPromise({
+			try: () => reader.read(),
+			catch: (cause) => protocolError("Reading the screenshot response failed", cause)
+		});
+		if (next.done) break;
+		observed += next.value.byteLength;
+		if (observed > request.limits.maxOutputBytes) return yield* PageScreenshotOutputLimitError.make({
+			implementation: browserQuickActionImplementation,
+			limit: request.limits.maxOutputBytes,
+			observed
+		});
+		chunks.push(next.value);
+	}
+	const bytes = new Uint8Array(observed);
+	let offset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return bytes;
+}, Effect.scoped);
+const makeScreenshot = (browser) => Effect.fn("BrowserQuickActionScreenshot.capture")(function* (request) {
+	if (request.engine !== "chromium") return yield* PageCaptureUnsupportedError.make({
+		implementation: browserQuickActionImplementation,
+		feature: "engine",
+		message: "The browser binding's screenshot action exposes no engine selector"
+	});
+	const response = yield* browser.screenshot(screenshotOptions(request)).pipe(Effect.mapError((error) => protocolError("The browser binding rejected the screenshot", error.cause)));
+	if (response.status === 429) {
+		const body = response.body;
+		if (body !== null) yield* cancelBody(body);
+		return yield* PageCaptureRateLimitedError.make({
+			implementation: browserQuickActionImplementation,
+			reason: "rate",
+			...retryAfterMillis(response) === void 0 ? {} : { retryAfterMillis: retryAfterMillis(response) },
+			message: "The screenshot Quick Action was rate limited"
+		});
+	}
+	if (!response.ok) {
+		const body = response.body;
+		if (body !== null) yield* cancelBody(body);
+		const message = `The screenshot Quick Action answered HTTP ${response.status}`;
+		return yield* response.status >= 500 ? protocolError(message) : navigationError(message);
+	}
+	const bytes = yield* readScreenshot(response, request);
+	return PageScreenshotResult.make({
+		implementation: browserQuickActionImplementation,
+		mediaType: "image/png",
+		bytes
+	});
+});
+/** Native Browser Run screenshot adapter. It retains PNG bytes only for the caller's result. */
+const browserQuickActionScreenshotLayer = () => Layer.effect(PageScreenshot, Effect.map(BrowserQuickActionBrowserBinding, (browser) => PageScreenshot.of({ capture: makeScreenshot(browser) })));
+//#endregion
+//#region src/CloudflareBrowser.ts
+var CloudflareBrowser_exports = /* @__PURE__ */ __exportAll({
+	BrowserQuickActionBrowserBinding: () => BrowserQuickActionBrowserBinding,
+	BrowserQuickActionRpcError: () => BrowserQuickActionRpcError,
+	BrowserQuickActionWorkersAi: () => BrowserQuickActionWorkersAi,
+	BrowserQuickActionWorkersAiPolicyError: () => BrowserQuickActionWorkersAiPolicyError,
+	CloudflareBrowser: () => CloudflareBrowser,
+	browserQuickActionCaptureLayer: () => browserQuickActionCaptureLayer,
+	browserQuickActionScreenshotLayer: () => browserQuickActionScreenshotLayer,
+	browserQuickActionWorkersAiCaptureLayer: () => browserQuickActionWorkersAiCaptureLayer
+});
+//#endregion
+export { BrowserQuickActionWorkersAiPolicyError as a, browserQuickActionScreenshotLayer as c, BrowserQuickActionWorkersAi as i, browserQuickActionWorkersAiCaptureLayer as l, BrowserQuickActionBrowserBinding as n, CloudflareBrowser as o, BrowserQuickActionRpcError as r, browserQuickActionCaptureLayer as s, CloudflareBrowser_exports as t };
+
+//# sourceMappingURL=CloudflareBrowser-DV6kya1H.mjs.map