@effect-agent/platform-cloudflare 0.1.0-beta.38 → 0.1.0-beta.40

package/dist/{scheduling-B-OFqoS9.mjs → prepared-admission-BKp_Upw2.mjs}

@@ -1,15 +1,14 @@
-import { Clock, Context, Crypto, DateTime, Duration, Effect, Layer, Option, Predicate, Random, Ref, Schema, Semaphore, Stream } from "effect";
-import { AbortCommand, AbortIntent, AdmissionConflict, AgentBindingResolver, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, ConversationNotMaterialized, ConversationStoreError, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, JoinedToHost, LedgerError, OperationDenied, PersistedJson, Principal, Receipt, ScheduleAuthorizationError, ScheduleCapacityError, ScheduleConflict, ScheduleDestination, ScheduleDriver, ScheduleFailpointError, ScheduleId, ScheduleNotFound, ScheduleOwner, ScheduleScope, ScheduleSnapshot, ScheduleSnapshotPage, ScheduleStorageError, ScheduleTimingRequest, ScheduleValidationError, ScheduleWakeNoop, ScheduledInputAdmission, ScheduledInputRetryable, Scheduling, Settlement, SettlementConflict, SubmissionLedger, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, defaultSchedulingLimits, scheduleOwnerKey } from "@effect-agent/session";
-import { DEFAULT_MAX_STORED_VALUE_BYTES, DoScheduleAlarmControl, DoScheduleTransaction, scheduleStoreLayer } from "@effect-agent/storage-cloudflare";
+import { Clock, Context, Crypto, Duration, Effect, Layer, Option, Predicate, Random, Ref, Schema, Semaphore, Stream } from "effect";
+import { DEFAULT_MAX_STORED_VALUE_BYTES } from "@effect-agent/storage-cloudflare";
+import { AbortCommand, AbortIntent, AdmissionConflict, AppendConflict, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, CanonicalRecordEnvelope, CanonicalSequence, DEFAULT_OWNERSHIP_LEASE_DURATION, DefinitionDigests, DeploymentId, DigestError, DurableAgentRuntime, DurableRuntimeFailpointError, FenceRejected, IdempotencyKey, JoinedToHost, LedgerError, OperationDenied, PersistedJson, PreparedInputAdmission, Principal, Receipt, ScheduleStorageError, ScheduledInputAdmission, ScheduledInputRetryable, Settlement, SettlementConflict, SubmissionLedger, ThreadNotMaterialized, ThreadStoreError, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent } from "@effect-agent/thread";
 import { AgentId, AgentInputError } from "@effect-agent/core";
 import { BrowserCrypto } from "@effect/platform-browser";
-import { SqliteClient } from "@effect/sql-sqlite-do";
-import { DurableObject, DurableObjectAlarm, DurableObjectState, RpcTracing } from "effect-cf";
+import { RpcTracing } from "effect-cf";
 //#region src/bindings.ts
 /**
 * 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 Conversation Object class constructs these Layers once
+* `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). */
@@ -18,13 +17,16 @@ var CloudflareBindingError = class extends Schema.TaggedError()("CloudflareBindi
 	message: Schema.String
 }) {};
 /**
-* The `DurableObjectNamespace` binding that addresses Conversation Objects. The Object
-* identity rule is `namespace.idFromName(conversationId)` (plan §1.2): Conversation IDs are
+* The `DurableObjectNamespace` binding that addresses Thread Objects. The Object
+* identity rule is `namespace.idFromName(threadId)` (plan §1.2): Thread IDs are
 * globally unique, so the mapping is total and deterministic and no directory service exists.
 */
-var ConversationObjectNamespace = class ConversationObjectNamespace extends Context.Service()("@effect-agent/platform-cloudflare/ConversationObjectNamespace") {
-	static layer(namespace) {
-		return Layer.succeed(ConversationObjectNamespace)({ namespace });
+var ThreadObjectNamespace = class ThreadObjectNamespace extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectNamespace") {
+	static layer(namespace, options = {}) {
+		return Layer.succeed(ThreadObjectNamespace)({
+			namespace,
+			...options.rpcTracing === void 0 ? {} : { rpcTracing: options.rpcTracing }
+		});
 	}
 };
 /**
@@ -33,7 +35,7 @@ var ConversationObjectNamespace = class ConversationObjectNamespace extends Cont
 * 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 conversationNamespaceFromEnv = Effect.fn("conversationNamespaceFromEnv")(function* (env, binding) {
+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."
@@ -54,14 +56,14 @@ const conversationNamespaceFromEnv = Effect.fn("conversationNamespaceFromEnv")(f
 	if (candidate !== void 0) return candidate;
 	return yield* CloudflareBindingError.make({
 		binding,
-		message: `env.${binding} is not a DurableObjectNamespace binding; declare the Conversation Object class under this binding in the Worker configuration.`
+		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 conversationNamespaceLayer = (env, binding, options = {}) => Layer.effect(ConversationObjectNamespace)(Effect.map(conversationNamespaceFromEnv(env, binding), (namespace) => ({
+const threadNamespaceLayer = (env, binding, options = {}) => Layer.effect(ThreadObjectNamespace)(Effect.map(threadNamespaceFromEnv(env, binding), (namespace) => ({
 	namespace,
 	...options.rpcTracing === true ? { rpcTracing: binding } : {}
 })));
@@ -79,11 +81,11 @@ var DurableObjectContext = class DurableObjectContext extends Context.Service()(
 	}
 };
 /**
-* The Conversation identity this Object serializes and the producer identity its Attempts
-* write with (`{producerPrefix}:{conversationId}`, plan §1.4). Derived once per incarnation
-* from `ctx.id.name` — the Object identity rule guarantees the name IS the Conversation ID.
+* 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 ConversationObjectIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ConversationObjectIdentity") {};
+var ThreadObjectIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadObjectIdentity") {};
 //#endregion
 //#region src/config.ts
 /**
@@ -103,7 +105,7 @@ var CloudflarePlatformConfigError = class extends Schema.TaggedError()("Cloudfla
 * (deployment spec §8, DEPLOY-007: "Admission has explicit bounded quota and overload
 * behavior... a typed rejection"). This is the DC analogue of `NodeDurableHost`'s
 * `AdmissionClosed` host gate: the port surface stays untouched, the refusal happens in the
-* Conversation Object's submit entry point before `DurableAgentRuntime.submit` runs, and
+* Thread Object's submit entry point before `DurableAgentRuntime.submit` runs, and
 * nothing was admitted or written.
 */
 var AdmissionLimitExceeded = class extends Schema.TaggedError()("AdmissionLimitExceeded", {
@@ -124,11 +126,11 @@ const CLOUDFLARE_DATABASE_CAP_BYTES = 1e10;
 /** Default database-size admission ceiling: a 1 GB safety margin under the platform cap. */
 const DEFAULT_MAX_DATABASE_BYTES = 9e9;
 /**
-* Explicit bounded admission quotas checked by the Conversation Object BEFORE admission
+* Explicit bounded admission quotas checked by the Thread Object BEFORE admission
 * (exit gate "resource limits are checked before admission").
 */
 var CloudflareAdmissionLimitsValue = class extends Schema.Class("@effect-agent/platform-cloudflare/CloudflareAdmissionLimitsValue")({
-	/** Maximum nonterminal Submissions per Conversation lane before new admissions refuse. */
+	/** Maximum nonterminal Submissions per Thread lane before new admissions refuse. */
 	maxQueueDepthPerLane: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(1e5)),
 	/** Maximum encoded input bytes; never above the storage per-value bound. */
 	maxInputBytes: Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(2e6)),
@@ -137,13 +139,13 @@ var CloudflareAdmissionLimitsValue = class extends Schema.Class("@effect-agent/p
 }) {};
 /**
 * Validated Cloudflare durable runtime configuration. The producer identity of one
-* Conversation Object is `{producerPrefix}:{conversationId}` — stable across incarnations of
+* Thread Object is `{producerPrefix}:{threadId}` — stable across incarnations of
 * the same deployment, distinct across deployments — and producer-epoch fencing (not the
 * producer name) remains the correctness authority (DUR-006).
 */
 var CloudflareDurableRuntimeConfigValue = class extends Schema.Class("@effect-agent/platform-cloudflare/CloudflareDurableRuntimeConfigValue")({
 	deploymentId: DeploymentId,
-	/** Head of the minted producer identity `{producerPrefix}:{conversationId}`. */
+	/** Head of the minted producer identity `{producerPrefix}:{threadId}`. */
 	producerPrefix: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
 	/** Submission ownership lease duration (D5); fences work across Object incarnations. */
 	ownershipLeaseDuration: PositiveMillis,
@@ -172,7 +174,7 @@ var CloudflareDurableRuntimeConfigValue = class extends Schema.Class("@effect-ag
 }) {};
 /** Explicit configuration authority for the assembled Cloudflare durable runtime. */
 var CloudflareDurableRuntimeConfig = class extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareDurableRuntimeConfig") {};
-/** Documented production defaults applied by `CloudflareDurableRuntime.layer`. */
+/** Documented production defaults applied by `ThreadObject.layer`. */
 const CLOUDFLARE_RUNTIME_DEFAULTS = {
 	ownershipLeaseDuration: Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION),
 	alarmBackoffBase: 100,
@@ -300,21 +302,21 @@ var MaintenancePassReport = class extends Schema.Class("@effect-agent/platform-c
 	alarm: Schema.Literals(["rearmed", "cleared"])
 }) {};
 /** Test-only fault authority; production uses the inert layer. */
-var ConversationMaintenanceFailpoint = class extends Context.Service()("@effect-agent/platform-cloudflare/ConversationMaintenanceFailpoint") {
+var ThreadMaintenanceFailpoint = class extends Context.Service()("@effect-agent/platform-cloudflare/ThreadMaintenanceFailpoint") {
 	static layer = Layer.succeed(this)({ hit: () => Effect.void });
 };
 const MaintenanceGeneration = Schema.BigIntFromString.check(Schema.isGreaterThanOrEqualToBigInt(0n));
 /** Versioned, platform-private maintenance state stored through Durable Object KV. */
-var ConversationMaintenanceState = class extends Schema.Class("@effect-agent/platform-cloudflare/ConversationMaintenanceState")({
+var ThreadMaintenanceState = class extends Schema.Class("@effect-agent/platform-cloudflare/ThreadMaintenanceState")({
 	schemaVersion: Schema.Literal(1),
 	dirty: MaintenanceGeneration,
 	processed: MaintenanceGeneration,
 	nonterminal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
 }) {};
-const MAINTENANCE_STATE_KEY = "effect-agent:conversation-maintenance:v1";
-const decodeMaintenanceState = Schema.decodeUnknownSync(ConversationMaintenanceState);
-const encodeMaintenanceState = Schema.encodeSync(ConversationMaintenanceState);
-const initialMaintenanceState = () => ConversationMaintenanceState.make({
+const MAINTENANCE_STATE_KEY = "effect-agent:thread-maintenance:v1";
+const decodeMaintenanceState = Schema.decodeUnknownSync(ThreadMaintenanceState);
+const encodeMaintenanceState = Schema.encodeSync(ThreadMaintenanceState);
+const initialMaintenanceState = () => ThreadMaintenanceState.make({
 	schemaVersion: 1,
 	dirty: 1n,
 	processed: 0n,
@@ -363,16 +365,15 @@ const stableExternalWait = (snapshot, reports) => {
 * 4. Stable external waits acknowledge and clear. Autonomous retry, indeterminate, and lease
 *    recovery states leave their generation dirty and retain bounded backoff rearming.
 */
-var ConversationMaintenance = class ConversationMaintenance extends Context.Service()("@effect-agent/platform-cloudflare/ConversationMaintenance") {
-	static layer = Layer.effect(ConversationMaintenance)(Effect.gen(function* () {
+var ThreadMaintenance = class ThreadMaintenance extends Context.Service()("@effect-agent/platform-cloudflare/ThreadMaintenance") {
+	static layer = (bindings) => Layer.effect(ThreadMaintenance)(Effect.gen(function* () {
 		const runtime = yield* DurableAgentRuntime;
-		const resolver = yield* AgentBindingResolver;
 		const ledger = yield* SubmissionLedger;
 		const alarm = yield* DurableAlarmService;
 		const config = yield* CloudflareDurableRuntimeConfig;
-		const identity = yield* ConversationObjectIdentity;
+		const identity = yield* ThreadObjectIdentity;
 		const { ctx } = yield* DurableObjectContext;
-		const failpoint = yield* ConversationMaintenanceFailpoint;
+		const failpoint = yield* ThreadMaintenanceFailpoint;
 		/**
 		* Consecutive no-progress passes — an in-memory CACHE, not state: a fresh incarnation
 		* restarts at zero and merely re-arms sooner than a long-lived one would have.
@@ -392,12 +393,12 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 			try: transaction,
 			catch: alarmFailure(operation)
 		});
-		const beginMutation = Effect.fn("ConversationMaintenance.beginMutation")(function* () {
+		const beginMutation = Effect.fn("ThreadMaintenance.beginMutation")(function* () {
 			yield* failpoint.hit("maintenance:dirty:before");
 			const now = yield* Clock.currentTimeMillis;
 			yield* runTransaction("advance maintenance generation", () => ctx.storage.transaction(async (transaction) => {
 				const { state } = await readMaintenanceState(transaction);
-				const next = ConversationMaintenanceState.make({
+				const next = ThreadMaintenanceState.make({
 					...state,
 					dirty: state.dirty + 1n
 				});
@@ -409,7 +410,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 		});
 		const endMutation = generationGate.withPermit(Ref.update(activeMutations, (active) => Math.max(0, active - 1)));
 		const withMutation = (body) => Effect.acquireUseRelease(generationGate.withPermit(beginMutation()), () => failpoint.hit("maintenance:mutation:armed").pipe(Effect.andThen(body), Effect.tap(() => failpoint.hit("maintenance:mutation:finished"))), () => endMutation);
-		const ensureAlarm = Effect.fn("ConversationMaintenance.ensureAlarm")(function* () {
+		const ensureAlarm = Effect.fn("ThreadMaintenance.ensureAlarm")(function* () {
 			yield* failpoint.hit("maintenance:ensure:before");
 			const now = yield* Clock.currentTimeMillis;
 			yield* runTransaction("ensure maintenance alarm", () => ctx.storage.transaction(async (transaction) => {
@@ -419,7 +420,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 			}));
 			yield* failpoint.hit("maintenance:ensure:after");
 		});
-		const beginPass = Effect.fn("ConversationMaintenance.beginPass")(function* () {
+		const beginPass = Effect.fn("ThreadMaintenance.beginPass")(function* () {
 			yield* failpoint.hit("maintenance:begin:before");
 			const now = yield* Clock.currentTimeMillis;
 			const result = yield* runTransaction("begin maintenance pass", () => ctx.storage.transaction(async (transaction) => {
@@ -441,7 +442,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 			yield* failpoint.hit("maintenance:begin:after");
 			return result;
 		});
-		const rearmDelay = Effect.fn("ConversationMaintenance.rearmDelay")(function* (progressed) {
+		const rearmDelay = Effect.fn("ThreadMaintenance.rearmDelay")(function* (progressed) {
 			const priorStalls = yield* Ref.getAndUpdate(stalls, (count) => progressed ? 0 : count + 1);
 			if (progressed) return config.alarmBackoffBase;
 			const exponent = Math.min(priorStalls, 30);
@@ -450,7 +451,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 			const jittered = Math.ceil(backoff / 2 + backoff / 2 * jitter);
 			return Math.min(jittered, config.wakeScanInterval);
 		});
-		const pass = Effect.fn("ConversationMaintenance.pass")(function* () {
+		const pass = Effect.fn("ThreadMaintenance.pass")(function* () {
 			const annotate = (report) => Effect.annotateCurrentSpan({
 				phase: report.phase,
 				recovered: report.recovered,
@@ -473,7 +474,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 				alarm: "cleared"
 			}));
 			const recovered = yield* runtime.runRecovery;
-			const settlements = yield* runtime.processConversationResolved(identity.conversationId).pipe(Effect.provideService(AgentBindingResolver, resolver));
+			const settlements = yield* runtime.processThreadResolved(identity.threadId, bindings);
 			const remaining = yield* Stream.runCollect(ledger.scanNonterminal);
 			const reports = new Map(recovered.map((report) => [report.submissionId, report]));
 			const head = remaining[0];
@@ -491,7 +492,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 				return yield* runTransaction("finish maintenance pass", () => ctx.storage.transaction(async (transaction) => {
 					const { state } = await readMaintenanceState(transaction);
 					const processed = autonomous || started.activeAtStart > 0 || active > 0 ? state.processed : state.processed > started.generation ? state.processed : started.generation;
-					const next = ConversationMaintenanceState.make({
+					const next = ThreadMaintenanceState.make({
 						...state,
 						processed,
 						nonterminal: remaining.length
@@ -519,7 +520,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 				alarm: alarmDisposition
 			}));
 		});
-		return ConversationMaintenance.of({
+		return ThreadMaintenance.of({
 			pass: alarm.withWakesDeferred(maintenancePassGate.withPermit(pass())),
 			ensureAlarm: ensureAlarm(),
 			withMutation
@@ -529,7 +530,7 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 //#endregion
 //#region src/client.ts
 /**
-* The Worker↔Conversation-Object host protocol (plan §1.4): Schema envelopes for the host
+* The Worker↔Thread-Object host protocol (plan §1.4): Schema envelopes for the host
 * entry points (`submitEncoded`, `awaitSettlementEncoded`, `observePage`, `abortEncoded`,
 * `resolveApprovalEncoded`, `resolveUnknownEncoded`) plus the Worker-side client that speaks
 * it. Mirrors the WP2 port protocol: requests and responses are closed Schema unions, typed
@@ -540,15 +541,15 @@ var ConversationMaintenance = class ConversationMaintenance extends Context.Serv
 const MAX_HOST_DIAGNOSTIC_LENGTH = 4096;
 const BoundedDiagnostic = Schema.String.check(Schema.isMaxLength(MAX_HOST_DIAGNOSTIC_LENGTH));
 /** Truncate a diagnostic string to the host protocol's bounded length. */
-const boundHostDiagnostic = (value) => value.length > MAX_HOST_DIAGNOSTIC_LENGTH ? `${value.slice(0, MAX_HOST_DIAGNOSTIC_LENGTH - 3)}...` : value;
+const boundHostDiagnostic = (value) => value.length > MAX_HOST_DIAGNOSTIC_LENGTH ? `${value.slice(0, 4093)}...` : value;
 /**
 * The envelope itself could not be honored: the Object could not decode the request, or a
 * response could not be encoded/decoded. Never carries operation semantics.
 */
 var HostProtocolError = class extends Schema.TaggedError()("HostProtocolError", { message: BoundedDiagnostic }) {};
 /** The Worker-side stub call itself failed (RPC rejection, overload, eviction mid-call). */
-var ConversationClientError = class extends Schema.TaggedError()("ConversationClientError", {
-	conversationId: Schema.String,
+var ThreadClientError = class extends Schema.TaggedError()("ThreadClientError", {
+	threadId: Schema.String,
 	message: Schema.String,
 	cause: Schema.optionalKey(Schema.Defect()),
 	/** Cloudflare's own classification for a failure safe to retry with a fresh stub. */
@@ -560,7 +561,7 @@ var ConversationClientError = class extends Schema.TaggedError()("ConversationCl
 * One durable submission, input ALREADY encoded by the caller through the Agent Binding's
 * input schema (the Worker bundles the same Agent definitions as the Object, so schema
 * validation happens client-side; the resolved Binding re-validates at claim time). The
-* Conversation identity is deliberately absent — the addressed Object IS the lane.
+* Thread identity is deliberately absent — the addressed Object IS the lane.
 */
 var SubmitRequest = class extends Schema.Class("@effect-agent/platform-cloudflare/SubmitRequest")({
 	agentId: AgentId,
@@ -596,8 +597,8 @@ const HostFailure = Schema.Union([
 	UnknownResolutionConflict,
 	JoinedToHost,
 	LedgerError,
-	ConversationStoreError,
-	ConversationNotMaterialized,
+	ThreadStoreError,
+	ThreadNotMaterialized,
 	AppendConflict,
 	FenceRejected,
 	DurableRuntimeFailpointError,
@@ -647,14 +648,14 @@ const decodeUnknownResolutionCommand = Schema.decodeUnknownEffect(UnknownResolut
 const encodeUnknownResolutionCommand = Schema.encodeEffect(UnknownResolutionCommand);
 const encodeHostResponse = Schema.encodeEffect(HostResponse);
 const decodeHostResponse = Schema.decodeUnknownEffect(HostResponse);
-/** Failure surface of `CloudflareConversationClient.submit`. */
+/** Failure surface of `CloudflareThreadClient.submit`. */
 const ClientSubmitHostFailure = Schema.Union([
 	AgentInputError,
 	DigestError,
 	AdmissionConflict,
 	LedgerError,
-	ConversationStoreError,
-	ConversationNotMaterialized,
+	ThreadStoreError,
+	ThreadNotMaterialized,
 	AppendConflict,
 	FenceRejected,
 	DurableRuntimeFailpointError,
@@ -665,15 +666,17 @@ const ClientSubmitHostFailure = Schema.Union([
 const ClientAwaitHostFailure = Schema.Union([
 	LedgerError,
 	SettlementConflict,
+	OperationDenied,
 	HostProtocolError
 ]);
 const ClientObserveHostFailure = Schema.Union([
-	ConversationStoreError,
-	ConversationNotMaterialized,
+	ThreadStoreError,
+	ThreadNotMaterialized,
 	OperationDenied,
 	HostProtocolError
 ]);
 const ClientAbortHostFailure = Schema.Union([
+	OperationDenied,
 	LedgerError,
 	SettlementConflict,
 	JoinedToHost,
@@ -699,9 +702,9 @@ const ClientUnknownHostFailure = Schema.Union([
 	DurableAlarmError,
 	HostProtocolError
 ]);
-const outOfContract = (conversationId, operation, observed) => ConversationClientError.make({
-	conversationId,
-	message: boundHostDiagnostic(`The Conversation Object answered ${operation} with the out-of-contract ${observed}.`)
+const outOfContract = (threadId, operation, observed) => ThreadClientError.make({
+	threadId,
+	message: boundHostDiagnostic(`The Thread Object answered ${operation} with the out-of-contract ${observed}.`)
 });
 const hostRpcMethods = {
 	submit: "submitEncoded",
@@ -713,52 +716,60 @@ const hostRpcMethods = {
 	resolveApproval: "resolveApprovalEncoded",
 	resolveUnknown: "resolveUnknownEncoded"
 };
-/** Worker-side client over the Conversation Object namespace (DEPLOY-010). */
-var CloudflareConversationClient = class CloudflareConversationClient extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareConversationClient") {
-	static layer = Layer.effect(CloudflareConversationClient)(Effect.gen(function* () {
-		const { namespace, rpcTracing } = yield* ConversationObjectNamespace;
+/** Worker-side client over the Thread Object namespace (DEPLOY-010). */
+var CloudflareThreadClient = class CloudflareThreadClient extends Context.Service()("@effect-agent/platform-cloudflare/CloudflareThreadClient") {
+	/**
+	* Assemble the client from a resolved namespace and the platform Crypto implementation.
+	* rpcTracing is the binding name and remains opt-in. Caller authentication, principals,
+	* idempotency keys, and definition digests are still explicit submission inputs.
+	*/
+	static layerFromBinding(options) {
+		return CloudflareThreadClient.layer.pipe(Layer.provide([ThreadObjectNamespace.layer(options.namespace, options), BrowserCrypto.layer]));
+	}
+	static layer = Layer.effect(CloudflareThreadClient)(Effect.gen(function* () {
+		const { namespace, rpcTracing } = yield* ThreadObjectNamespace;
 		const crypto = yield* Crypto.Crypto;
-		const call = Effect.fn(function* (conversationId, operation, encoded) {
+		const call = Effect.fn(function* (threadId, operation, encoded) {
 			const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
 			const raw = yield* Effect.tryPromise({
 				try: () => {
-					return namespace.get(namespace.idFromName(conversationId))[hostRpcMethods[operation]](encoded, ...traceArgs);
+					return namespace.get(namespace.idFromName(threadId))[hostRpcMethods[operation]](encoded, ...traceArgs);
 				},
-				catch: (cause) => ConversationClientError.make({
-					conversationId,
-					message: boundHostDiagnostic(`${operation} did not reach the Conversation Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
+				catch: (cause) => ThreadClientError.make({
+					threadId,
+					message: boundHostDiagnostic(`${operation} did not reach the Thread Object: ${safeCauseMessage(cause, "the RPC failed without a diagnostic")}`),
 					cause,
 					...cloudflareFailureSignals(cause)
 				})
 			});
 			return yield* decodeHostResponse(raw).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`The ${operation} answer could not be decoded: ${error.message}`) })));
-		}, (effect, conversationId, operation) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflareConversationClient.call", { attributes: {
-			conversationId,
+		}, (effect, threadId, operation) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflareThreadClient.call", { attributes: {
+			threadId,
 			operation
 		} }) : RpcTracing.withRpcClientSpan(effect, rpcTracing, hostRpcMethods[operation]));
-		const expect = (conversationId, operation, resultSchema, failureSchema) => {
+		const expect = (threadId, operation, resultSchema, failureSchema) => {
 			const isExpectedResult = Schema.is(resultSchema);
 			const isExpectedFailure = Schema.is(failureSchema);
 			return (response) => {
 				if (response._tag === "HostFailed") {
 					const failure = response.failure;
-					return isExpectedFailure(failure) ? Effect.fail(failure) : Effect.fail(outOfContract(conversationId, operation, `failure ${failure._tag}`));
+					return isExpectedFailure(failure) ? Effect.fail(failure) : Effect.fail(outOfContract(threadId, operation, `failure ${failure._tag}`));
 				}
-				if (!isExpectedResult(response)) return Effect.fail(outOfContract(conversationId, operation, `result ${response._tag}`));
+				if (!isExpectedResult(response)) return Effect.fail(outOfContract(threadId, operation, `result ${response._tag}`));
 				return Effect.succeed(response);
 			};
 		};
-		const readPage = (conversationId, options) => Effect.gen(function* () {
+		const readPage = (threadId, options) => Effect.gen(function* () {
 			const request = ObservePageRequest.make({
 				...options?.afterSequence === void 0 ? {} : { afterSequence: options.afterSequence },
 				limit: options?.limit ?? 256
 			});
 			const encoded = yield* encodeObservePageRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`observePage request encode failed: ${error.message}`) })));
-			const response = yield* call(conversationId, "observePage", encoded);
-			return (yield* expect(conversationId, "observePage", ObservedPage, ClientObserveHostFailure)(response)).records;
+			const response = yield* call(threadId, "observePage", encoded);
+			return (yield* expect(threadId, "observePage", ObservedPage, ClientObserveHostFailure)(response)).records;
 		});
-		const cancelProgress = (conversationId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(conversationId, "cancelProgress", encoded)), Effect.asVoid, Effect.ignore);
-		return CloudflareConversationClient.of({
+		const cancelProgress = (threadId, waiterId) => encodeCancelProgressRequest(CancelProgressRequest.make({ waiterId })).pipe(Effect.mapError(() => void 0), Effect.flatMap((encoded) => call(threadId, "cancelProgress", encoded)), Effect.asVoid, Effect.ignore);
+		return CloudflareThreadClient.of({
 			submit: (agent, input, options) => Effect.gen(function* () {
 				const encodedInput = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError((cause) => AgentInputError.make({ message: `Unable to encode Agent input: ${cause.message}` })));
 				const inputPayload = yield* Schema.decodeUnknownEffect(PersistedJson)(encodedInput).pipe(Effect.mapError(() => AgentInputError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
@@ -770,30 +781,30 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 					inputPayload
 				});
 				const encoded = yield* encodeSubmitRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`submit request encode failed: ${error.message}`) })));
-				const response = yield* call(options.conversationId, "submit", encoded);
-				return (yield* expect(options.conversationId, "submit", SubmitSucceeded, ClientSubmitHostFailure)(response)).receipt;
+				const response = yield* call(options.threadId, "submit", encoded);
+				return (yield* expect(options.threadId, "submit", SubmitSucceeded, ClientSubmitHostFailure)(response)).receipt;
 			}),
 			awaitSettlement: (receipt) => Effect.gen(function* () {
 				const encoded = yield* encodeReceipt(receipt).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`receipt encode failed: ${error.message}`) })));
-				const response = yield* call(receipt.conversationId, "awaitSettlement", encoded);
-				return (yield* expect(receipt.conversationId, "awaitSettlement", SettlementReached, ClientAwaitHostFailure)(response)).settlement;
+				const response = yield* call(receipt.threadId, "awaitSettlement", encoded);
+				return (yield* expect(receipt.threadId, "awaitSettlement", SettlementReached, ClientAwaitHostFailure)(response)).settlement;
 			}),
-			awaitProgress: (conversationId, afterSequence) => Effect.gen(function* () {
+			awaitProgress: (threadId, afterSequence) => Effect.gen(function* () {
 				const waiterId = yield* crypto.randomUUIDv4.pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress cancellation identity generation failed: ${error.message}`) })));
 				const request = AwaitProgressRequest.make({
 					afterSequence,
 					waiterId
 				});
 				const encoded = yield* encodeAwaitProgressRequest(request).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`awaitProgress request encode failed: ${error.message}`) })));
-				const attempt = (retry) => call(conversationId, "awaitProgress", encoded).pipe(Effect.flatMap(expect(conversationId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, Effect.catchTag("ConversationClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
-				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(conversationId, waiterId)));
+				const attempt = (retry) => call(threadId, "awaitProgress", encoded).pipe(Effect.flatMap(expect(threadId, "awaitProgress", ProgressObserved, ClientObserveHostFailure)), Effect.asVoid, Effect.catchTag("ThreadClientError", (error) => error.retryable === true && error.overloaded !== true && retry < 5 ? Effect.sleep(Duration.millis(10 * 2 ** retry)).pipe(Effect.andThen(attempt(retry + 1))) : Effect.fail(error)));
+				yield* attempt(0).pipe(Effect.onInterrupt(() => cancelProgress(threadId, waiterId)));
 			}),
 			readPage,
-			readAll: (conversationId) => Effect.gen(function* () {
+			readAll: (threadId) => Effect.gen(function* () {
 				const all = [];
 				let after;
 				for (;;) {
-					const page = yield* readPage(conversationId, {
+					const page = yield* readPage(threadId, {
 						afterSequence: after,
 						limit: 1024
 					});
@@ -803,387 +814,77 @@ var CloudflareConversationClient = class CloudflareConversationClient extends Co
 					after = last.sequence;
 				}
 			}),
-			abort: (conversationId, command) => Effect.gen(function* () {
+			abort: (threadId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeAbortCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`abort command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "abort", encoded);
-				return (yield* expect(conversationId, "abort", AbortRecorded, ClientAbortHostFailure)(response)).intent;
+				const response = yield* call(threadId, "abort", encoded);
+				return (yield* expect(threadId, "abort", AbortRecorded, ClientAbortHostFailure)(response)).intent;
 			}),
-			resolveApproval: (conversationId, command) => Effect.gen(function* () {
+			resolveApproval: (threadId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeApprovalDecisionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`approval command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "resolveApproval", encoded);
-				return (yield* expect(conversationId, "resolveApproval", ApprovalRecorded, ClientApprovalHostFailure)(response)).intent;
+				const response = yield* call(threadId, "resolveApproval", encoded);
+				return (yield* expect(threadId, "resolveApproval", ApprovalRecorded, ClientApprovalHostFailure)(response)).intent;
 			}),
-			resolveUnknown: (conversationId, command) => Effect.gen(function* () {
+			resolveUnknown: (threadId, command) => Effect.gen(function* () {
 				const encoded = yield* encodeUnknownResolutionCommand(command).pipe(Effect.mapError((error) => HostProtocolError.make({ message: boundHostDiagnostic(`resolution command encode failed: ${error.message}`) })));
-				const response = yield* call(conversationId, "resolveUnknown", encoded);
-				return (yield* expect(conversationId, "resolveUnknown", UnknownResolutionRecorded, ClientUnknownHostFailure)(response)).intent;
+				const response = yield* call(threadId, "resolveUnknown", encoded);
+				return (yield* expect(threadId, "resolveUnknown", UnknownResolutionRecorded, ClientUnknownHostFailure)(response)).intent;
 			})
 		});
 	}));
 };
 //#endregion
-//#region src/scheduling.ts
-const SCHEDULE_ALARM_TAG = "effect-agent/ScheduleOwnerWake";
-const SCHEDULE_ALARM_ID = "driver";
-const ScheduleAlarmPayload = Schema.Struct({
-	schemaVersion: Schema.Literal(1),
-	generation: Schema.Int.check(Schema.isGreaterThan(0))
-});
-var ScheduleAlarmProtocolError = class extends Schema.TaggedError()("ScheduleAlarmProtocolError", { message: Schema.String }) {};
-const boundedProtocolMessage = (message) => message.length <= 4096 ? message : `${message.slice(0, 4093)}...`;
-var ScheduleOwnerProtocolError = class extends Schema.TaggedError()("ScheduleOwnerProtocolError", { message: Schema.String.check(Schema.isMaxLength(4096)) }) {};
-const ScheduleMutationRequestFields = {
-	schemaVersion: Schema.Literal(1),
-	agentId: AgentId,
-	input: PersistedJson,
-	scope: ScheduleScope,
-	scheduleId: ScheduleId,
-	timing: ScheduleTimingRequest,
-	destination: ScheduleDestination,
-	deliveryPrincipal: ScheduleScope.fields.principal,
-	definitions: DefinitionDigests
-};
-const ScheduleCreateRequest = Schema.TaggedStruct("Create", ScheduleMutationRequestFields);
-const ScheduleUpdateRequest = Schema.TaggedStruct("Update", {
-	...ScheduleMutationRequestFields,
-	expectedRevision: Schema.Int.check(Schema.isGreaterThan(0))
-});
-const ScheduleGetRequest = Schema.TaggedStruct("Get", {
-	schemaVersion: Schema.Literal(1),
-	scope: ScheduleScope,
-	scheduleId: ScheduleId
-});
-const ScheduleListRequest = Schema.TaggedStruct("List", {
-	schemaVersion: Schema.Literal(1),
-	scope: ScheduleScope,
-	after: Schema.optionalKey(ScheduleId),
-	limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)))
-});
-const ScheduleControlRequest = Schema.TaggedStruct("Control", {
-	schemaVersion: Schema.Literal(1),
-	operation: Schema.Literals([
-		"pause",
-		"resume",
-		"cancel"
-	]),
-	scope: ScheduleScope,
-	scheduleId: ScheduleId,
-	expectedRevision: Schema.Int.check(Schema.isGreaterThan(0))
-});
-const ScheduleOwnerRequest = Schema.Union([
-	ScheduleCreateRequest,
-	ScheduleUpdateRequest,
-	ScheduleGetRequest,
-	ScheduleListRequest,
-	ScheduleControlRequest
-]);
-const ScheduleOwnerFailure = Schema.Union([
-	ScheduleValidationError,
-	ScheduleAuthorizationError,
-	ScheduleConflict,
-	ScheduleNotFound,
-	ScheduleCapacityError,
-	ScheduleStorageError,
-	ScheduleFailpointError,
-	ScheduleOwnerProtocolError
-]);
-const ScheduleOwnerResponse = Schema.Union([
-	Schema.TaggedStruct("Snapshot", { value: ScheduleSnapshot }),
-	Schema.TaggedStruct("Page", { value: ScheduleSnapshotPage }),
-	Schema.TaggedStruct("Failed", { failure: ScheduleOwnerFailure })
-]);
-const decodeScheduleOwnerRequest = Schema.decodeUnknownEffect(ScheduleOwnerRequest);
-const encodeScheduleOwnerRequest = Schema.encodeEffect(ScheduleOwnerRequest);
-const decodeScheduleOwnerResponse = Schema.decodeUnknownEffect(ScheduleOwnerResponse);
-const encodeScheduleOwnerResponse = Schema.encodeEffect(ScheduleOwnerResponse);
-const scheduleProtocolFailure = (message) => ({
-	_tag: "Failed",
-	failure: ScheduleOwnerProtocolError.make({ message: boundedProtocolMessage(message) })
-});
-var ScheduleOwnerNamespace = class extends Context.Service()("@effect-agent/platform-cloudflare/ScheduleOwnerNamespace") {};
+//#region src/prepared-admission.ts
 const passthroughAgent = (agentId) => ({ definition: {
 	id: agentId,
 	input: PersistedJson
 } });
-const requestOwner = (request) => request.scope.owner;
-/** Provides the same authorized management service as NodeScheduling.layer. */
-var CloudflareSchedulingClient = class {
-	static layer = Layer.effect(Scheduling, Effect.gen(function* () {
-		const { namespace } = yield* ScheduleOwnerNamespace;
-		const call = Effect.fn("CloudflareSchedulingClient.call")(function* (owner, request) {
-			const encoded = yield* encodeScheduleOwnerRequest(request).pipe(Effect.mapError(() => ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			})));
-			const raw = yield* Effect.tryPromise({
-				try: () => namespace.get(namespace.idFromName(scheduleOwnerKey(owner))).schedule(encoded),
-				catch: () => ScheduleStorageError.make({
-					operation: "call Schedule Owner",
-					reason: "unavailable"
-				})
-			});
-			const response = yield* decodeScheduleOwnerResponse(raw).pipe(Effect.mapError(() => ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			})));
-			if (response._tag !== "Failed") return response;
-			return yield* response.failure._tag === "ScheduleOwnerProtocolError" ? ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			}) : response.failure;
-		});
-		const encodeInput = Effect.fn("CloudflareSchedulingClient.encodeInput")(function* (agent, input) {
-			const encoded = yield* Schema.encodeEffect(agent.definition.input)(input).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Unable to encode Agent input" })));
-			return yield* Schema.decodeUnknownEffect(PersistedJson)(encoded).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Agent input does not satisfy the canonical persistence bounds" })));
-		});
-		const create = (agent, input, options) => Effect.gen(function* () {
-			const payload = yield* encodeInput(agent, input);
-			const response = yield* call(options.scope.owner, {
-				_tag: "Create",
-				schemaVersion: 1,
-				agentId: agent.definition.id,
-				input: payload,
-				...options
-			});
-			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			});
-		});
-		const update = (agent, input, options) => Effect.gen(function* () {
-			const payload = yield* encodeInput(agent, input);
-			const response = yield* call(options.scope.owner, {
-				_tag: "Update",
-				schemaVersion: 1,
-				agentId: agent.definition.id,
-				input: payload,
-				...options
-			});
-			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			});
-		});
-		const get = (scope, scheduleId) => Effect.gen(function* () {
-			const response = yield* call(scope.owner, {
-				_tag: "Get",
-				schemaVersion: 1,
-				scope,
-				scheduleId
-			});
-			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			});
-		});
-		const list = (scope, options = {}) => Effect.gen(function* () {
-			const response = yield* call(scope.owner, {
-				_tag: "List",
-				schemaVersion: 1,
-				scope,
-				...options.after === void 0 ? {} : { after: options.after },
-				...options.limit === void 0 ? {} : { limit: options.limit }
-			});
-			return response._tag === "Page" ? response.value : yield* ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			});
-		});
-		const control = (operation, scope, scheduleId, expectedRevision) => Effect.gen(function* () {
-			const response = yield* call(scope.owner, {
-				_tag: "Control",
-				schemaVersion: 1,
-				operation,
-				scope,
-				scheduleId,
-				expectedRevision
-			});
-			return response._tag === "Snapshot" ? response.value : yield* ScheduleStorageError.make({
-				operation: "Schedule Owner protocol",
-				reason: "corrupt"
-			});
-		});
-		return Scheduling.of({
-			create,
-			update,
-			get,
-			list,
-			pause: (scope, id, revision) => control("pause", scope, id, revision),
-			resume: (scope, id, revision) => control("resume", scope, id, revision),
-			cancel: (scope, id, revision) => control("cancel", scope, id, revision)
-		});
-	}));
-};
-var ScheduleOwnerIdentity = class extends Context.Service()("@effect-agent/platform-cloudflare/ScheduleOwnerIdentity") {};
-const decodeOwnerName = Effect.fn("decodeScheduleOwnerName")(function* (name) {
-	if (name === null || name === void 0) return yield* ScheduleOwnerProtocolError.make({ message: "Schedule Owner objects require an idFromName identity" });
-	const tuple = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Tuple([Schema.String, Schema.String])))(name).pipe(Effect.mapError(() => ScheduleOwnerProtocolError.make({ message: "Schedule Owner object name is malformed" })));
-	return yield* Schema.decodeUnknownEffect(ScheduleOwner)({
-		tenantId: tuple[0],
-		ownerId: tuple[1]
-	}).pipe(Effect.mapError(() => ScheduleOwnerProtocolError.make({ message: "Schedule Owner object identity is invalid" })));
-});
-const alarmStorageError = (operation) => (error) => ScheduleStorageError.make({
-	operation,
-	reason: error._tag === "StorageOperationError" ? "unavailable" : "corrupt"
-});
-const transactionLayer = Layer.effect(DoScheduleTransaction, Effect.gen(function* () {
-	const alarms = yield* DurableObjectAlarm.DurableObjectAlarm;
-	return DoScheduleTransaction.of({ run: (body) => Effect.gen(function* () {
-		const nowMillis = yield* Clock.currentTimeMillis;
-		return yield* alarms.transaction((transaction) => body((replacement) => replacement.deadlineAtMillis === null ? transaction.cancelAlarm({
-			id: SCHEDULE_ALARM_ID,
-			tag: SCHEDULE_ALARM_TAG
-		}).pipe(Effect.mapError(alarmStorageError("cancel Schedule Owner alarm"))) : Effect.fromOption(DateTime.make(Math.max(replacement.deadlineAtMillis, nowMillis + 1))).pipe(Effect.mapError(() => ScheduleStorageError.make({
-			operation: "validate Schedule Owner alarm deadline",
-			reason: "corrupt"
-		})), Effect.flatMap((runAt) => transaction.scheduleAlarm({
-			id: SCHEDULE_ALARM_ID,
-			tag: SCHEDULE_ALARM_TAG,
-			runAt,
-			payload: {
-				schemaVersion: 1,
-				generation: replacement.generation
-			}
-		}).pipe(Effect.mapError(alarmStorageError("schedule Schedule Owner alarm"))))))).pipe(Effect.catchTag("StorageOperationError", () => ScheduleStorageError.make({
-			operation: "commit Schedule Owner transaction",
-			reason: "unavailable"
-		})));
-	}) });
-}));
-const admissionLayer = Layer.effect(ScheduledInputAdmission, Effect.gen(function* () {
-	const client = yield* CloudflareConversationClient;
-	const submit = (envelope) => client.submit(passthroughAgent(envelope.agentId), envelope.input, {
-		conversationId: envelope.conversationId,
+/** Ordinary prepared admission through one freshly addressed Thread Object call. */
+const cloudflarePreparedInputAdmissionLayer = Layer.effect(PreparedInputAdmission, Effect.gen(function* () {
+	const client = yield* CloudflareThreadClient;
+	return PreparedInputAdmission.of({ submit: (envelope) => client.submit(passthroughAgent(envelope.agentId), envelope.input, {
+		threadId: envelope.threadId,
 		principal: envelope.deliveryPrincipal,
 		idempotencyKey: envelope.admissionKey,
 		definitions: envelope.definitions
 	}).pipe(Effect.catchTags({
 		AdmissionConflict: () => ScheduleStorageError.make({
-			operation: "scheduled admission",
+			operation: "prepared admission",
 			reason: "corrupt"
 		}),
 		AdmissionLimitExceeded: () => ScheduledInputRetryable.make({ reason: "capacity" }),
-		ConversationClientError: (error) => ScheduledInputRetryable.make({ reason: error.overloaded === true ? "capacity" : "transport" }),
+		ThreadClientError: (error) => ScheduledInputRetryable.make({ reason: error.overloaded === true ? "capacity" : "transport" }),
 		HostProtocolError: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
 		LedgerError: () => ScheduledInputRetryable.make({ reason: "storage" }),
-		ConversationStoreError: () => ScheduledInputRetryable.make({ reason: "storage" }),
+		ThreadStoreError: () => ScheduledInputRetryable.make({ reason: "storage" }),
 		DurableAlarmError: () => ScheduledInputRetryable.make({ reason: "storage" }),
 		AgentInputError: () => ScheduleStorageError.make({
-			operation: "scheduled admission",
+			operation: "prepared admission",
 			reason: "corrupt"
 		}),
 		DigestError: () => ScheduleStorageError.make({
-			operation: "scheduled admission",
+			operation: "prepared admission",
 			reason: "corrupt"
 		}),
-		ConversationNotMaterialized: () => ScheduledInputRetryable.make({ reason: "storage" }),
+		ThreadNotMaterialized: () => ScheduledInputRetryable.make({ reason: "storage" }),
 		AppendConflict: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
 		FenceRejected: () => ScheduledInputRetryable.make({ reason: "ambiguous" }),
 		DurableRuntimeFailpointError: () => ScheduledInputRetryable.make({ reason: "ambiguous" })
-	}));
-	return ScheduledInputAdmission.of({ submit });
+	})) });
 }));
-const ensureOwner = (expected, request) => {
-	const observed = requestOwner(request);
-	return observed.tenantId === expected.tenantId && observed.ownerId === expected.ownerId ? Effect.void : Effect.fail(ScheduleOwnerProtocolError.make({ message: "The request owner does not match the addressed Schedule Owner object" }));
-};
-const handleScheduleRequest = Effect.fn("ScheduleOwner.handleRequest")(function* (encoded) {
-	const decoded = yield* decodeScheduleOwnerRequest(encoded).pipe(Effect.result);
-	if (decoded._tag === "Failure") return yield* encodeScheduleOwnerResponse(scheduleProtocolFailure("The Schedule request could not be decoded")).pipe(Effect.orDie);
-	const request = decoded.success;
-	const { owner } = yield* ScheduleOwnerIdentity;
-	const scheduling = yield* Scheduling;
-	const response = yield* Effect.gen(function* () {
-		yield* ensureOwner(owner, request);
-		switch (request._tag) {
-			case "Create": return {
-				_tag: "Snapshot",
-				value: yield* scheduling.create(passthroughAgent(request.agentId), request.input, {
-					scope: request.scope,
-					scheduleId: request.scheduleId,
-					timing: request.timing,
-					destination: request.destination,
-					deliveryPrincipal: request.deliveryPrincipal,
-					definitions: request.definitions
-				})
-			};
-			case "Update": return {
-				_tag: "Snapshot",
-				value: yield* scheduling.update(passthroughAgent(request.agentId), request.input, {
-					scope: request.scope,
-					scheduleId: request.scheduleId,
-					timing: request.timing,
-					destination: request.destination,
-					deliveryPrincipal: request.deliveryPrincipal,
-					definitions: request.definitions,
-					expectedRevision: request.expectedRevision
-				})
-			};
-			case "Get": return {
-				_tag: "Snapshot",
-				value: yield* scheduling.get(request.scope, request.scheduleId)
-			};
-			case "List": return {
-				_tag: "Page",
-				value: yield* scheduling.list(request.scope, {
-					...request.after === void 0 ? {} : { after: request.after },
-					...request.limit === void 0 ? {} : { limit: request.limit }
-				})
-			};
-			case "Control": return {
-				_tag: "Snapshot",
-				value: request.operation === "pause" ? yield* scheduling.pause(request.scope, request.scheduleId, request.expectedRevision) : request.operation === "resume" ? yield* scheduling.resume(request.scope, request.scheduleId, request.expectedRevision) : yield* scheduling.cancel(request.scope, request.scheduleId, request.expectedRevision)
-			};
-		}
-	}).pipe(Effect.map((value) => value), Effect.catch((failure) => Schema.is(ScheduleOwnerFailure)(failure) ? Effect.succeed({
-		_tag: "Failed",
-		failure
-	}) : Effect.succeed(scheduleProtocolFailure("The Schedule operation failed outside its public contract"))));
-	return yield* encodeScheduleOwnerResponse(response).pipe(Effect.orDie);
+const preparedFromSchedule = (envelope) => ({
+	schemaVersion: 1,
+	threadId: envelope.threadId,
+	deliveryPrincipal: envelope.deliveryPrincipal,
+	agentId: envelope.agentId,
+	definitions: envelope.definitions,
+	input: envelope.input,
+	inputDigest: envelope.inputDigest,
+	admissionKey: envelope.admissionKey,
+	authorization: envelope.authorization
 });
-const scheduleAlarmHandler = (limits) => DurableObjectAlarm.processDue((event) => Effect.gen(function* () {
-	if (event.tag !== SCHEDULE_ALARM_TAG || event.id !== SCHEDULE_ALARM_ID) return yield* ScheduleAlarmProtocolError.make({ message: `Unsupported Schedule Owner alarm ${event.tag}/${event.id}` });
-	yield* Schema.decodeUnknownEffect(ScheduleAlarmPayload)(event.payload).pipe(Effect.mapError(() => ScheduleAlarmProtocolError.make({ message: "Unsupported Schedule Owner alarm payload version" })));
-	const scheduling = yield* ScheduleDriver;
-	const alarmControl = yield* DoScheduleAlarmControl;
-	const { owner } = yield* ScheduleOwnerIdentity;
-	const nowMillis = yield* Clock.currentTimeMillis;
-	yield* alarmControl.prearm(nowMillis + limits.recoveryPollMillis);
-	if ((yield* scheduling.runDue(owner)).failed > 0) yield* alarmControl.prearm((yield* Clock.currentTimeMillis) + limits.recoveryPollMillis);
-	else yield* alarmControl.reconcile;
-}), { mode: "ordered" }).pipe(Effect.asVoid);
-/**
-* The host Layer supplies authorization and routing and is cached for the object incarnation.
-* Cloudflare eviction does not guarantee its finalizers run. Do not acquire resources requiring
-* cleanup in this Layer; acquire them inside scoped `manage` / `prepare` operations instead.
-* Native services belong to effect-cf; the database and alarm runtime remain instance-owned.
-*/
-const makeScheduleOwnerObjectClass = (host, limits = defaultSchedulingLimits) => {
-	const ownerLayer = Layer.effect(ScheduleOwnerIdentity, Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		return ScheduleOwnerIdentity.of({ owner: yield* decodeOwnerName(state.raw.id.name) });
-	}));
-	const sqlLayer = Layer.unwrap(Effect.map(DurableObjectState.DurableObjectState, (state) => SqliteClient.layer({ storage: state.raw.storage })));
-	const application = Layer.merge(Scheduling.layer(limits), ScheduleDriver.layer(limits)).pipe(Layer.provideMerge(scheduleStoreLayer.pipe(Layer.provide(transactionLayer), Layer.provide(sqlLayer))), Layer.provide(admissionLayer.pipe(Layer.provide(CloudflareConversationClient.layer))), Layer.provide(ScheduleWakeNoop), Layer.provide(BrowserCrypto.layer), Layer.provideMerge(DurableObjectAlarm.DurableObjectAlarm.layer), Layer.provide(host), Layer.provideMerge(ownerLayer));
-	const runtime = Layer.effectContext(Effect.gen(function* () {
-		const state = yield* DurableObjectState.DurableObjectState;
-		const scope = yield* Effect.scope;
-		return yield* state.blockConcurrencyWhile(Layer.buildWithScope(application, scope));
-	}));
-	const Base = DurableObject.make(runtime, {
-		initialize: Effect.void,
-		rpc: { schedule: (encoded) => handleScheduleRequest(encoded) },
-		alarms: scheduleAlarmHandler(limits)
-	});
-	class ScheduleOwnerObject extends Base {
-		alarm(alarmInfo) {
-			return super.alarm?.(alarmInfo);
-		}
-	}
-	return ScheduleOwnerObject;
-};
+/** Compatibility adapter retaining Scheduling's public admission port. */
+const cloudflareScheduledInputAdmissionLayer = Layer.effect(ScheduledInputAdmission, Effect.map(PreparedInputAdmission, (admission) => ScheduledInputAdmission.of({ submit: (envelope) => admission.submit(preparedFromSchedule(envelope)) })));
 //#endregion
-export { CLOUDFLARE_RUNTIME_DEFAULTS as $, decodeHostResponse as A, encodeObservePageRequest as B, SubmitSucceeded as C, decodeApprovalDecisionCommand as D, decodeAbortCommand as E, encodeAbortCommand as F, ConversationMaintenanceFailpoint as G, encodeSubmitRequest as H, encodeApprovalDecisionCommand as I, MaintenancePassReport as J, DurableAlarmError as K, encodeAwaitProgressRequest as L, decodeReceipt as M, decodeSubmitRequest as N, decodeAwaitProgressRequest as O, decodeUnknownResolutionCommand as P, CLOUDFLARE_DATABASE_CAP_BYTES as Q, encodeCancelProgressRequest as R, SubmitRequest as S, boundHostDiagnostic as T, encodeUnknownResolutionCommand as U, encodeReceipt as V, ConversationMaintenance as W, safeCauseMessage as X, safeCauseDiagnostic as Y, AdmissionLimitExceeded as Z, ObservePageRequest as _, ScheduleOwnerProtocolError as a, CloudflareBindingError as at, ProgressObserved as b, ApprovalRecorded as c, DurableObjectContext as ct, CloudflareConversationClient as d, CloudflareAdmissionLimitsValue as et, ConversationClientError as f, HostResponse as g, HostProtocolError as h, ScheduleOwnerNamespace as i, DEFAULT_MAX_DATABASE_BYTES as it, decodeObservePageRequest as j, decodeCancelProgressRequest as k, AwaitProgressRequest as l, conversationNamespaceFromEnv as lt, HostFailure as m, ScheduleAlarmProtocolError as n, CloudflareDurableRuntimeConfigValue as nt, makeScheduleOwnerObjectClass as o, ConversationObjectIdentity as ot, HostFailed as p, DurableAlarmService as q, ScheduleOwnerIdentity as r, CloudflarePlatformConfigError as rt, AbortRecorded as s, ConversationObjectNamespace as st, CloudflareSchedulingClient as t, CloudflareDurableRuntimeConfig as tt, CancelProgressRequest as u, conversationNamespaceLayer as ut, ObservedPage as v, UnknownResolutionRecorded as w, SettlementReached as x, ProgressCancelled as y, encodeHostResponse as z };
+export { CloudflarePlatformConfigError as $, decodeUnknownResolutionCommand as A, DurableAlarmError as B, decodeApprovalDecisionCommand as C, decodeObservePageRequest as D, decodeHostResponse as E, encodeHostResponse as F, safeCauseDiagnostic as G, MaintenancePassReport as H, encodeObservePageRequest as I, CLOUDFLARE_DATABASE_CAP_BYTES as J, safeCauseMessage as K, encodeReceipt as L, encodeApprovalDecisionCommand as M, encodeAwaitProgressRequest as N, decodeReceipt as O, encodeCancelProgressRequest as P, CloudflareDurableRuntimeConfigValue as Q, encodeSubmitRequest as R, decodeAbortCommand as S, decodeCancelProgressRequest as T, ThreadMaintenance as U, DurableAlarmService as V, ThreadMaintenanceFailpoint as W, CloudflareAdmissionLimitsValue as X, CLOUDFLARE_RUNTIME_DEFAULTS as Y, CloudflareDurableRuntimeConfig as Z, SubmitRequest as _, AwaitProgressRequest as a, threadNamespaceFromEnv as at, UnknownResolutionRecorded as b, HostFailed as c, HostResponse as d, DEFAULT_MAX_DATABASE_BYTES as et, ObservePageRequest as f, SettlementReached as g, ProgressObserved as h, ApprovalRecorded as i, ThreadObjectNamespace as it, encodeAbortCommand as j, decodeSubmitRequest as k, HostFailure as l, ProgressCancelled as m, cloudflareScheduledInputAdmissionLayer as n, DurableObjectContext as nt, CancelProgressRequest as o, threadNamespaceLayer as ot, ObservedPage as p, AdmissionLimitExceeded as q, AbortRecorded as r, ThreadObjectIdentity as rt, CloudflareThreadClient as s, cloudflarePreparedInputAdmissionLayer as t, CloudflareBindingError as tt, HostProtocolError as u, SubmitSucceeded as v, decodeAwaitProgressRequest as w, boundHostDiagnostic as x, ThreadClientError as y, encodeUnknownResolutionCommand as z };
 
-//# sourceMappingURL=scheduling-B-OFqoS9.mjs.map
+//# sourceMappingURL=prepared-admission-BKp_Upw2.mjs.map