@effect-agent/platform-cloudflare 0.1.0-beta.45 → 0.1.0-beta.46

package/dist/index.mjs

@@ -1,1357 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { $ as CloudflarePlatformConfigError, A as decodeUnknownResolutionCommand, B as DurableAlarmError, C as decodeApprovalDecisionCommand, D as decodeObservePageRequest, E as decodeHostResponse, F as encodeHostResponse, G as safeCauseDiagnostic, H as MaintenancePassReport, I as encodeObservePageRequest, J as CLOUDFLARE_DATABASE_CAP_BYTES, K as safeCauseMessage, L as encodeReceipt, M as encodeApprovalDecisionCommand, N as encodeAwaitProgressRequest, O as decodeReceipt, P as encodeCancelProgressRequest, Q as CloudflareDurableRuntimeConfigValue, R as encodeSubmitRequest, S as decodeAbortCommand, T as decodeCancelProgressRequest, U as ThreadMaintenance, V as DurableAlarmService, W as ThreadMaintenanceFailpoint, X as CloudflareAdmissionLimitsValue, Y as CLOUDFLARE_RUNTIME_DEFAULTS, Z as CloudflareDurableRuntimeConfig, _ as SubmitRequest, a as AwaitProgressRequest, at as threadNamespaceFromEnv, b as UnknownResolutionRecorded, c as HostFailed, d as HostResponse, et as DEFAULT_MAX_DATABASE_BYTES, f as ObservePageRequest, g as SettlementReached, h as ProgressObserved, i as ApprovalRecorded, it as ThreadObjectNamespace, j as encodeAbortCommand, k as decodeSubmitRequest, l as HostFailure, m as ProgressCancelled, n as cloudflareScheduledInputAdmissionLayer, nt as DurableObjectContext, o as CancelProgressRequest, ot as threadNamespaceLayer, p as ObservedPage, q as AdmissionLimitExceeded, r as AbortRecorded, rt as ThreadObjectIdentity, s as CloudflareThreadClient, t as cloudflarePreparedInputAdmissionLayer, tt as CloudflareBindingError, u as HostProtocolError, v as SubmitSucceeded, w as decodeAwaitProgressRequest, x as boundHostDiagnostic, y as ThreadClientError, z as encodeUnknownResolutionCommand } from "./prepared-admission-BhW2eT_a.mjs";
-import { CloudflareSchedulingClient, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, makeScheduleOwnerObjectClass } from "./scheduling.mjs";
-import { CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionProtocolError, makeSubscriptionPartitionObjectClass, sourcePartitionName, validateCloudflareSubscriptionLimits } from "./subscriptions.mjs";
-import { CloudflareBrowser } from "./browser-quick-action.mjs";
-import { Clock, Context, Deferred, Duration, Effect, Exit, Fiber, Layer, Option, PubSub, Queue, Ref, Schema, Stream } from "effect";
-import { MemoryOwnerIdentity, MemoryOwnerRequest, MemoryOwnerResponse, MemoryRpcError, MemoryRpcLimits, ThreadPortTransport, decodeMemoryWire, decodePortRequest, defaultDoMemoryStorageLimits, defaultMemoryRpcLimits, doMemoryStoreLayerWithFailpoints, encodeMemoryWire, encodePortResponse, executePortRequest, handleMemoryOwnerRequest, portTransportFailure, routedSubmissionLedgerLayer, routedThreadStoreLayer, storageConfigLayer, storageFailpointLayer, submissionLedgerLayer, threadStoreLayer } from "@effect-agent/storage-cloudflare";
-import { AppendConflict, DigestError, DurableAgentRuntime, DurableRuntimeConfig, DurableRuntimeFailpoint, DurableRuntimeFailpointError, FenceRejected, IntegrityReport, LedgerError, ObligationReport, ObligationThresholds, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, OwnershipLost, PersistedJson, Principal, ProducerId, RecoveryExplanation, RecoveryReport, RetryCommand, RetryRefused, RunJournalError, SettlementConflict, SubmissionLedger, SubmissionLookupByKey, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError, ToolReconciler, WakeScheduler, compileRegistrations, makeWakeSubscriptionHub, operationAuthorizerLayer } from "@effect-agent/thread";
-import { Memory, MemoryAccess, MemoryDocument, MemoryMutationFailpoint, MemoryNamespace, MemoryNamespaceAddress, MemoryRecallLimits, MemoryStorageError, MemoryWriter, SubmissionId, ThreadId } from "@effect-agent/core";
-import { CurrentToolFailureObserver, RunContextPreparationPassthrough, RunToolAuthorization, toolFailureObserverLayer } from "@effect-agent/engine";
-import { BrowserCrypto } from "@effect/platform-browser";
-import { SqliteClient } from "@effect/sql-sqlite-do";
-import { DurableObject, DurableObjectState, WorkerEnvironment } from "effect-cf";
-import { CodeExecutionHost, CodeExecutionProtocolError, CodeExecutionResourceUse, CodeExecutionResult, CodeExecutionTimeoutError, CodeExecutor, CodeExecutorStartError, CodeExecutorTerminatedError, CodeExecutorUnsupportedError, CodeHostCall, CodeHostCallLimitError, CodeHostCallResult, CodeOutputLimitError, CodeProgramFailedError, CodeSourceError, SandboxImplementation } from "@effect-agent/sandbox";
-import { RpcTarget } from "cloudflare:workers";
-//#region src/wake-scheduler.ts
-/**
-* Bounded in-memory wake buffer for same-incarnation `awaitSettlement` subscribers. Wake
-* hints are droppable by contract (consumers pair every subscription with ledger polls), so
-* a full buffer slides out the oldest hint and an eviction simply loses the buffer — the
-* poll interval and the persisted alarm keep liveness (persistence §14).
-*/
-const WAKE_BUFFER_CAPACITY = 1024;
-/** A remote wake stub call failed; always swallowed and logged (hints are droppable). */
-var RemoteWakeDropped = class extends Schema.TaggedError()("RemoteWakeDropped", {
-	threadId: Schema.String,
-	message: Schema.String,
-	cause: Schema.optionalKey(Schema.Defect())
-}) {};
-/**
-* The DC `WakeScheduler` (plan §1.4):
-*
-* - `notify(local)` → `setAlarm(now)` — durable, cheap, coalescing (the alarm slot keeps the
-*   earliest deadline) — plus a same-incarnation PubSub hint for `awaitSettlement` waiters.
-* - `notify(remote)` → fire-and-forget `wake()` on the owning Object's stub with every error
-*   swallowed and logged: hints are droppable, and the target's own alarm/scan pairing (the
-*   maintenance pass re-polls unsettled children) guarantees liveness without this call.
-* - `wakes` → the bounded sliding PubSub only. No important state lives in memory: the
-*   subscription accelerates waiters within one incarnation and the settlement poll interval
-*   is the correctness path.
-*/
-const cloudflareWakeSchedulerLayer = Layer.effect(WakeScheduler)(Effect.gen(function* () {
-	const alarm = yield* DurableAlarmService;
-	const identity = yield* ThreadObjectIdentity;
-	const { namespace } = yield* ThreadObjectNamespace;
-	const hints = yield* PubSub.sliding(WAKE_BUFFER_CAPACITY);
-	const progress = yield* makeWakeSubscriptionHub;
-	yield* Effect.addFinalizer(() => PubSub.shutdown(hints));
-	const notifyLocal = (threadId) => progress.notify(threadId).pipe(Effect.andThen(PubSub.publish(hints, threadId)), Effect.andThen(alarm.scheduleNow), Effect.catch((error) => Effect.logWarning("CloudflareWakeScheduler: local alarm wake failed", error)), Effect.asVoid);
-	const notifyRemote = (threadId) => Effect.tryPromise({
-		try: () => namespace.get(namespace.idFromName(threadId)).wake(),
-		catch: (cause) => RemoteWakeDropped.make({
-			threadId,
-			message: safeCauseMessage(cause, "The remote wake failed without a diagnostic"),
-			cause
-		})
-	}).pipe(Effect.catch((error) => Effect.logWarning(`CloudflareWakeScheduler: remote wake of ${threadId} dropped`, error)), Effect.asVoid);
-	return WakeScheduler.of({
-		notify: (threadId) => threadId === identity.threadId ? notifyLocal(threadId) : notifyRemote(threadId),
-		subscribe: progress.subscribe,
-		wakes: Stream.fromPubSub(hints)
-	});
-}));
-//#endregion
-//#region src/progress-wait.ts
-/** Cancellation tombstones are bounded hints, never durable authority. */
-const MAX_CANCELLATION_TOMBSTONES = 1024;
-/**
-* Per-incarnation cancellation registry for long-lived progress RPCs. The public runtime owns
-* the actual wake registration; this host-only registry lets an interrupted Worker Effect ask
-* the Object to interrupt its scoped wait before the Worker execution context itself ends.
-*/
-var ProgressWaitRegistry = class ProgressWaitRegistry extends Context.Service()("@effect-agent/platform-cloudflare/ProgressWaitRegistry") {
-	static layer = Layer.effect(ProgressWaitRegistry, Effect.gen(function* () {
-		const registrations = yield* Ref.make(/* @__PURE__ */ new Map());
-		const remove = (waiterId, deferred) => Ref.update(registrations, (current) => {
-			const existing = current.get(waiterId);
-			if (existing === void 0 || existing === "cancelled" || !existing.has(deferred)) return current;
-			const next = new Map(current);
-			const active = new Set(existing);
-			active.delete(deferred);
-			if (active.size === 0) next.delete(waiterId);
-			else next.set(waiterId, active);
-			return next;
-		});
-		const subscribe = Effect.fn("ProgressWaitRegistry.subscribe")((waiterId) => Effect.gen(function* () {
-			const deferred = yield* Deferred.make();
-			yield* Effect.addFinalizer(() => remove(waiterId, deferred));
-			return {
-				cancelled: yield* Ref.modify(registrations, (current) => {
-					const existing = current.get(waiterId);
-					const next = new Map(current);
-					if (existing === "cancelled") return [true, current];
-					const active = new Set(existing ?? []);
-					active.add(deferred);
-					next.set(waiterId, active);
-					return [false, next];
-				}),
-				deferred
-			};
-		}).pipe(Effect.map(({ cancelled, deferred }) => cancelled ? Effect.void : Deferred.await(deferred))));
-		const cancel = Effect.fn("ProgressWaitRegistry.cancel")(function* (waiterId) {
-			const waiters = yield* Ref.modify(registrations, (current) => {
-				const existing = current.get(waiterId);
-				const next = new Map(current);
-				if (existing === void 0) {
-					next.set(waiterId, "cancelled");
-					let tombstones = 0;
-					for (const registration of next.values()) if (registration === "cancelled") tombstones += 1;
-					if (tombstones > MAX_CANCELLATION_TOMBSTONES) for (const [id, registration] of next) {
-						if (registration !== "cancelled") continue;
-						next.delete(id);
-						break;
-					}
-					return [[], next];
-				}
-				if (existing === "cancelled") return [[], current];
-				next.delete(waiterId);
-				return [[...existing], next];
-			});
-			yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, void 0), { discard: true });
-		});
-		return ProgressWaitRegistry.of({
-			subscribe,
-			cancel
-		});
-	}));
-};
-//#endregion
-//#region src/transport.ts
-/**
-* `ThreadPortTransport` over native Durable Object JS RPC (decision D-P6-3): one
-* `portCall(envelope)` on the stub of the Object that owns the addressed Thread
-* (`namespace.idFromName(threadId)` — the identity rule, plan §1.2). The envelopes are
-* already Schema-encoded JSON, so the RPC boundary carries only structured-cloneable values;
-* the protocol module stays transport-agnostic and fetch-with-JSON remains the documented
-* fallback carrier.
-*
-* Every delivery problem — stub construction, RPC rejection, overload, deploy-in-progress —
-* surfaces as `PortTransportError` (preserving the platform stub's own `retryable` signal
-* when present) and NEVER as a fabricated answer: on `resolveAdmission` the routing layer
-* turns exactly this error into `AdmissionIndeterminate` (SUB-031).
-*/
-const threadPortTransportLayer = Layer.effect(ThreadPortTransport)(Effect.gen(function* () {
-	const { namespace } = yield* ThreadObjectNamespace;
-	return ThreadPortTransport.of({ call: (threadId, request) => Effect.tryPromise({
-		try: () => namespace.get(namespace.idFromName(threadId)).portCall(request),
-		catch: (cause) => portTransportFailure(threadId, cause)
-	}).pipe(Effect.withSpan("CloudflarePortTransport.call", { attributes: { threadId } })) });
-}));
-//#endregion
-//#region src/layers.ts
-/**
-* Owner-side execution port for a `portCall` request the wire endpoint has already decoded.
-* It executes against THIS Object's LOCAL port facets — never the routed decorators, so a
-* request cannot bounce between Objects — and returns the typed response for the endpoint to
-* encode.
-*/
-var ThreadObjectPorts = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectPorts") {};
-const decodeConfigValue = Schema.decodeUnknownEffect(CloudflareDurableRuntimeConfigValue);
-const decodeThreadId = Schema.decodeUnknownEffect(ThreadId);
-const decodeProducerId = Schema.decodeUnknownEffect(ProducerId);
-const configFromOptions = (options) => decodeConfigValue({
-	deploymentId: options.deploymentId,
-	producerPrefix: options.producerPrefix,
-	ownershipLeaseDuration: options.ownershipLeaseDuration ?? CLOUDFLARE_RUNTIME_DEFAULTS.ownershipLeaseDuration,
-	alarmBackoffBase: options.alarmBackoffBase ?? CLOUDFLARE_RUNTIME_DEFAULTS.alarmBackoffBase,
-	alarmBackoffCap: options.alarmBackoffCap ?? CLOUDFLARE_RUNTIME_DEFAULTS.alarmBackoffCap,
-	wakeScanInterval: options.wakeScanInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.wakeScanInterval,
-	settlementPollInterval: options.settlementPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.settlementPollInterval,
-	leaseRenewalInterval: options.leaseRenewalInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.leaseRenewalInterval,
-	abortPollInterval: options.abortPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.abortPollInterval,
-	observationPollInterval: options.observationPollInterval ?? CLOUDFLARE_RUNTIME_DEFAULTS.observationPollInterval,
-	maxStoredValueBytes: options.maxStoredValueBytes ?? CLOUDFLARE_RUNTIME_DEFAULTS.maxStoredValueBytes,
-	verifyOnOpen: options.verifyOnOpen ?? CLOUDFLARE_RUNTIME_DEFAULTS.verifyOnOpen,
-	limits: {
-		maxQueueDepthPerLane: options.maxQueueDepthPerLane ?? CLOUDFLARE_RUNTIME_DEFAULTS.maxQueueDepthPerLane,
-		maxInputBytes: Math.min(options.maxInputBytes ?? CLOUDFLARE_RUNTIME_DEFAULTS.maxInputBytes, options.maxStoredValueBytes ?? CLOUDFLARE_RUNTIME_DEFAULTS.maxStoredValueBytes),
-		maxDatabaseBytes: options.maxDatabaseBytes ?? CLOUDFLARE_RUNTIME_DEFAULTS.maxDatabaseBytes
-	}
-}).pipe(Effect.mapError((error) => CloudflarePlatformConfigError.make({
-	message: `Invalid Cloudflare durable runtime configuration: ${error.message}`,
-	cause: error
-})));
-/**
-* The Thread this Object owns, from the Object identity rule (plan §1.2): Thread
-* Objects are addressed exclusively by `idFromName(threadId)`, so `ctx.id.name` IS the
-* Thread ID. An unnamed Object (from `newUniqueId`) is a deployment error, not a lane.
-*/
-const threadIdFromState = (ctx) => ctx.id.name === void 0 ? Effect.fail(CloudflarePlatformConfigError.make({ message: "This Durable Object was not created via idFromName(threadId); Thread Objects must be addressed by their Thread identity (plan §1.2)." })) : decodeThreadId(ctx.id.name).pipe(Effect.mapError((error) => CloudflarePlatformConfigError.make({
-	message: `The Durable Object name is not a valid ThreadId: ${error.message}`,
-	cause: error
-})));
-/**
-* Validate deployment settings and derive services before building application dependencies.
-* The native class factory builds this Layer inside its constructor gate. Custom Effect hosts
-* can provide it around the complete application Layer with the native context already supplied.
-*/
-const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
-	const { ctx } = yield* DurableObjectContext;
-	const config = yield* configFromOptions(options);
-	const threadId = yield* threadIdFromState(ctx);
-	const producerId = yield* decodeProducerId(`${config.producerPrefix}:${threadId}`).pipe(Effect.mapError((error) => CloudflarePlatformConfigError.make({
-		message: `The minted producer identity is invalid: ${error.message}`,
-		cause: error
-	})));
-	return Layer.mergeAll(Layer.succeed(CloudflareDurableRuntimeConfig, config), Layer.succeed(ThreadObjectIdentity, {
-		threadId,
-		producerId
-	}), DurableRuntimeConfig.layer({
-		deploymentId: config.deploymentId,
-		producerId,
-		settlementPollInterval: Duration.millis(config.settlementPollInterval),
-		leaseRenewalInterval: Duration.millis(config.leaseRenewalInterval),
-		abortPollInterval: Duration.millis(config.abortPollInterval),
-		...options.estimateCostMicrousd === void 0 ? {} : { estimateCostMicrousd: options.estimateCostMicrousd }
-	}), BrowserCrypto.layer, storageFailpointLayer({
-		storage: ctx.storage,
-		failpoint: options.storageFailpoint?.(ctx)
-	}), options.runtimeFailpoint === void 0 ? DurableRuntimeFailpoint.layer : Layer.succeed(DurableRuntimeFailpoint, { hit: options.runtimeFailpoint(ctx) }), options.maintenanceFailpoint === void 0 ? ThreadMaintenanceFailpoint.layer : Layer.succeed(ThreadMaintenanceFailpoint, { hit: options.maintenanceFailpoint(ctx) }), options.toolReconciler ?? ToolReconciler.uncertain, options.operationAuthorizer === void 0 ? Layer.empty : operationAuthorizerLayer(options.operationAuthorizer), options.toolFailureObserver === void 0 ? Layer.succeed(CurrentToolFailureObserver, void 0) : toolFailureObserverLayer(options.toolFailureObserver), RunContextPreparationPassthrough, RunToolAuthorization.allowAll);
-}));
-/**
-* Register typed Agents and version declarations. Hashing and dependency capture happen in
-* this Layer's Scope, after application Layers have been provided. Every Agent's instruction,
-* Tool, Schema, and model requirements remain visible until satisfied by Layer composition.
-* Use Layer.unwrap for registration values that need effectful application setup.
-*/
-const layer = (registrations) => Layer.unwrap(Effect.map(compileRegistrations(registrations), layerFromBindings));
-/**
-* Assemble the durable runtime from already-resolved Agent Bindings.
-* Use `ThreadObject.layer` to compile typed Agent registrations instead.
-* Supply host services through `ThreadObject.make` or `ThreadObject.layerConfig` and
-* the Durable Object context and namespace Layers when composing a custom host.
-*/
-const layerFromBindings = (bindings) => Layer.unwrap(Effect.gen(function* () {
-	const { ctx } = yield* DurableObjectContext;
-	const config = yield* CloudflareDurableRuntimeConfig;
-	const { threadId } = yield* ThreadObjectIdentity;
-	const storageOptions = {
-		storage: ctx.storage,
-		observationPollInterval: config.observationPollInterval,
-		ownershipLeaseDuration: config.ownershipLeaseDuration,
-		maxStoredValueBytes: config.maxStoredValueBytes,
-		verifyOnOpen: config.verifyOnOpen
-	};
-	const infrastructure = Layer.mergeAll(storageConfigLayer(storageOptions), SqliteClient.layer({ storage: ctx.storage }));
-	const localPorts = Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(Layer.provide(infrastructure));
-	const portsEndpointLayer = Layer.effect(ThreadObjectPorts)(Effect.gen(function* () {
-		const local = yield* Effect.context();
-		return ThreadObjectPorts.of({ handle: (request) => executePortRequest(request).pipe(Effect.provide(local)) });
-	})).pipe(Layer.provide(localPorts));
-	const routedPorts = Layer.mergeAll(routedSubmissionLedgerLayer({ localThreadId: threadId }), routedThreadStoreLayer({ localThreadId: threadId })).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
-	const base = Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer);
-	const runtimeStack = DurableAgentRuntime.layerWithBindings(bindings).pipe(Layer.provideMerge(routedPorts), Layer.provideMerge(cloudflareWakeSchedulerLayer), Layer.provideMerge(base));
-	return Layer.mergeAll(runtimeStack, ThreadMaintenance.layer.pipe(Layer.provide(runtimeStack)), portsEndpointLayer);
-}));
-//#endregion
-//#region src/thread-object.ts
-var thread_object_exports = /* @__PURE__ */ __exportAll({
-	AdminExplainRequest: () => AdminExplainRequest,
-	AdminFailed: () => AdminFailed,
-	AdminFailure: () => AdminFailure,
-	AdminResponse: () => AdminResponse,
-	AdminVerifyRequest: () => AdminVerifyRequest,
-	ExplainedRecovery: () => ExplainedRecovery,
-	ObligationsScanned: () => ObligationsScanned,
-	RetryExecuted: () => RetryExecuted,
-	VerifiedIntegrity: () => VerifiedIntegrity,
-	decodeAdminExplainRequest: () => decodeAdminExplainRequest,
-	decodeAdminResponse: () => decodeAdminResponse,
-	decodeAdminVerifyRequest: () => decodeAdminVerifyRequest,
-	decodeObligationThresholds: () => decodeObligationThresholds,
-	decodeRetryCommand: () => decodeRetryCommand,
-	encodeAdminResponse: () => encodeAdminResponse,
-	layer: () => layer,
-	layerConfig: () => layerConfig,
-	make: () => make
-});
-/** Classify only a decoded port request so new protocol members cannot bypass pre-arming. */
-const isMutatingPortRequest = (request) => {
-	switch (request._tag) {
-		case "LedgerAdmit":
-		case "LedgerMarkReady":
-		case "LedgerRequestAbort":
-		case "LedgerRecordChildSettled":
-		case "StoreMaterialize":
-		case "StoreAppend": return true;
-		case "LedgerLookup":
-		case "LedgerResolveAdmission":
-		case "StoreReadPage":
-		case "StoreInspectTail":
-		case "StoreExport": return false;
-	}
-	return false;
-};
-/** The literal encoded `PortFailed(PortProtocolError)` fallback (same shape as WP2's). */
-const encodedPortProtocolFailure = (message) => ({
-	_tag: "PortFailed",
-	failure: {
-		_tag: "PortProtocolError",
-		message: boundHostDiagnostic(message)
-	}
-});
-const protocolFailure = (context) => (error) => HostProtocolError.make({ message: boundHostDiagnostic(`${context}: ${error.message}`) });
-/** Fold one endpoint's typed failures into the uniform `HostResponse` envelope. */
-const respond = (effect) => effect.pipe(Effect.map((result) => result), Effect.catch((failure) => Effect.succeed(HostFailed.make({ failure }))));
-/** Encode the response envelope; an unencodable response degrades to a protocol failure. */
-const encodeResponse = (response) => encodeHostResponse(response).pipe(Effect.catch((error) => Effect.succeed({
-	_tag: "HostFailed",
-	failure: {
-		_tag: "HostProtocolError",
-		message: boundHostDiagnostic(`The host response could not be encoded: ${error.message}`)
-	}
-})));
-const utf8Bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
-/**
-* The admission-limits gate, BEFORE `runtime.submit` touches the ledger (exit gate
-* "resource limits are checked before admission"; DEPLOY-007). A replayed idempotency key is
-* exempt: its accepted-work obligation already exists, and returning the original Receipt
-* consumes no new quota. Refusals are typed `AdmissionLimitExceeded` and nothing is written.
-*/
-const gateAdmissionLimits = Effect.fn("ThreadObject.gateAdmissionLimits")(function* (request) {
-	const identity = yield* ThreadObjectIdentity;
-	const config = yield* CloudflareDurableRuntimeConfig;
-	const ledger = yield* SubmissionLedger;
-	const { ctx } = yield* DurableObjectContext;
-	const existing = yield* ledger.lookup(SubmissionLookupByKey.make({
-		threadId: identity.threadId,
-		principal: request.principal,
-		idempotencyKey: request.idempotencyKey
-	}));
-	if (Option.isSome(existing)) return;
-	const inputBytes = utf8Bytes(request.inputPayload);
-	if (inputBytes > config.limits.maxInputBytes) return yield* AdmissionLimitExceeded.make({
-		limit: "input-bytes",
-		actual: inputBytes,
-		maximum: config.limits.maxInputBytes
-	});
-	const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
-	if (nonterminal.length >= config.limits.maxQueueDepthPerLane) return yield* AdmissionLimitExceeded.make({
-		limit: "queue-depth",
-		actual: nonterminal.length,
-		maximum: config.limits.maxQueueDepthPerLane
-	});
-	const databaseBytes = yield* Effect.sync(() => ctx.storage.sql.databaseSize);
-	if (databaseBytes > config.limits.maxDatabaseBytes) return yield* AdmissionLimitExceeded.make({
-		limit: "database-bytes",
-		actual: databaseBytes,
-		maximum: config.limits.maxDatabaseBytes
-	});
-});
-/**
-* The submit-capable projection of an Agent Binding on the OBJECT side: the input arrived
-* already encoded through the real input schema on the Worker side (`client.ts`), so the
-* Object admits the canonical `PersistedJson` payload as-is; the resolved Binding re-derives
-* everything else from the stored `(agentId, agentDigests)` at claim time (SUB-023).
-*/
-const passthroughSubmitAgent = (agentId) => ({ definition: {
-	id: agentId,
-	input: PersistedJson
-} });
-const submitEndpoint = (encoded) => decodeSubmitRequest(encoded).pipe(Effect.mapError(protocolFailure("The submit request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const maintenance = yield* ThreadMaintenance;
-	const runtime = yield* DurableAgentRuntime;
-	yield* gateAdmissionLimits(request);
-	const receipt = yield* maintenance.withMutation(runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
-		threadId: identity.threadId,
-		principal: request.principal,
-		idempotencyKey: request.idempotencyKey,
-		definitions: request.definitions
-	}));
-	return SubmitSucceeded.make({ receipt });
-})), respond, Effect.flatMap(encodeResponse));
-const awaitSettlementEndpoint = (encoded) => decodeReceipt(encoded).pipe(Effect.mapError(protocolFailure("The receipt could not be decoded")), Effect.flatMap((receipt) => Effect.gen(function* () {
-	const settlement = yield* (yield* DurableAgentRuntime).awaitSettlement(receipt);
-	return SettlementReached.make({ settlement });
-})), respond, Effect.flatMap(encodeResponse));
-const awaitProgressEndpoint = (encoded) => decodeAwaitProgressRequest(encoded).pipe(Effect.mapError(protocolFailure("The progress request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const runtime = yield* DurableAgentRuntime;
-	const registry = yield* ProgressWaitRegistry;
-	yield* Effect.scoped(Effect.gen(function* () {
-		const cancelled = yield* registry.subscribe(request.waiterId);
-		yield* Effect.raceFirst(runtime.awaitProgress(identity.threadId, request.afterSequence), cancelled);
-	}));
-	return ProgressObserved.make();
-})), respond, Effect.flatMap(encodeResponse));
-const cancelProgressEndpoint = (encoded) => decodeCancelProgressRequest(encoded).pipe(Effect.mapError(protocolFailure("The progress cancellation could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	yield* (yield* ProgressWaitRegistry).cancel(request.waiterId);
-	return ProgressCancelled.make();
-})), respond, Effect.flatMap(encodeResponse));
-const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(Effect.mapError(protocolFailure("The observe request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const store = yield* ThreadStore;
-	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
-		operation: "observe",
-		threadId: identity.threadId
-	}));
-	const records = yield* Stream.runCollect(store.read(ThreadRead.make({
-		threadId: identity.threadId,
-		...request.afterSequence === void 0 ? {} : { afterSequence: request.afterSequence },
-		limit: request.limit
-	})));
-	return ObservedPage.make({ records: [...records] });
-})), respond, Effect.flatMap(encodeResponse));
-const abortEndpoint = (encoded) => decodeAbortCommand(encoded).pipe(Effect.mapError(protocolFailure("The abort command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
-	const maintenance = yield* ThreadMaintenance;
-	const runtime = yield* DurableAgentRuntime;
-	const intent = yield* maintenance.withMutation(runtime.abort(command));
-	return AbortRecorded.make({ intent });
-})), respond, Effect.flatMap(encodeResponse));
-const resolveApprovalEndpoint = (encoded) => decodeApprovalDecisionCommand(encoded).pipe(Effect.mapError(protocolFailure("The approval command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
-	const maintenance = yield* ThreadMaintenance;
-	const runtime = yield* DurableAgentRuntime;
-	const intent = yield* maintenance.withMutation(runtime.resolveApproval(command));
-	return ApprovalRecorded.make({ intent });
-})), respond, Effect.flatMap(encodeResponse));
-const resolveUnknownEndpoint = (encoded) => decodeUnknownResolutionCommand(encoded).pipe(Effect.mapError(protocolFailure("The resolution command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
-	const maintenance = yield* ThreadMaintenance;
-	const runtime = yield* DurableAgentRuntime;
-	const intent = yield* maintenance.withMutation(runtime.resolveUnknown(command));
-	return UnknownResolutionRecorded.make({ intent });
-})), respond, Effect.flatMap(encodeResponse));
-/** Explain one Submission (`submissionId` present) or every nonterminal lane member. */
-var AdminExplainRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/AdminExplainRequest")({ submissionId: Schema.optionalKey(SubmissionId) }) {};
-/** Verify carries no parameters — the addressed Object IS the lane. */
-var AdminVerifyRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/AdminVerifyRequest")({}) {};
-/** Every typed failure of the four admin entry points, plus the protocol's own errors. */
-const AdminFailure = Schema.Union([
-	OperationDenied,
-	RetryRefused,
-	LedgerError,
-	RunJournalError,
-	DigestError,
-	OwnershipLost,
-	SettlementConflict,
-	ThreadStoreError,
-	ThreadNotMaterialized,
-	AppendConflict,
-	FenceRejected,
-	DurableRuntimeFailpointError,
-	DurableAlarmError,
-	HostProtocolError
-]);
-var ExplainedRecovery = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ExplainedRecovery")("ExplainedRecovery", { explanations: Schema.Array(RecoveryExplanation).check(Schema.isMaxLength(1024)) }) {};
-var VerifiedIntegrity = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/VerifiedIntegrity")("VerifiedIntegrity", { report: IntegrityReport }) {};
-var RetryExecuted = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/RetryExecuted")("RetryExecuted", { report: RecoveryReport }) {};
-var ObligationsScanned = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/ObligationsScanned")("ObligationsScanned", { report: ObligationReport }) {};
-/** The admin entry point failed TYPED on the Object; the failure re-decodes verbatim. */
-var AdminFailed = class extends Schema.TaggedClass("@effect-agent/platform-cloudflare/AdminFailed")("AdminFailed", { failure: AdminFailure }) {};
-/** The uniform answer of one admin entry point. Callers narrow by the tag their call implies. */
-const AdminResponse = Schema.Union([
-	ExplainedRecovery,
-	VerifiedIntegrity,
-	RetryExecuted,
-	ObligationsScanned,
-	AdminFailed
-]);
-const decodeAdminExplainRequest = Schema.decodeUnknownEffect(AdminExplainRequest);
-const decodeAdminVerifyRequest = Schema.decodeUnknownEffect(AdminVerifyRequest);
-const decodeRetryCommand = Schema.decodeUnknownEffect(RetryCommand);
-const decodeObligationThresholds = Schema.decodeUnknownEffect(ObligationThresholds);
-const encodeAdminResponse = Schema.encodeEffect(AdminResponse);
-const decodeAdminResponse = Schema.decodeUnknownEffect(AdminResponse);
-/** Fold one admin endpoint's typed failures into the uniform `AdminResponse` envelope. */
-const respondAdmin = (effect) => effect.pipe(Effect.map((result) => result), Effect.catch((failure) => Effect.succeed(AdminFailed.make({ failure }))));
-/** Encode the admin response envelope; an unencodable response degrades to a protocol failure. */
-const encodeAdminResponseTotal = (response) => encodeAdminResponse(response).pipe(Effect.catch((error) => Effect.succeed({
-	_tag: "AdminFailed",
-	failure: {
-		_tag: "HostProtocolError",
-		message: boundHostDiagnostic(`The admin response could not be encoded: ${error.message}`)
-	}
-})));
-const explainEndpoint = (encoded) => decodeAdminExplainRequest(encoded).pipe(Effect.mapError(protocolFailure("The explain request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const runtime = yield* DurableAgentRuntime;
-	const explanations = request.submissionId === void 0 ? yield* runtime.explainThread(identity.threadId) : [yield* runtime.explain(request.submissionId)];
-	return ExplainedRecovery.make({ explanations });
-})), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
-const verifyEndpoint = (encoded) => decodeAdminVerifyRequest(encoded).pipe(Effect.mapError(protocolFailure("The verify request could not be decoded")), Effect.flatMap(() => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const report = yield* (yield* DurableAgentRuntime).verify(identity.threadId);
-	return VerifiedIntegrity.make({ report });
-})), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
-const retryEndpoint = (encoded) => decodeRetryCommand(encoded).pipe(Effect.mapError(protocolFailure("The retry command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
-	const maintenance = yield* ThreadMaintenance;
-	const runtime = yield* DurableAgentRuntime;
-	const report = yield* maintenance.withMutation(runtime.retry(command));
-	return RetryExecuted.make({ report });
-})), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
-const obligationsEndpoint = (encoded) => decodeObligationThresholds(encoded).pipe(Effect.mapError(protocolFailure("The obligation thresholds could not be decoded")), Effect.flatMap((thresholds) => Effect.gen(function* () {
-	const report = yield* (yield* DurableAgentRuntime).scanObligations(thresholds);
-	return ObligationsScanned.make({ report });
-})), respondAdmin, Effect.flatMap(encodeAdminResponseTotal));
-/**
-* Owner-side `portCall`: wrap a mutating envelope in the same pre-armed generation protocol as
-* public RPC (a routed mutation committed by THIS Object must already carry the alarm that will
-* finish it), execute on the LOCAL facets (never the routed decorators), then arm an immediate
-* alarm so the mutated lane is processed promptly. Protocol anomalies answer
-* `PortFailed(PortProtocolError)`.
-*/
-const portCallEndpoint = (encoded) => Effect.gen(function* () {
-	const ports = yield* ThreadObjectPorts;
-	const maintenance = yield* ThreadMaintenance;
-	const alarm = yield* DurableAlarmService;
-	const decoded = yield* decodePortRequest(encoded).pipe(Effect.map((request) => ({
-		_tag: "success",
-		request
-	})), Effect.catch((error) => Effect.succeed({
-		_tag: "failure",
-		message: error.message
-	})));
-	if (decoded._tag === "failure") return encodedPortProtocolFailure(`The port request could not be decoded: ${decoded.message}`);
-	const mutating = isMutatingPortRequest(decoded.request);
-	const handled = yield* (mutating ? maintenance.withMutation(ports.handle(decoded.request)) : ports.handle(decoded.request)).pipe(Effect.exit);
-	if (handled._tag === "Failure") return encodedPortProtocolFailure("The owner Object could not arm its maintenance alarm before the mutation.");
-	const response = yield* encodePortResponse(handled.value).pipe(Effect.catch((error) => Effect.succeed(encodedPortProtocolFailure(`The port response could not be encoded: ${error.message}`))));
-	if (mutating) yield* alarm.scheduleNow.pipe(Effect.catch((error) => Effect.logWarning("ThreadObject.portCall: immediate re-arm failed", error)));
-	return response;
-});
-const wakeEndpoint = Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	yield* (yield* WakeScheduler).notify(identity.threadId);
-});
-const alarmEndpoint = Effect.gen(function* () {
-	yield* (yield* ThreadMaintenance).pass;
-});
-const gateEndpoint = Effect.gen(function* () {
-	yield* (yield* ThreadMaintenance).ensureAlarm;
-});
-/**
-* Adapter from effect-cf's native Durable Object services to Effect Agent's existing platform
-* ports. effect-cf owns the cached ManagedRuntime and supplies these values once per Object
-* incarnation; the durable runtime continues to depend only on the narrow services below.
-*/
-const effectCfPlatformLayer = (namespaceBinding, rpcTracing = false) => {
-	const context = Layer.effect(DurableObjectContext)(Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		const env = yield* WorkerEnvironment;
-		return DurableObjectContext.of({
-			ctx: state.raw,
-			env
-		});
-	}));
-	const namespace = Layer.effect(ThreadObjectNamespace)(Effect.gen(function* () {
-		const env = yield* WorkerEnvironment;
-		const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
-		return ThreadObjectNamespace.of({
-			namespace: binding,
-			...rpcTracing === true ? { rpcTracing: namespaceBinding } : {}
-		});
-	}));
-	return Layer.merge(context, namespace);
-};
-/**
-* Export a composed application Layer as a native Durable Object class.
-* Bootstrap services are provided to the whole graph before it acquires, so application Layers
-* can yield effect-cf's WorkerEnvironment and DurableObjectState, derived identity, and Crypto.
-* Application dependencies remain visible until Layer.provide satisfies them. effect-cf owns the
-* cached ManagedRuntime, native RPC methods, event scopes, and telemetry flushing.
-* Initialization is local and bounded inside the constructor gate. Cloudflare eviction does not
-* guarantee finalizers; put resources requiring timely release in scoped operations or eventLayer.
-*/
-const make = (applicationLayer, options) => {
-	const application = applicationLayer.pipe(Layer.provideMerge(layerConfig(options)), Layer.provideMerge(effectCfPlatformLayer(options.namespaceBinding, options.rpcTracing)));
-	const runtime = Layer.effectContext(Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		const scope = yield* Effect.scope;
-		return yield* state.blockConcurrencyWhile(Effect.gen(function* () {
-			const services = yield* Layer.buildWithScope(application, scope);
-			yield* gateEndpoint.pipe(Effect.provide(services));
-			return services;
-		}));
-	}));
-	const rpc = {
-		submitEncoded: (encoded) => submitEndpoint(encoded),
-		awaitSettlementEncoded: (encoded) => awaitSettlementEndpoint(encoded),
-		awaitProgressEncoded: (encoded) => awaitProgressEndpoint(encoded),
-		cancelProgressEncoded: (encoded) => cancelProgressEndpoint(encoded),
-		observePage: (encoded) => observePageEndpoint(encoded),
-		abortEncoded: (encoded) => abortEndpoint(encoded),
-		resolveApprovalEncoded: (encoded) => resolveApprovalEndpoint(encoded),
-		resolveUnknownEncoded: (encoded) => resolveUnknownEndpoint(encoded),
-		explainEncoded: (encoded) => explainEndpoint(encoded),
-		verifyEncoded: (encoded) => verifyEndpoint(encoded),
-		retryEncoded: (encoded) => retryEndpoint(encoded),
-		obligationsEncoded: (encoded) => obligationsEndpoint(encoded),
-		portCall: (encoded) => portCallEndpoint(encoded),
-		wake: () => wakeEndpoint
-	};
-	const EffectCfThreadObject = DurableObject.make(runtime, {
-		...options.rpcTracing === true ? { rpcTracing: { service: options.namespaceBinding } } : {},
-		...options.eventLayer === void 0 ? {} : { eventLayer: options.eventLayer },
-		initialize: Effect.void,
-		rpc,
-		alarm: () => alarmEndpoint
-	});
-	class ThreadObject extends EffectCfThreadObject {
-		alarm(alarmInfo) {
-			return super.alarm?.(alarmInfo);
-		}
-	}
-	return ThreadObject;
-};
-//#endregion
-//#region src/code-mode-executor.ts
-/**
-* The Cloudflare Dynamic Worker `CodeExecutor` adapter (C4 of ADR-0017;
-* DEPLOY-011). Each pass loads one fresh Worker through the Worker Loader
-* with `globalOutbound: null`, so generated code has no ambient network,
-* bindings, or secrets; its only authority is the pass-scoped RPC target that
-* routes back into the owning event's `CodeExecutionHost` service. Platform
-* CPU limits stop synchronous runaway programs; the executor-owned wall-clock
-* deadline interrupts asynchronously suspended passes. Deployment class `E`
-* only: the adapter records no persistent state and a later pass may run in a
-* completely different isolate.
-*/
-const dynamicWorkerImplementation = SandboxImplementation.make({
-	isolation: "isolated",
-	identity: "cloudflare-dynamic-worker"
-});
-/**
-* One object-capability endpoint for one execution pass. Workers RPC invokes
-* the target in the request context where it was created, so the native
-* Promise returned by `dispatch` and the Effect fiber that settles it share
-* one I/O owner. Passing the target as `run()`'s argument also scopes the
-* remote stub to that RPC call; no request state lives at module scope.
-*/
-var CodeModePassHostTarget = class extends RpcTarget {
-	#dispatch;
-	constructor(dispatch) {
-		super();
-		this.#dispatch = dispatch;
-	}
-	call(hostCall) {
-		return this.#dispatch(hostCall);
-	}
-};
-/**
-* The fixed harness loaded as the dynamic worker's main module. The generated
-* source becomes `program.mjs` (`export default (<expression>);`) — a module,
-* never `eval`. The harness installs namespace globals and a bounded console,
-* imports the program, invokes it exactly once, and returns one envelope the
-* host validates through Effect Schema.
-*/
-const HARNESS_MODULE = String.raw`
-import { WorkerEntrypoint } from "cloudflare:workers";
-import programDefault from "./program.js";
-
-const encoder = new TextEncoder();
-const utf8 = (text) => encoder.encode(text).byteLength;
-const safeText = (value) => {
-  try {
-    if (value instanceof Error) return (value.name + ": " + value.message).slice(0, 4000);
-    if (typeof value === "string") return value.slice(0, 4000);
-    const encoded = JSON.stringify(value);
-    return (encoded === undefined ? String(value) : encoded).slice(0, 4000);
-  } catch {
-    return "[unserializable value]";
-  }
-};
-const safeJson = (value) => {
-  try {
-    const encoded = JSON.stringify(value);
-    if (encoded !== undefined && encoded.length <= 4000) return JSON.parse(encoded);
-  } catch {}
-  return safeText(value);
-};
-
-export default class CodeModeHarness extends WorkerEntrypoint {
-  async run(host) {
-    const config = this.env.CODE_MODE_PASS;
-    const limits = config.limits;
-    const logs = [];
-    let logBytes = 0;
-    let fatal;
-    const boundedLogs = () => logs.slice(0, 4096);
-    const write = (...values) => {
-      const joined = values.map(safeText).join(" ");
-      const line = joined.length > 16000 ? joined.slice(0, 15999) + "…" : joined;
-      const bytes = utf8(line);
-      if (logs.length >= 4096 || logBytes + bytes > limits.maxLogBytes) {
-        fatal = fatal ?? { _tag: "log-limit", observed: logBytes + bytes, logs: boundedLogs() };
-        throw new Error("code-mode log limit exceeded");
-      }
-      logs.push(line);
-      logBytes += bytes;
-    };
-    globalThis.console = { log: write, info: write, warn: write, error: write, debug: write };
-
-    let hostCalls = 0;
-    const makeMethod = (namespace, method) => async (argument) => {
-      hostCalls += 1;
-      if (hostCalls > limits.maxHostCalls) {
-        fatal = fatal ?? { _tag: "host-call-limit", logs: boundedLogs() };
-        throw new Error("code-mode host-call limit exceeded");
-      }
-      let argText;
-      try {
-        argText = JSON.stringify(argument);
-      } catch {}
-      if (argText === undefined || utf8(argText) > limits.maxHostCallArgumentBytes) {
-        fatal = fatal ?? {
-          _tag: "argument-limit",
-          observed: argText === undefined ? 0 : utf8(argText),
-          logs: boundedLogs(),
-        };
-        throw new Error("code-mode host-call argument limit exceeded");
-      }
-      const outcome = await host.call({
-        namespace,
-        method,
-        argument: JSON.parse(argText),
-      });
-      if (outcome !== null && typeof outcome === "object" && outcome._tag === "CodeHostCallSuccess") {
-        return outcome.value;
-      }
-      if (outcome !== null && typeof outcome === "object" && outcome._tag === "CodeHostCallFailure") {
-        throw outcome.error;
-      }
-      fatal = fatal ?? { _tag: "protocol", message: "host returned an unrecognized outcome" };
-      throw new Error("code-mode host protocol violation");
-    };
-    for (const namespace of config.namespaces) {
-      const methods = {};
-      for (const method of namespace.methods) {
-        methods[method] = makeMethod(namespace.name, method);
-      }
-      globalThis[namespace.name] = methods;
-    }
-
-    // program.js is imported statically at the top of this module, so a
-    // syntactically invalid program fails the whole harness at load (mapped
-    // to a source error by the host). Using a static import keeps this module
-    // free of dynamic-import expressions, which single-script Miniflare hosts
-    // reject. The isolation boundary does NOT depend on the ordering of this
-    // import versus the console/namespace shims installed below: the loaded
-    // Worker has globalOutbound: null and no bindings, secrets, or env from
-    // the Worker Loader config BEFORE any module in the graph evaluates, so
-    // module-level program code has no ambient authority regardless. The
-    // shims below are usability wrappers (bounded console, namespace globals),
-    // and the accepted program is a single async-function expression whose
-    // body runs only when invoked here — after the shims exist.
-    const program = programDefault;
-    if (typeof program !== "function") {
-      return { _tag: "source-not-a-function", actual: typeof program };
-    }
-    try {
-      const value = await program();
-      if (fatal !== undefined) return fatal;
-      let text;
-      try {
-        text = JSON.stringify(value);
-      } catch {}
-      if (text === undefined) {
-        return {
-          _tag: "program-failed",
-          reason: "non-json-result",
-          thrown: null,
-          message: "The program must return a JSON value",
-          logs: boundedLogs(),
-        };
-      }
-      const resultBytes = utf8(text);
-      if (resultBytes > limits.maxResultBytes) {
-        return { _tag: "result-limit", observed: resultBytes, logs: boundedLogs() };
-      }
-      return {
-        _tag: "completed",
-        value: JSON.parse(text),
-        logs: boundedLogs(),
-        hostCalls,
-        logBytes,
-        resultBytes,
-      };
-    } catch (cause) {
-      if (fatal !== undefined) return fatal;
-      return {
-        _tag: "program-failed",
-        reason: cause instanceof Error ? "threw" : "rejected",
-        thrown: safeJson(cause),
-        message: safeText(cause),
-        logs: boundedLogs(),
-      };
-    }
-  }
-}
-`;
-const BoundedLogs = Schema.Array(Schema.String.check(Schema.isMaxLength(16384))).check(Schema.isMaxLength(4096));
-const HarnessCompleted = Schema.TaggedStruct("completed", {
-	value: Schema.Json,
-	logs: BoundedLogs,
-	hostCalls: Schema.Natural,
-	logBytes: Schema.Natural,
-	resultBytes: Schema.Natural
-});
-const HarnessSourceInvalid = Schema.TaggedStruct("source-invalid", { message: Schema.String });
-const HarnessNotAFunction = Schema.TaggedStruct("source-not-a-function", { actual: Schema.String });
-const HarnessProgramFailed = Schema.TaggedStruct("program-failed", {
-	reason: Schema.Literals([
-		"threw",
-		"rejected",
-		"non-json-result"
-	]),
-	thrown: Schema.Json,
-	message: Schema.String,
-	logs: BoundedLogs
-});
-const HarnessLogLimit = Schema.TaggedStruct("log-limit", {
-	observed: Schema.Natural,
-	logs: BoundedLogs
-});
-const HarnessArgumentLimit = Schema.TaggedStruct("argument-limit", {
-	observed: Schema.Natural,
-	logs: BoundedLogs
-});
-const HarnessResultLimit = Schema.TaggedStruct("result-limit", {
-	observed: Schema.Natural,
-	logs: BoundedLogs
-});
-const HarnessHostCallLimit = Schema.TaggedStruct("host-call-limit", { logs: BoundedLogs });
-const HarnessProtocol = Schema.TaggedStruct("protocol", { message: Schema.String });
-const HarnessOutcome = Schema.Union([
-	HarnessCompleted,
-	HarnessSourceInvalid,
-	HarnessNotAFunction,
-	HarnessProgramFailed,
-	HarnessLogLimit,
-	HarnessArgumentLimit,
-	HarnessResultLimit,
-	HarnessHostCallLimit,
-	HarnessProtocol
-]);
-const HarnessPassConfig = Schema.Struct({
-	namespaces: Schema.Array(Schema.Struct({
-		name: Schema.NonEmptyString,
-		methods: Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(64))
-	})).check(Schema.isMaxLength(32)),
-	limits: Schema.Struct({
-		maxLogBytes: Schema.Natural,
-		maxResultBytes: Schema.Natural,
-		maxHostCalls: Schema.Natural,
-		maxHostCallArgumentBytes: Schema.Natural
-	})
-});
-const encodeHarnessPassConfig = Schema.encodeSync(HarnessPassConfig);
-const encodeJsonPayload = Schema.encodeSync(Schema.fromJsonString(Schema.Json));
-const decodeJsonPayload = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json));
-const decodeHarnessOutcome = (value) => {
-	try {
-		return Schema.decodeUnknownOption(HarnessOutcome)(value);
-	} catch {
-		return Option.none();
-	}
-};
-const decodeHostCall = (value) => {
-	try {
-		return Schema.decodeUnknownOption(CodeHostCall)(value);
-	} catch {
-		return Option.none();
-	}
-};
-const decodeHostCallResult = (value) => {
-	try {
-		return Schema.decodeUnknownOption(CodeHostCallResult)(value);
-	} catch {
-		return Option.none();
-	}
-};
-/** Dispose a Cloudflare RPC handle when the runtime supplies its untyped disposal hook. @internal */
-const disposeRpcHandle = (handle) => Effect.try({
-	try: () => {
-		if (typeof handle !== "object" && typeof handle !== "function" || handle === null) return;
-		if (!(Symbol.dispose in handle)) return;
-		const dispose = Reflect.get(handle, Symbol.dispose);
-		if (typeof dispose === "function") Reflect.apply(dispose, handle, []);
-	},
-	catch: (cause) => safeCauseDiagnostic(cause, "The Cloudflare RPC disposal hook failed without a diagnostic")
-}).pipe(Effect.catch((diagnostic) => Effect.logWarning(`Cloudflare RPC handle disposal failed: ${diagnostic}`).pipe(Effect.ignoreCause)));
-const encodeHostResultPayload = (outcome) => {
-	try {
-		const payload = outcome._tag === "CodeHostCallSuccess" ? outcome.value : outcome.error;
-		const encodedPayload = encodeJsonPayload(payload);
-		return {
-			encodedPayload,
-			resultBytes: utf8ByteLength(encodedPayload)
-		};
-	} catch {
-		return;
-	}
-};
-const utf8ByteLength = (value) => {
-	let total = 0;
-	for (const character of value) {
-		const codePoint = character.codePointAt(0) ?? 0;
-		total += codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
-	}
-	return total;
-};
-/** Reserved global names the harness owns inside the dynamic worker. */
-const reservedHarnessGlobals = /* @__PURE__ */ new Set(["console"]);
-const makeExecute = (options, clock) => Effect.fn("DynamicWorkerCodeExecutor.execute")(function* (request) {
-	if (request.network._tag !== "NetworkDisabled") return yield* CodeExecutorUnsupportedError.make({
-		implementation: dynamicWorkerImplementation,
-		feature: "network",
-		message: "The Dynamic Worker executor denies all egress with globalOutbound: null; an allowlist is not supported in the first slice"
-	});
-	const sourceBytes = utf8ByteLength(request.source);
-	if (sourceBytes > request.limits.maxSourceBytes) return yield* CodeSourceError.make({
-		implementation: dynamicWorkerImplementation,
-		reason: "oversized",
-		message: `Source is ${sourceBytes} bytes; the request allows ${request.limits.maxSourceBytes}`
-	});
-	for (const namespace of request.namespaces) if (reservedHarnessGlobals.has(namespace.name)) return yield* CodeExecutorUnsupportedError.make({
-		implementation: dynamicWorkerImplementation,
-		feature: "namespaces",
-		message: `Namespace ${namespace.name} collides with a harness binding`
-	});
-	const host = yield* CodeExecutionHost;
-	const startedAt = clock.monotonicTimeNanosUnsafe();
-	const passDeadline = startedAt + Duration.toNanosUnsafe(request.limits.maxWallTime);
-	const remainingPassWallTime = () => {
-		const now = clock.monotonicTimeNanosUnsafe();
-		return Duration.nanos(passDeadline > now ? passDeadline - now : 0n);
-	};
-	let issuedHostCalls = 0;
-	let passOpen = true;
-	const queuedHostCalls = [];
-	let passFailure;
-	const failPass = (error) => {
-		if (passFailure === void 0) passFailure = error;
-	};
-	const rejectQueuedHostCalls = (reason) => {
-		for (const queued of queuedHostCalls.splice(0)) queued.reject(reason);
-	};
-	const queue = yield* Queue.unbounded();
-	const deliverHostOutcome = (queued, outcome) => Effect.gen(function* () {
-		const decoded = decodeHostCallResult(outcome);
-		if (Option.isNone(decoded)) {
-			const error = CodeExecutionProtocolError.make({
-				implementation: dynamicWorkerImplementation,
-				message: "The execution host returned a value outside the CodeHostCallResult schema"
-			});
-			failPass(error);
-			return yield* error;
-		}
-		const encoded = encodeHostResultPayload(decoded.value);
-		if (encoded === void 0 || encoded.resultBytes > request.limits.maxHostCallResultBytes) {
-			const error = CodeOutputLimitError.make({
-				implementation: dynamicWorkerImplementation,
-				surface: "host-call-result",
-				limit: request.limits.maxHostCallResultBytes,
-				observed: encoded?.resultBytes ?? 0,
-				logs: []
-			});
-			failPass(error);
-			return yield* error;
-		}
-		const normalizedPayload = decodeJsonPayload(encoded.encodedPayload);
-		if (Option.isNone(normalizedPayload)) {
-			const error = CodeExecutionProtocolError.make({
-				implementation: dynamicWorkerImplementation,
-				message: "The execution host returned a result that could not cross the JSON boundary"
-			});
-			failPass(error);
-			return yield* error;
-		}
-		queued.resolve(decoded.value._tag === "CodeHostCallSuccess" ? {
-			_tag: "CodeHostCallSuccess",
-			value: normalizedPayload.value
-		} : {
-			_tag: "CodeHostCallFailure",
-			error: normalizedPayload.value
-		});
-	});
-	const server = yield* Effect.gen(function* () {
-		while (true) {
-			const work = yield* Queue.take(queue);
-			if (work._tag === "limit") {
-				const error = CodeHostCallLimitError.make({
-					implementation: dynamicWorkerImplementation,
-					limit: request.limits.maxHostCalls,
-					logs: []
-				});
-				failPass(error);
-				return yield* error;
-			}
-			const queued = work.queued;
-			yield* host.call(queued.call).pipe(Effect.timeoutOrElse({
-				duration: remainingPassWallTime(),
-				orElse: () => {
-					const error = CodeExecutionTimeoutError.make({
-						implementation: dynamicWorkerImplementation,
-						kind: "wall-clock",
-						maxWallTime: request.limits.maxWallTime,
-						logs: []
-					});
-					failPass(error);
-					return error;
-				}
-			}), Effect.flatMap((outcome) => deliverHostOutcome(queued, outcome)), Effect.tapError(() => Effect.sync(() => queued.reject(/* @__PURE__ */ new Error("Code Mode host call failed")))), Effect.onInterrupt(() => Effect.sync(() => queued.reject(/* @__PURE__ */ new Error("Code Mode pass is closing")))));
-		}
-	}).pipe(Effect.forkScoped);
-	const dispatch = (hostCall) => {
-		if (!passOpen) return Promise.reject(/* @__PURE__ */ new Error("Code Mode pass is closing"));
-		issuedHostCalls += 1;
-		if (issuedHostCalls > request.limits.maxHostCalls) {
-			const error = CodeHostCallLimitError.make({
-				implementation: dynamicWorkerImplementation,
-				limit: request.limits.maxHostCalls,
-				logs: []
-			});
-			failPass(error);
-			Queue.offerUnsafe(queue, { _tag: "limit" });
-			return Promise.reject(/* @__PURE__ */ new Error("host-call limit exceeded"));
-		}
-		const decoded = decodeHostCall(hostCall);
-		if (Option.isNone(decoded)) return Promise.reject(/* @__PURE__ */ new TypeError("host calls must match the CodeHostCall schema"));
-		return new Promise((resolve, reject) => {
-			const queued = {
-				call: decoded.value,
-				resolve,
-				reject
-			};
-			queuedHostCalls.push(queued);
-			Queue.offerUnsafe(queue, {
-				_tag: "call",
-				queued
-			});
-		});
-	};
-	const closeAdmission = Effect.sync(() => {
-		passOpen = false;
-		rejectQueuedHostCalls(/* @__PURE__ */ new Error("Code Mode pass is closing"));
-	});
-	yield* Effect.addFinalizer(() => closeAdmission.pipe(Effect.andThen(Fiber.interrupt(server))));
-	const workerCode = {
-		compatibilityDate: options.compatibilityDate ?? "2025-05-01",
-		mainModule: "harness.js",
-		modules: {
-			"harness.js": HARNESS_MODULE,
-			"program.js": `export default (\n${request.source}\n);`
-		},
-		env: { CODE_MODE_PASS: encodeHarnessPassConfig({
-			namespaces: request.namespaces.map((namespace) => ({
-				name: namespace.name,
-				methods: namespace.methods
-			})),
-			limits: {
-				maxLogBytes: request.limits.maxLogBytes,
-				maxResultBytes: request.limits.maxResultBytes,
-				maxHostCalls: request.limits.maxHostCalls,
-				maxHostCallArgumentBytes: request.limits.maxHostCallArgumentBytes
-			}
-		}) },
-		globalOutbound: null,
-		...request.limits.cpuMillis === void 0 ? {} : { limits: {
-			cpuMs: request.limits.cpuMillis,
-			subRequests: request.limits.maxHostCalls + 8
-		} }
-	};
-	const worker = yield* Effect.acquireRelease(Effect.try({
-		try: () => options.loader.load(workerCode),
-		catch: (cause) => {
-			const text = safeCauseMessage(cause, "The Worker Loader failed without a diagnostic");
-			if (/syntaxerror|failed to (compile|parse)/i.test(text)) return CodeSourceError.make({
-				implementation: dynamicWorkerImplementation,
-				reason: "invalid",
-				message: text.slice(0, 8e3)
-			});
-			return CodeExecutorStartError.make({
-				implementation: dynamicWorkerImplementation,
-				message: `The Worker Loader rejected the pass: ${text}`.slice(0, 8e3),
-				cause
-			});
-		}
-	}), disposeRpcHandle);
-	const entrypoint = yield* Effect.acquireRelease(Effect.try({
-		try: () => worker.getEntrypoint(),
-		catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime)
-	}), disposeRpcHandle);
-	const rpc = Effect.tryPromise({
-		try: () => entrypoint.run(new CodeModePassHostTarget(dispatch)),
-		catch: (cause) => classifyWorkerFailure(cause, request.limits.maxWallTime)
-	});
-	const exit = yield* Effect.raceFirst(rpc.pipe(Effect.timeoutOrElse({
-		duration: remainingPassWallTime(),
-		orElse: () => CodeExecutionTimeoutError.make({
-			implementation: dynamicWorkerImplementation,
-			kind: "wall-clock",
-			maxWallTime: request.limits.maxWallTime,
-			logs: []
-		})
-	})), Fiber.join(server)).pipe(Effect.exit);
-	yield* closeAdmission;
-	yield* Fiber.interrupt(server);
-	if (passFailure !== void 0) return yield* passFailure;
-	if (Exit.isFailure(exit)) return yield* Effect.failCause(exit.cause);
-	const raw = exit.value;
-	const finishedAt = clock.monotonicTimeNanosUnsafe();
-	const outcome = decodeHarnessOutcome(raw);
-	if (Option.isNone(outcome)) return yield* CodeExecutionProtocolError.make({
-		implementation: dynamicWorkerImplementation,
-		message: "The dynamic worker returned a value outside the harness envelope schema"
-	});
-	switch (outcome.value._tag) {
-		case "completed": return CodeExecutionResult.make({
-			implementation: dynamicWorkerImplementation,
-			value: outcome.value.value,
-			logs: outcome.value.logs,
-			resourceUse: CodeExecutionResourceUse.make({
-				wallTime: Duration.nanos(finishedAt > startedAt ? finishedAt - startedAt : 0n),
-				hostCalls: outcome.value.hostCalls,
-				logBytes: outcome.value.logBytes,
-				resultBytes: outcome.value.resultBytes
-			})
-		});
-		case "source-invalid": return yield* CodeSourceError.make({
-			implementation: dynamicWorkerImplementation,
-			reason: "invalid",
-			message: outcome.value.message.slice(0, 8e3)
-		});
-		case "source-not-a-function": return yield* CodeSourceError.make({
-			implementation: dynamicWorkerImplementation,
-			reason: "not-a-function",
-			message: `The source expression evaluated to ${outcome.value.actual}; it must evaluate to one async function`
-		});
-		case "program-failed": return yield* CodeProgramFailedError.make({
-			implementation: dynamicWorkerImplementation,
-			reason: outcome.value.reason,
-			thrown: outcome.value.thrown,
-			message: outcome.value.message.slice(0, 8e3),
-			logs: outcome.value.logs
-		});
-		case "log-limit": return yield* CodeOutputLimitError.make({
-			implementation: dynamicWorkerImplementation,
-			surface: "logs",
-			limit: request.limits.maxLogBytes,
-			observed: outcome.value.observed,
-			logs: outcome.value.logs
-		});
-		case "argument-limit": return yield* CodeOutputLimitError.make({
-			implementation: dynamicWorkerImplementation,
-			surface: "host-call-argument",
-			limit: request.limits.maxHostCallArgumentBytes,
-			observed: outcome.value.observed,
-			logs: outcome.value.logs
-		});
-		case "result-limit": return yield* CodeOutputLimitError.make({
-			implementation: dynamicWorkerImplementation,
-			surface: "result",
-			limit: request.limits.maxResultBytes,
-			observed: outcome.value.observed,
-			logs: outcome.value.logs
-		});
-		case "host-call-limit": return yield* CodeHostCallLimitError.make({
-			implementation: dynamicWorkerImplementation,
-			limit: request.limits.maxHostCalls,
-			logs: outcome.value.logs
-		});
-		case "protocol": return yield* CodeExecutionProtocolError.make({
-			implementation: dynamicWorkerImplementation,
-			message: outcome.value.message.slice(0, 8e3)
-		});
-	}
-});
-/**
-* Expected worker-level failures map into the typed union with bounded
-* diagnostics; anything unrecognized stays a start/termination error rather
-* than a fabricated program result.
-*/
-const classifyWorkerFailure = (cause, maxWallTime) => {
-	const text = safeCauseDiagnostic(cause, "[unserializable worker failure]");
-	if (/syntaxerror|failed to (compile|parse)/i.test(text)) return CodeSourceError.make({
-		implementation: dynamicWorkerImplementation,
-		reason: "invalid",
-		message: text.slice(0, 8e3)
-	});
-	if (/cpu/i.test(text)) return CodeExecutionTimeoutError.make({
-		implementation: dynamicWorkerImplementation,
-		kind: "cpu",
-		maxWallTime,
-		logs: []
-	});
-	if (/failed to start worker/i.test(text)) return CodeExecutorStartError.make({
-		implementation: dynamicWorkerImplementation,
-		message: text.slice(0, 8e3),
-		cause
-	});
-	return CodeExecutorTerminatedError.make({
-		implementation: dynamicWorkerImplementation,
-		message: text.slice(0, 8e3)
-	});
-};
-/** Layer building the Dynamic Worker `CodeExecutor` from resolved bindings. */
-const dynamicWorkerCodeExecutorLayer = (options) => Layer.effect(CodeExecutor, Effect.gen(function* () {
-	const clock = yield* Clock.Clock;
-	return CodeExecutor.of({ execute: makeExecute(options, clock) });
-}));
-/** Assemble Code Mode handlers with the isolated Dynamic Worker executor. */
-const CloudflareCodeMode = { 
-/**
-* Provide the selected tool handlers at construction, where Code Mode captures them.
-* Their errors and remaining dependencies stay visible. The definition still owns the
-* allowlist and limits; the runtime supplies the live Tool broker for each scoped pass.
-*/
-layer: (definition, options) => definition.handlers.pipe(Layer.provide(options.handlers), Layer.provide(dynamicWorkerCodeExecutorLayer(options))) };
-//#endregion
-//#region src/memory.ts
-var MemoryObjectNamespace = class extends Context.Service()("@effect-agent/platform-cloudflare/MemoryObjectNamespace") {};
-/** Namespace version and identity are already canonicalized by MemoryNamespace. */
-const memoryObjectName = (namespace) => namespace.address;
-/**
-* Effect-native, host-bound memory client. Recall revalidates the entire admitted lookup
-* in one RPC and renders it locally. No retries or per-source splitting occur here.
-* Interrupted callers stop waiting; the owner has its own deadline. A timed-out write
-* may have committed: reconcile by sending the identical operation ID and command.
-*/
-const makeMemoryClient = Effect.fn("CloudflareMemoryClient.make")(function* (access, principal, rpcLimits = defaultMemoryRpcLimits) {
-	const validated = yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(rpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-	const bound = yield* Schema.decodeUnknownEffect(MemoryAccess.Wire)(access).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-	principal = yield* Schema.decodeUnknownEffect(Principal)(principal).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-	const { namespace } = yield* MemoryObjectNamespace;
-	const call = Effect.fn("CloudflareMemoryClient.call")(function* (request) {
-		const decoded = yield* Schema.decodeUnknownEffect(MemoryOwnerRequest)(request).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-		const encoded = yield* encodeMemoryWire(MemoryOwnerRequest, decoded, validated.maxRequestBytes);
-		const raw = yield* Effect.tryPromise({
-			try: () => namespace.get(namespace.idFromName(memoryObjectName(bound.namespace))).memory(encoded),
-			catch: () => MemoryRpcError.make({ reason: "unavailable" })
-		});
-		const response = yield* decodeMemoryWire(MemoryOwnerResponse, raw, validated.maxResponseBytes);
-		if (response._tag === "Failed") return yield* response.failure;
-		if (!MemoryNamespace.equals(response.access.namespace, bound.namespace) || response.access.scope !== bound.scope) return yield* MemoryRpcError.make({ reason: "protocol" });
-		return response;
-	});
-	const withinDeadline = (effect, timeoutMillis) => effect.pipe(Effect.timeoutOrElse({
-		duration: timeoutMillis,
-		orElse: () => Effect.fail(MemoryRpcError.make({ reason: "timeout" }))
-	}));
-	const revalidate = Effect.fn("CloudflareMemoryClient.revalidate")(function* (lookup, limits) {
-		limits = yield* Schema.decodeUnknownEffect(MemoryRecallLimits)(limits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-		const timeoutMillis = Math.min(validated.timeoutMillis, limits.timeoutMillis);
-		return yield* Effect.gen(function* () {
-			const response = yield* call({
-				_tag: "Revalidate",
-				version: 1,
-				access: bound,
-				principal,
-				lookup,
-				limits,
-				deadlineMillis: (yield* Clock.currentTimeMillis) + timeoutMillis
-			});
-			if (response._tag !== "Lookup") return yield* MemoryRpcError.make({ reason: "protocol" });
-			return response.lookup;
-		}).pipe((effect) => withinDeadline(effect, timeoutMillis));
-	});
-	const change = Effect.fn("CloudflareMemoryClient.change")(function* (write) {
-		if (!MemoryNamespace.equals(write.key.namespace, bound.namespace)) return yield* MemoryRpcError.make({ reason: "denied" });
-		return yield* Effect.gen(function* () {
-			const response = yield* call({
-				_tag: "Change",
-				version: 1,
-				access: bound,
-				principal,
-				write,
-				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
-			});
-			if (response._tag !== "Changed" || response.document.key.id !== write.key.id) return yield* MemoryRpcError.make({ reason: "protocol" });
-			return yield* MemoryDocument.restore(access.namespace, response.document);
-		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
-	});
-	const revalidateSemantic = Effect.fn("CloudflareMemoryClient.revalidateSemantic")(function* (found, profile, limits) {
-		return yield* Effect.gen(function* () {
-			const response = yield* call({
-				_tag: "RevalidateSemantic",
-				version: 1,
-				access: bound,
-				principal,
-				found,
-				profile,
-				limits,
-				deadlineMillis: (yield* Clock.currentTimeMillis) + validated.timeoutMillis
-			});
-			if (response._tag !== "Semantic") return yield* MemoryRpcError.make({ reason: "protocol" });
-			return response.result;
-		}).pipe((effect) => withinDeadline(effect, validated.timeoutMillis));
-	});
-	return {
-		recall: Effect.fn("CloudflareMemoryClient.recall")(function* (lookup, limits, estimateTokens) {
-			return yield* Memory.recall([{
-				id: "memory",
-				essential: true,
-				read: revalidate(lookup, limits)
-			}], limits, estimateTokens);
-		}),
-		revalidate,
-		revalidateSemantic,
-		change
-	};
-});
-const CloudflareMemoryClient = {
-	/** Bind access and principal using the MemoryObjectNamespace supplied by the application. */
-	make: makeMemoryClient,
-	/** Use a resolved Worker or Durable Object binding without manual service provisioning. */
-	fromBinding: Effect.fn("CloudflareMemoryClient.fromBinding")(function* (binding, options) {
-		return yield* makeMemoryClient(options.access, options.principal, options.rpcLimits).pipe(Effect.provideService(MemoryObjectNamespace, { namespace: binding }));
-	})
-};
-/**
-* Optional activity-processor destination. Keeps domain write errors intact; transport,
-* authorization and deadline failures become the existing MemoryStorageError contract.
-* Receipts remain authoritative, including after caller interruption or lost replies.
-*/
-const cloudflareMemoryWriterLayer = (access, principal, limits = defaultMemoryRpcLimits) => Layer.effect(MemoryWriter, Effect.gen(function* () {
-	const client = yield* CloudflareMemoryClient.make(access, principal, limits);
-	return MemoryWriter.fromAdapter({ change: (write) => client.change(write).pipe(Effect.catchTag("MemoryRpcError", (error) => Effect.fail(MemoryStorageError.make({
-		operation: `memory RPC ${error.reason}`,
-		reason: error.reason === "unavailable" || error.reason === "timeout" ? "unavailable" : "invalid-input"
-	}))), Effect.catchTag([
-		"MemoryRecallError",
-		"MemoryIndexError",
-		"SemanticMemoryError"
-	], () => Effect.fail(MemoryStorageError.make({
-		operation: "memory RPC response",
-		reason: "corrupt"
-	})))) });
-}));
-/**
-* Dedicated SQLite owner, independent of Thread lifetimes. The host binds authorization
-* after restoring its namespace definition from MemoryOwnerIdentity. Do not retain
-* cleanup-scoped resources in the host Layer; it lives for the DO incarnation.
-*/
-const makeMemoryObject = (host, options = {}) => {
-	const identity = Layer.effect(MemoryOwnerIdentity, Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		const address = yield* Schema.decodeUnknownEffect(MemoryNamespaceAddress)(state.raw.id.name).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "denied" })));
-		return { namespace: MemoryNamespace.Any.make({ address }) };
-	}));
-	const store = Layer.unwrap(Effect.map(DurableObjectState.DurableObjectState, (state) => doMemoryStoreLayerWithFailpoints(state.raw.storage, options.storageLimits ?? defaultDoMemoryStorageLimits))).pipe(Layer.provide(options.failpoints ?? MemoryMutationFailpoint.layer));
-	const application = Layer.merge(store, host).pipe(Layer.provideMerge(identity));
-	const runtime = Layer.effectContext(Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		const scope = yield* Effect.scope;
-		yield* Schema.decodeUnknownEffect(MemoryRpcLimits)(options.rpcLimits ?? defaultMemoryRpcLimits).pipe(Effect.mapError(() => MemoryRpcError.make({ reason: "protocol" })));
-		return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));
-	}));
-	return DurableObject.make(runtime, { rpc: { memory: (encoded) => handleMemoryOwnerRequest(encoded, options.rpcLimits) } });
-};
-const MemoryObject = { 
-/** Build the SQLite Durable Object class with the application's owner authorization Layer. */
-make: makeMemoryObject };
-//#endregion
-export { AbortRecorded, AdmissionLimitExceeded, ApprovalRecorded, AwaitProgressRequest, CLOUDFLARE_DATABASE_CAP_BYTES, CLOUDFLARE_RUNTIME_DEFAULTS, CancelProgressRequest, CloudflareAdmissionLimitsValue, CloudflareBindingError, CloudflareBrowser, CloudflareCodeMode, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflareMemoryClient, CloudflarePlatformConfigError, CloudflareSchedulingClient, CloudflareSubscriptionConfigError, CloudflareSubscriptionsClient, CloudflareThreadClient, DEFAULT_MAX_DATABASE_BYTES, DurableAlarmError, DurableAlarmService, DurableObjectContext, HostFailed, HostFailure, HostProtocolError, HostResponse, MaintenancePassReport, MemoryObject, MemoryObjectNamespace, ObservePageRequest, ObservedPage, ProgressCancelled, ProgressObserved, ProgressWaitRegistry, ScheduleAlarmProtocolError, ScheduleOwnerIdentity, ScheduleOwnerNamespace, ScheduleOwnerProtocolError, SettlementReached, SubmitRequest, SubmitSucceeded, SubscriptionAlarmProtocolError, SubscriptionPartitionIdentity, SubscriptionPartitionNamespace, SubscriptionPartitionProtocolError, ThreadClientError, ThreadMaintenance, ThreadMaintenanceFailpoint, thread_object_exports as ThreadObject, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPorts, UnknownResolutionRecorded, boundHostDiagnostic, cloudflareMemoryWriterLayer, cloudflarePreparedInputAdmissionLayer, cloudflareScheduledInputAdmissionLayer, cloudflareWakeSchedulerLayer, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeHostResponse, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, disposeRpcHandle, dynamicWorkerCodeExecutorLayer, dynamicWorkerImplementation, encodeAbortCommand, encodeApprovalDecisionCommand, encodeAwaitProgressRequest, encodeCancelProgressRequest, encodeHostResponse, encodeObservePageRequest, encodeReceipt, encodeSubmitRequest, encodeUnknownResolutionCommand, layerFromBindings, makeScheduleOwnerObjectClass, makeSubscriptionPartitionObjectClass, memoryObjectName, sourcePartitionName, threadNamespaceFromEnv, threadNamespaceLayer, threadPortTransportLayer, validateCloudflareSubscriptionLimits };
-
-//# sourceMappingURL=index.mjs.map
+import { t as CloudflareBindings_exports } from "./CloudflareBindings.mjs";
+import { t as CloudflareConfig_exports } from "./CloudflareConfig.mjs";
+import { t as Alarm_exports } from "./Alarm.mjs";
+import { t as CloudflareBrowser_exports } from "./CloudflareBrowser-1jeZx3_g.mjs";
+import { t as CloudflareCodeMode_exports } from "./CloudflareCodeMode.mjs";
+import { t as CloudflareMemory_exports } from "./CloudflareMemory.mjs";
+import { t as CloudflareThreadClient_exports } from "./CloudflareThreadClient.mjs";
+import { t as CloudflareScheduling_exports } from "./CloudflareScheduling.mjs";
+import { t as CloudflareSubscriptions_exports } from "./CloudflareSubscriptions.mjs";
+import { t as WakeScheduler_exports } from "./WakeScheduler.mjs";
+import { l as ThreadObject_exports } from "./ThreadObject-IrGuIO4a.mjs";
+export { Alarm_exports as Alarm, CloudflareBindings_exports as CloudflareBindings, CloudflareBrowser_exports as CloudflareBrowser, CloudflareCodeMode_exports as CloudflareCodeMode, CloudflareConfig_exports as CloudflareConfig, CloudflareMemory_exports as CloudflareMemory, CloudflareScheduling_exports as CloudflareScheduling, CloudflareSubscriptions_exports as CloudflareSubscriptions, CloudflareThreadClient_exports as CloudflareThreadClient, ThreadObject_exports as ThreadObject, WakeScheduler_exports as WakeScheduler };