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

package/dist/{ThreadObject-DHjrnlX4.mjs → ThreadObject-C0vrcDrw.mjs}

@@ -1,40 +1,183 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement, callThreadObject, threadNamespaceFromEnv } from "./CloudflareBindings.mjs";
 import { AdmissionLimitExceeded, CLOUDFLARE_RUNTIME_DEFAULTS, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError } from "./CloudflareConfig.mjs";
-import { _ as Messages, b as Publication, c as ThreadMessageDelivery, d as ThreadPublication, g as Lifecycle, h as HostLaneId, l as ThreadMutationGate, m as publishCommitted, n as DurableAlarmError, o as ThreadMaintenance, r as DurableAlarmService, s as ThreadMaintenanceFailpoint, u as ThreadNativeMaintenance, v as Native, y as Projection } from "./Alarm-B0ODr1NE.mjs";
-import { AbortRecorded, ApprovalRecorded, CloudflareThreadClient, HostFailed, HostProtocolError, ObservedPage, ProgressCancelled, ProgressObserved, SettlementReached, SubmissionStatusResponse, SubmitSucceeded, UnknownResolutionRecorded, boundHostDiagnostic, decodeAbortCommand, decodeApprovalDecisionCommand, decodeAwaitProgressRequest, decodeCancelProgressRequest, decodeObservePageRequest, decodeReceipt, decodeSubmitRequest, decodeUnknownResolutionCommand, encodeHostResponse } from "./CloudflareThreadClient.mjs";
-import { t as cloudflarePreparedInputAdmissionLayer } from "./prepared-admission-DMX5p9dC.mjs";
+import { _ as Lifecycle, b as Projection, c as ThreadMaintenanceFailpoint, d as ThreadNativeMaintenance, f as ThreadPublication, g as HostLaneId, h as publishCommitted, l as ThreadMessageDelivery, n as DurableAlarmError, o as ThreadMaintenance, r as DurableAlarmService, s as ThreadMaintenanceAlarm, u as ThreadMutationGate, v as Messages, x as Publication, y as Native } from "./Alarm-DxODgAZZ.mjs";
+import { A as decodeSubmitRequest, C as decodeAbortCommand, E as decodeCancelProgressRequest, G as Request, H as MAX_DELTA_LENGTH, I as encodeHostResponse, K as isBoundedEvent, O as decodeObservePageRequest, S as boundHostDiagnostic, T as decodeAwaitProgressRequest, V as Frame, _ as SubmissionStatusResponse, a as CloudflareThreadClient, f as ObservedPage, g as SettlementRecordReached, h as SettlementReached, j as decodeUnknownResolutionCommand, k as decodeReceipt, l as HostProtocolError, m as ProgressObserved, n as ApprovalRecorded, p as ProgressCancelled, q as cloudflareCryptoLayer, s as HostFailed, t as AbortRecorded, w as decodeApprovalDecisionCommand, x as UnknownResolutionRecorded, y as SubmitSucceeded } from "./CloudflareThreadClient-CZm0TvUe.mjs";
+import { t as cloudflarePreparedInputAdmissionLayer } from "./prepared-admission-3UUq0zth.mjs";
 import { cloudflareWakeSchedulerLayer } from "./WakeScheduler.mjs";
+import { ThreadPortTransport, executePortRequest, makeLocalSubmissionLookup, portTransportFailure, routedMessageDeliveryStoreLayer, routedSettlementPublisherLayer, routedSubmissionLedgerLayer, routedThreadStoreLayer, routedWorkerAdmissionLayer } from "@yielded/agent-storage-cloudflare/port-routing";
 import { compileRegistrations } from "@yielded/agent/agent-registration";
-import { ApprovalSuspensionError, DurableAgentRuntime, DurableRuntimeConfig, RecoveryReport } from "@yielded/agent/durable-agent-runtime";
+import { ApprovalSuspensionError, DurableAgentRuntime, DurableRuntimeConfig, RecoveryBlocked, RecoveryReport } from "@yielded/agent/durable-agent-runtime";
 import { SubmissionId, ThreadId } from "@yielded/agent/identifiers";
 import { AdmissionPolicyError, LedgerError, OwnershipLost, SettlementConflict, SubmissionLedger, SubmissionLookupByKey } from "@yielded/agent/submission-ledger";
 import { ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
 import { WakeScheduler } from "@yielded/agent/wake-scheduler";
-import { Cause, Clock, Context, Deferred, Duration, Effect, ErrorReporter, Exit, Layer, Match, Option, Ref, Schema, Semaphore, Stream } from "effect";
-import { DurableObject, DurableObjectState, RpcTracing, WorkerEnvironment } from "effect-cf";
+import { Cause, Clock, Context, Deferred, Duration, Effect, ErrorReporter, Exit, Layer, Match, Option, Queue, Ref, Schema, Scope, Semaphore, Stream } from "effect";
+import { DurableObject, DurableObjectAlarm, DurableObjectState, RpcTracing, WorkerEnvironment } from "effect-cf";
 import { SqlClient } from "effect/sql/SqlClient";
 import { PersistedJson, ProducerId } from "@yielded/agent/records";
-import { BrowserCrypto } from "@effect/platform-browser";
 import { SqliteClient } from "@effect/sql-sqlite-do";
 import { DigestError } from "@yielded/agent/digest";
 import { DurableRuntimeFailpoint, DurableRuntimeFailpointError } from "@yielded/agent/durable-failpoint";
 import { OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, operationAuthorizerLayer } from "@yielded/agent/operation-authorizer";
-import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError } from "@yielded/agent/thread-store";
+import { AppendConflict, AppendResult, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError } from "@yielded/agent/thread-store";
+import { Publisher } from "@yielded/agent/provisional-text";
 import { LedgerLookupResult, PortFailed, PortProtocolError, PortSucceeded, decodePortRequest, encodePortResponse } from "@yielded/agent-storage-cloudflare/port-protocol";
 import { IntegrityReport, ObligationReport, ObligationThresholds, RecoveryExplanation, RetryCommand, RetryRefused } from "@yielded/agent/admin";
 import { RunJournalError } from "@yielded/agent/run-journal";
+import { WorkDiscoveryUnavailable } from "@yielded/agent/thread-work";
 import { doMessageDeliveryStoreLayer } from "@yielded/agent-storage-cloudflare/do-message-delivery-store";
 import "@yielded/agent-storage-cloudflare/do-storage-failpoint";
 import { submissionLedgerLayer } from "@yielded/agent-storage-cloudflare/do-submission-ledger";
 import { sqlOwnerLayer, storageConfigLayer, storageFailpointLayer, threadStoreLayer } from "@yielded/agent-storage-cloudflare/do-thread-store";
-import { ThreadPortTransport, executePortRequest, makeLocalSubmissionLookup, portTransportFailure, routedMessageDeliveryStoreLayer, routedSubmissionLedgerLayer, routedThreadStoreLayer, routedWorkerAdmissionLayer } from "@yielded/agent-storage-cloudflare/port-routing";
 import { SqlStorageProgress, SqlStorageProgressError } from "@yielded/agent-storage-sql/sql-storage-progress";
 import { LifecyclePublicationError, LifecyclePublicationFact, drainLifecyclePublications, lifecyclePublicationLayer } from "@yielded/agent/lifecycle-publication";
 import { MessageDeliveryDriver, MessageDeliveryError, MessageDeliveryStore } from "@yielded/agent/message-delivery";
 import { CurrentToolFailureObserver, RunContextPreparationPassthrough, RunToolAuthorization, toolFailureObserverLayer } from "@yielded/agent/run-options";
+import { StorageOwner, layer } from "@yielded/agent/run-storage";
+import { SettlementPublisher, validatePublication } from "@yielded/agent/settlement-publisher";
 import { SqlStorageOwner } from "@yielded/agent/sql-memory-store";
 import { ToolReconciler } from "@yielded/agent/tool-reconciler";
+import * as Response from "effect/ai/Response";
+//#region src/internal/live-text.ts
+/** One Object incarnation; owns drafts and subscriptions independently of RPC event scopes. */
+var LiveTextHub = class LiveTextHub extends Context.Service()("@effect-agent/platform-cloudflare/LiveTextHub") {
+	static layer = Layer.effectContext(Effect.gen(function* () {
+		const owner = yield* Effect.scope;
+		const observers = /* @__PURE__ */ new Set();
+		const drafts = /* @__PURE__ */ new Map();
+		let length = 0;
+		let unavailable;
+		const encode = Schema.encodeEffect(Schema.fromJsonString(Frame));
+		const encoder = new TextEncoder();
+		yield* Effect.addFinalizer(() => Effect.sync(() => drafts.clear()));
+		const fail = (attemptId) => {
+			const error = HostProtocolError.make({ message: "Provisional text exceeds its draft bounds or is invalid; read canonical records" });
+			unavailable = {
+				error,
+				attemptId
+			};
+			drafts.clear();
+			length = 0;
+			for (const observer of observers) {
+				observer.snapshot = true;
+				Queue.failCauseUnsafe(observer.queue, Cause.fail(error));
+				Queue.shutdownUnsafe(observer.queue);
+			}
+			return false;
+		};
+		const offerUnsafe = (event) => {
+			if (event._tag === "AttemptEnded" && event.attemptId === unavailable?.attemptId) unavailable = void 0;
+			if (unavailable !== void 0) return false;
+			if (!isBoundedEvent(event)) return event._tag === "AttemptEnded" ? false : fail(event.attemptId);
+			if (event._tag === "Text") {
+				const key = JSON.stringify([
+					event.threadId,
+					event.submissionId,
+					event.attemptId,
+					event.runId,
+					event.turnId,
+					event.generation,
+					event.part.id
+				]);
+				const draft = drafts.get(key);
+				if (event.part.type === "text-start") {
+					if (draft !== void 0 || drafts.size >= 32) return fail(event.attemptId);
+					drafts.set(key, {
+						start: event,
+						text: "",
+						ended: false
+					});
+				} else {
+					if (draft === void 0) return false;
+					if (draft.ended) return fail(event.attemptId);
+					if (event.part.type === "text-delta") {
+						if (length + event.part.delta.length > 2097152) return fail(event.attemptId);
+						draft.text += event.part.delta;
+						length += event.part.delta.length;
+					} else draft.ended = true;
+				}
+			} else for (const [key, draft] of drafts) {
+				const start = draft.start;
+				if (start.threadId === event.threadId && start.submissionId === event.submissionId && start.attemptId === event.attemptId && (event._tag === "AttemptEnded" || start.runId === event.runId && start.turnId === event.turnId && start.generation === event.generation)) {
+					drafts.delete(key);
+					length -= draft.text.length;
+				}
+			}
+			for (const observer of observers) {
+				if (observer.threadId !== event.threadId) continue;
+				if (!Queue.offerUnsafe(observer.queue, event)) observer.snapshot = true;
+			}
+			return true;
+		};
+		const open = Effect.fnUntraced(function* (threadId) {
+			if (unavailable !== void 0) return yield* unavailable.error;
+			if (threadId.length > 256 || observers.size >= 8) return yield* HostProtocolError.make({ message: "Provisional text observation capacity exceeded" });
+			const scope = yield* Scope.fork(owner);
+			const queue = yield* Queue.dropping(32);
+			const observer = {
+				threadId,
+				queue,
+				snapshot: true,
+				streamId: "",
+				sequence: 0
+			};
+			const close = Scope.close(scope, Exit.void);
+			yield* Scope.addFinalizer(scope, Effect.sync(() => {
+				observer.snapshot = true;
+				observers.delete(observer);
+				Queue.shutdownUnsafe(queue);
+			}));
+			observers.add(observer);
+			Queue.offerUnsafe(queue, void 0);
+			const frame = (event) => ({
+				_tag: "Event",
+				schemaVersion: 1,
+				streamId: observer.streamId,
+				sequence: ++observer.sequence,
+				event
+			});
+			const snapshot = function* () {
+				while (Queue.sizeUnsafe(queue) > 0) Queue.takeUnsafe(queue);
+				const current = Array.from(drafts.values()).filter((draft) => draft.start.threadId === threadId).map((draft) => ({ ...draft }));
+				observer.snapshot = false;
+				observer.streamId = crypto.randomUUID();
+				observer.sequence = 0;
+				yield {
+					_tag: "Reset",
+					schemaVersion: 1,
+					streamId: observer.streamId,
+					threadId,
+					sequence: 0
+				};
+				for (const draft of current) {
+					yield frame(draft.start);
+					for (let offset = 0; offset < draft.text.length; offset += MAX_DELTA_LENGTH) yield frame({
+						...draft.start,
+						part: Response.makePart("text-delta", {
+							id: draft.start.part.id,
+							delta: draft.text.slice(offset, offset + MAX_DELTA_LENGTH)
+						})
+					});
+					if (draft.ended) yield frame({
+						...draft.start,
+						part: Response.makePart("text-end", { id: draft.start.part.id })
+					});
+				}
+			};
+			const toBytes = Effect.fnUntraced(function* (value) {
+				const json = yield* encode(value).pipe(Effect.mapError(() => HostProtocolError.make({ message: "Provisional text frame is invalid" })));
+				const bytes = encoder.encode(json + "\n");
+				if (bytes.byteLength > 32768) return yield* HostProtocolError.make({ message: "Provisional text frame exceeds its wire bound" });
+				return bytes;
+			});
+			const frames = Stream.fromEffectRepeat(Queue.take(queue)).pipe(Stream.flatMap((event) => observer.snapshot || event === void 0 ? Stream.fromIterable(snapshot(), { chunkSize: 1 }).pipe(Stream.takeWhile(() => !observer.snapshot)) : Stream.succeed(frame(event))), Stream.mapEffect(toBytes), Stream.ensuring(close));
+			return yield* Stream.toReadableStreamEffect(frames);
+		});
+		return Context.make(LiveTextHub, { open }).pipe(Context.add(Publisher, { offerUnsafe }));
+	}));
+};
+//#endregion
 //#region src/internal/message-delivery.ts
 /** Every write prearms its owner; the delivery due index owns its recovery deadline. */
 const guardedMessageDeliveryStoreLayer = Layer.effect(MessageDeliveryStore, Effect.gen(function* () {
@@ -116,23 +259,20 @@ var ProgressWaitRegistry = class ProgressWaitRegistry extends Context.Service()(
 			else next.set(waiterId, active);
 			return next;
 		});
-		const subscribe = Effect.fn("ProgressWaitRegistry.subscribe")((waiterId) => Effect.gen(function* () {
+		const subscribe = Effect.fnUntraced(function* (waiterId) {
 			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) {
+			return (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];
+			})) ? Effect.void : Deferred.await(deferred);
+		});
+		const cancel = Effect.fnUntraced(function* (waiterId) {
 			const waiters = yield* Ref.modify(registrations, (current) => {
 				const existing = current.get(waiterId);
 				if (existing === "cancelled") return [[], current];
@@ -176,7 +316,7 @@ var ProgressWaitRegistry = class ProgressWaitRegistry extends Context.Service()(
 const threadPortTransportLayer = Layer.effect(ThreadPortTransport)(Effect.gen(function* () {
 	const namespace = yield* ThreadObjectNamespace;
 	const { rpcTracing } = namespace;
-	return ThreadPortTransport.of({ call: Effect.fn(function* (threadId, request) {
+	return ThreadPortTransport.of({ call: Effect.fnUntraced(function* (threadId, request) {
 		const traceArgs = rpcTracing === void 0 ? [] : yield* RpcTracing.withRpcTraceContext([]);
 		return yield* callThreadObject(threadId, (target) => target.portCall(request, ...traceArgs), (cause) => portTransportFailure(threadId, cause)).pipe(Effect.provideService(ThreadObjectNamespace, namespace));
 	}, (effect, threadId) => rpcTracing === void 0 ? Effect.withSpan(effect, "CloudflarePortTransport.call", { attributes: { threadId } }) : RpcTracing.withRpcClientSpan(effect, rpcTracing, "portCall")) });
@@ -196,11 +336,9 @@ 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,
 	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,
 	projectionDispatchTimeoutMillis: options.projectionDispatchTimeoutMillis ?? CLOUDFLARE_RUNTIME_DEFAULTS.projectionDispatchTimeoutMillis,
@@ -236,10 +374,9 @@ const runtimeConfigLayer = (options, producerId) => Layer.unwrap(Effect.gen(func
 		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({
+	}), cloudflareCryptoLayer, LiveTextHub.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);
@@ -256,7 +393,10 @@ const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
 	return Layer.mergeAll(runtimeConfigLayer(options, producerId), Layer.succeed(ThreadObjectIdentity, {
 		threadId,
 		producerId
-	}), Layer.succeed(ThreadObjectPlacement, { ownsThread: (target) => target === threadId }));
+	}), Layer.succeed(ThreadObjectPlacement, {
+		threadId,
+		ownsThread: (target) => target === threadId
+	}));
 }));
 /**
 * Configuration for an application Object owning several logical Threads. The producer is
@@ -275,7 +415,7 @@ const layerHostConfig = (options, ownsThread) => Layer.unwrap(Effect.gen(functio
 * Use Layer.unwrap for registration values that need effectful application setup.
 */
 const registeredLayer = (registrations, options = {}) => Layer.unwrap(Effect.map(compileRegistrations(registrations), (bindings) => boundLayer(bindings, options)));
-function layer(registrations, options = {}) {
+function layer$1(registrations, options = {}) {
 	return registeredLayer(registrations, options);
 }
 /**
@@ -291,11 +431,11 @@ function layerInHost(application, options = {}) {
 const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(function* () {
 	const { ctx } = yield* DurableObjectContext;
 	const config = yield* CloudflareDurableRuntimeConfig;
-	const { ownsThread } = yield* ThreadObjectPlacement;
+	const placement = yield* ThreadObjectPlacement;
+	const { ownsThread } = placement;
 	const storageOptions = {
 		storage: ctx.storage,
 		observationPollInterval: config.observationPollInterval,
-		ownershipLeaseDuration: config.ownershipLeaseDuration,
 		maxStoredValueBytes: config.maxStoredValueBytes,
 		verifyOnOpen: config.verifyOnOpen
 	};
@@ -342,6 +482,8 @@ const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(funct
 	const localPorts = options.publication === void 0 && options.projection === void 0 && options.hostLanesForMutation === void 0 && options.lifecyclePublication === void 0 ? rawLocalPorts : Layer.effectContext(Effect.gen(function* () {
 		const store = yield* ThreadStore;
 		const ledger = yield* SubmissionLedger;
+		const storageOwner = yield* StorageOwner;
+		const settlementPublisher = yield* SettlementPublisher;
 		const mutations = yield* ThreadMutationGate;
 		const index = yield* ThreadProjectionMaintenance;
 		const publish = yield* Effect.context();
@@ -379,7 +521,18 @@ const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(funct
 			cause
 		})), Effect.flatMap((lanes) => observeIntent(body, invalidatesRecovery, lanes)));
 		const stopWorker = ledger.stopWorker;
-		return Context.make(ThreadStore, observedStore).pipe(Context.add(SubmissionLedger, {
+		return Context.make(ThreadStore, observedStore).pipe(Context.add(StorageOwner, storageOwner), Context.add(SettlementPublisher, { publish: (input) => Effect.gen(function* () {
+			const { request } = yield* validatePublication(input);
+			return yield* mutations.withMutation(sourceCommits.withPermit(settlementPublisher.publish(request).pipe(Effect.tap((result) => result.replayed ? Effect.void : index.applyCommitted(request.append, AppendResult.make({
+				firstSequence: result.tailSequence,
+				lastSequence: result.tailSequence,
+				replayed: false
+			})).pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.logError("Thread projection deferred after settlement publication", cause)))))).pipe(Effect.tap(() => afterCommit)), { lanes: [...options.projection === void 0 ? [] : [Projection], ...options.lifecyclePublication === void 0 ? [] : [Lifecycle]] }).pipe(Effect.catchTag("DurableAlarmError", (cause) => ThreadStoreError.make({
+				operation: "prearm settlement publication",
+				message: cause.message,
+				cause
+			})));
+		}) }), Context.add(SubmissionLedger, {
 			...ledger,
 			...options.hostLanesForMutation === void 0 ? {} : { admit: (request) => observeMutation({
 				_tag: "Admission",
@@ -412,9 +565,9 @@ const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(funct
 			lookupSubmission: (submissionId) => lookupSubmission(submissionId).pipe(Effect.provide(local))
 		});
 	})).pipe(Layer.provide(localPorts), Layer.provide(messageStore), Layer.provide(wakes));
-	const routedPorts = Layer.mergeAll(routedSubmissionLedgerLayer({ ownsThread }), routedThreadStoreLayer({ ownsThread }), routedWorkerAdmissionLayer({ ownsThread })).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
+	const routedPorts = Layer.mergeAll(Layer.effect(StorageOwner, StorageOwner), routedSubmissionLedgerLayer({ ownsThread }), routedSettlementPublisherLayer({ ownsThread }), routedThreadStoreLayer({ ownsThread }), routedWorkerAdmissionLayer({ ownsThread })).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
 	const routedMessages = routedMessageDeliveryStoreLayer({ ownsThread }).pipe(Layer.provide(messageStore), Layer.provide(threadPortTransportLayer));
-	const runtimeStack = application.pipe(Layer.provide(cloudflarePreparedInputAdmissionLayer.pipe(Layer.provide(CloudflareThreadClient.layer))), Layer.provideMerge(routedMessages), Layer.provideMerge(routedPorts), Layer.provideMerge(wakes), Layer.provideMerge(base), Layer.provideMerge(portsEndpointLayer));
+	const runtimeStack = application.pipe(Layer.provideMerge(layer()), Layer.provide(cloudflarePreparedInputAdmissionLayer.pipe(Layer.provide(CloudflareThreadClient.layer))), Layer.provideMerge(routedMessages), Layer.provideMerge(routedPorts), Layer.provideMerge(wakes), Layer.provideMerge(base), Layer.provideMerge(portsEndpointLayer));
 	const maintenanceRuntime = options.lifecyclePublication === void 0 ? runtimeStack : Layer.merge(runtimeStack, Layer.effect(ThreadNativeMaintenance)(Effect.gen(function* () {
 		const previous = yield* ThreadNativeMaintenance;
 		const storage = (yield* ThreadStore).lifecyclePublications;
@@ -434,7 +587,14 @@ const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(funct
 			run: storage === void 0 ? Effect.fail(failure("Native lifecycle storage unavailable")) : drainLifecyclePublications(storage).pipe(Effect.provide(context), Effect.mapError(failure), Effect.andThen(deadline))
 		}] };
 	})).pipe(Layer.provide(rawLocalPorts), Layer.provide(options.lifecyclePublication.pipe(Layer.provide(rawLocalPorts))), Layer.provide(runtimeStack)));
-	return Layer.mergeAll(maintenanceRuntime, ThreadMaintenance.layer.pipe(Layer.provide(options.recoveryEvents ?? Layer.empty), Layer.provide(maintenanceRuntime), Layer.provide(messageRecovery)), portsEndpointLayer, routedMessages, messageRecovery).pipe(Layer.provideMerge(sourceProgress), Layer.provideMerge(publication), Layer.provideMerge(projection), Layer.provideMerge(sourceOwner), Layer.provideMerge(ThreadMutationGate.layer), Layer.provideMerge(infrastructure));
+	return Layer.mergeAll(maintenanceRuntime, ThreadMaintenance.layer.pipe(Layer.provide(options.recoveryEvents ?? Layer.empty), Layer.provide(Layer.effect(ThreadNativeMaintenance)(Effect.gen(function* () {
+		const previous = yield* ThreadNativeMaintenance;
+		const runtime = yield* DurableAgentRuntime;
+		return {
+			lanes: previous.lanes,
+			...placement.threadId === void 0 ? {} : { singleThreadRuntime: runtime }
+		};
+	}))), Layer.provide(maintenanceRuntime), Layer.provide(messageRecovery)), portsEndpointLayer, routedMessages, messageRecovery).pipe(Layer.provideMerge(sourceProgress), Layer.provideMerge(publication), Layer.provideMerge(projection), Layer.provideMerge(sourceOwner), Layer.provideMerge(ThreadMutationGate.layer), Layer.provideMerge(infrastructure));
 }));
 //#endregion
 //#region src/ThreadObject.ts
@@ -450,6 +610,7 @@ var ThreadObject_exports = /* @__PURE__ */ __exportAll({
 	ThreadObjectPorts: () => ThreadObjectPorts,
 	ThreadRpcOperation: () => ThreadRpcOperation,
 	VerifiedIntegrity: () => VerifiedIntegrity,
+	alarms: () => alarms,
 	decodeAdminExplainRequest: () => decodeAdminExplainRequest,
 	decodeAdminResponse: () => decodeAdminResponse,
 	decodeAdminVerifyRequest: () => decodeAdminVerifyRequest,
@@ -457,7 +618,7 @@ var ThreadObject_exports = /* @__PURE__ */ __exportAll({
 	decodeRetryCommand: () => decodeRetryCommand,
 	encodeAdminResponse: () => encodeAdminResponse,
 	handleRpc: () => handleRpc,
-	layer: () => layer,
+	layer: () => layer$1,
 	layerConfig: () => layerConfig,
 	layerHostConfig: () => layerHostConfig,
 	layerInHost: () => layerInHost,
@@ -476,15 +637,27 @@ const isMutatingPortRequest = (request) => {
 		case "LedgerRecordChildSettled":
 		case "StoreMaterialize":
 		case "StoreAppend":
+		case "StoreWorkRebuild":
+		case "StoreRangeSeal":
+		case "StoreRangeArchive":
+		case "SettlementPublish":
 		case "MessageDeliveryComplete": return true;
 		case "LedgerInspectWorker":
 		case "LedgerLookup":
 		case "LedgerResolveAdmission":
+		case "LedgerFundingOwner":
 		case "StoreReadPage":
+		case "StoreReadPrompt":
+		case "StoreReadExecution":
+		case "StoreWorkPage":
 		case "StoreInspectTail":
 		case "StoreReadIdentity":
 		case "StoreCountPeerMessages":
 		case "StoreExport":
+		case "StoreRangePage":
+		case "StoreRangeVerify":
+		case "StoreVerification":
+		case "StoreWorkerCapacity":
 		case "MessageDeliveryList": return false;
 	}
 	return false;
@@ -515,7 +688,7 @@ const utf8Bytes = (value) => new TextEncoder().encode(JSON.stringify(value)).len
 * 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* (threadId, request) {
+const gateAdmissionLimits = Effect.fnUntraced(function* (threadId, request) {
 	const config = yield* CloudflareDurableRuntimeConfig;
 	const ledger = yield* SubmissionLedger;
 	const { ctx } = yield* DurableObjectContext;
@@ -555,30 +728,32 @@ const passthroughSubmitAgent = (agentId) => ({ definition: {
 	input: PersistedJson
 } });
 /** A physical owner may hold other Threads; an addressed request cannot act on their IDs. */
-const lookupAddressedSubmission = Effect.fn("ThreadObject.lookupAddressedSubmission")(function* (submissionId) {
+const lookupAddressedSubmission = Effect.fnUntraced(function* (submissionId) {
 	const { threadId } = yield* ThreadObjectIdentity;
 	const submission = yield* (yield* ThreadObjectPorts).lookupSubmission(submissionId);
 	if (Option.isSome(submission) && submission.value.threadId !== threadId) return yield* HostProtocolError.make({ message: "The Submission belongs to another Thread" });
 	return submission;
 });
-const requireSubmissionThread = Effect.fn("ThreadObject.requireSubmissionThread")(function* (submissionId) {
+const requireSubmissionThread = Effect.fnUntraced(function* (submissionId) {
 	const submission = yield* lookupAddressedSubmission(submissionId);
 	if (Option.isNone(submission)) return yield* LedgerError.make({
 		operation: "addressed Submission lookup",
 		message: "The addressed Thread has no such Submission"
 	});
 });
-const requireReceiptThread = Effect.fn("ThreadObject.requireReceiptThread")(function* (threadId) {
+const requireReceiptThread = Effect.fnUntraced(function* (threadId) {
 	if (threadId !== (yield* ThreadObjectIdentity).threadId) return yield* HostProtocolError.make({ message: "The Receipt belongs to another Thread" });
 });
 const requirePortThread = (request) => {
 	switch (request._tag) {
+		case "SettlementPublish": return requireReceiptThread(request.request.append.threadId).pipe(Effect.andThen(requireSubmissionThread(request.request.submissionId)));
 		case "MessageDeliveryComplete": return requireReceiptThread(request.key.ownerThreadId);
 		case "MessageDeliveryList": return requireReceiptThread(request.request.ownerThreadId);
 		case "LedgerLookup": return request.request._tag === "SubmissionLookupById" ? lookupAddressedSubmission(request.request.submissionId).pipe(Effect.asVoid) : requireReceiptThread(request.request.threadId);
 		case "LedgerMarkReady":
 		case "LedgerRequestAbort": return requireSubmissionThread(request.request.submissionId);
 		case "LedgerRecordChildSettled": return requireSubmissionThread(request.request.parentSubmissionId);
+		case "LedgerFundingOwner": return requireReceiptThread(request.request.threadId).pipe(Effect.andThen(requireSubmissionThread(request.request.submissionId)));
 		case "LedgerInspectWorker":
 		case "LedgerStopWorker":
 		case "WorkerAdmit":
@@ -587,22 +762,33 @@ const requirePortThread = (request) => {
 		case "StoreMaterialize":
 		case "StoreAppend":
 		case "StoreReadPage":
+		case "StoreReadPrompt":
+		case "StoreReadExecution":
 		case "StoreInspectTail":
 		case "StoreReadIdentity":
 		case "StoreCountPeerMessages":
-		case "StoreExport": return requireReceiptThread(request.request.threadId);
+		case "StoreExport":
+		case "StoreWorkPage":
+		case "StoreWorkRebuild":
+		case "StoreRangePage":
+		case "StoreRangeSeal":
+		case "StoreRangeArchive":
+		case "StoreRangeVerify":
+		case "StoreVerification":
+		case "StoreWorkerCapacity": return requireReceiptThread(request.request.threadId);
 	}
 };
 /**
 * Admit an already Schema-decoded request to a logical Thread in this physical owner.
 * Custom hosts validate local placement before calling this Effect and provide their same
-* runtime/maintenance instances. The native endpoint uses this path too: queue limits,
+* runtime, maintenance and alarm instances. The native endpoint uses this path too: queue limits,
 * idempotent receipts and the pre-admission generation/alarm commit have one owner.
 */
-const submit = Effect.fn("ThreadObject.submit")(function* (threadId, request) {
+const submit = Effect.fnUntraced(function* (threadId, request) {
 	if (!(yield* ThreadObjectPlacement).ownsThread(threadId)) return yield* HostProtocolError.make({ message: "The Thread belongs to another Object" });
 	const mutations = yield* ThreadMutationGate;
 	const runtime = yield* DurableAgentRuntime;
+	const alarm = yield* DurableAlarmService;
 	yield* gateAdmissionLimits(threadId, request);
 	return yield* mutations.withMutation(runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
 		threadId,
@@ -613,11 +799,12 @@ const submit = Effect.fn("ThreadObject.submit")(function* (threadId, request) {
 		...request.workerAdmission === void 0 ? {} : { workerAdmission: request.workerAdmission },
 		...request.messageAdmission === void 0 ? {} : { messageAdmission: request.messageAdmission },
 		definitions: request.definitions
-	}).pipe(Effect.tap(() => publishCommitted)));
+	}).pipe(alarm.withHintsDeferred, Effect.tap(() => publishCommitted)));
 });
 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 receipt = yield* submit(identity.threadId, request);
+	if ((yield* DurableObjectAlarm.ScheduleConfiguration).dispatchAfterEvent === true) yield* (yield* DurableAlarmService).scheduleNow.pipe(Effect.catch((error) => Effect.logWarning("Post-admission maintenance hint failed", error)));
 	return SubmitSucceeded.make({ receipt });
 })), respond, Effect.flatMap(encodeResponse));
 const submissionStatusEndpoint = (encoded) => decodeReceipt(encoded).pipe(Effect.mapError(protocolFailure("The receipt could not be decoded")), Effect.flatMap((receipt) => Effect.gen(function* () {
@@ -631,16 +818,22 @@ const submissionStatusEndpoint = (encoded) => decodeReceipt(encoded).pipe(Effect
 	const runtime = yield* DurableAgentRuntime;
 	return SubmissionStatusResponse.make({ status: yield* runtime.submissionStatus(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* () {
-	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+const awaitSettlementEndpoint = (encoded, includeRecord = false) => decodeReceipt(encoded).pipe(Effect.mapError(protocolFailure("The receipt could not be decoded")), Effect.flatMap((receipt) => Effect.gen(function* () {
+	const authorizer = yield* OperationAuthorizer;
+	yield* authorizer.authorize(OperationAuthorizationRequest.make({
 		operation: "awaitSettlement",
 		threadId: receipt.threadId,
 		submissionId: receipt.submissionId
 	}));
+	if (includeRecord) yield* authorizer.authorize(OperationAuthorizationRequest.make({
+		operation: "observe",
+		threadId: receipt.threadId
+	}));
 	yield* requireReceiptThread(receipt.threadId);
 	yield* requireSubmissionThread(receipt.submissionId);
-	const settlement = yield* (yield* DurableAgentRuntime).awaitSettlement(receipt);
-	return SettlementReached.make({ settlement });
+	const runtime = yield* DurableAgentRuntime;
+	if (includeRecord) return SettlementRecordReached.make({ record: yield* runtime.awaitSettlementRecord(receipt) });
+	return SettlementReached.make({ settlement: yield* runtime.awaitSettlement(receipt) });
 })), 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;
@@ -671,6 +864,14 @@ const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(
 	})));
 	return ObservedPage.make({ records: [...records] });
 })), respond, Effect.flatMap(encodeResponse));
+const watchTextEndpoint = (encoded) => Schema.decodeUnknownEffect(Request)(encoded).pipe(Effect.mapError(protocolFailure("The provisional text request could not be decoded")), Effect.flatMap(() => Effect.gen(function* () {
+	const { threadId } = yield* ThreadObjectIdentity;
+	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+		operation: "observe",
+		threadId
+	}));
+	return yield* (yield* LiveTextHub).open(threadId);
+})), Effect.catch((failure) => encodeResponse(HostFailed.make({ failure }))));
 const abortEndpoint = (encoded) => decodeAbortCommand(encoded).pipe(Effect.mapError(protocolFailure("The abort command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
 	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
 		operation: "abort",
@@ -722,10 +923,11 @@ const AdminFailure = Schema.Union([
 	ThreadStoreError,
 	ThreadNotMaterialized,
 	AppendConflict,
-	FenceRejected,
 	DurableRuntimeFailpointError,
 	DurableAlarmError,
-	HostProtocolError
+	HostProtocolError,
+	RecoveryBlocked,
+	WorkDiscoveryUnavailable
 ]);
 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 }) {};
@@ -821,8 +1023,10 @@ const ThreadRpcOperation = Schema.Literals([
 	"submitEncoded",
 	"submissionStatusEncoded",
 	"awaitSettlementEncoded",
+	"awaitSettlementRecordEncoded",
 	"awaitProgressEncoded",
 	"cancelProgressEncoded",
+	"watchTextEncoded",
 	"observePage",
 	"abortEncoded",
 	"resolveApprovalEncoded",
@@ -834,8 +1038,10 @@ const threadRpc = {
 	submitEncoded: submitEndpoint,
 	submissionStatusEncoded: submissionStatusEndpoint,
 	awaitSettlementEncoded: awaitSettlementEndpoint,
+	awaitSettlementRecordEncoded: (encoded) => awaitSettlementEndpoint(encoded, true),
 	awaitProgressEncoded: awaitProgressEndpoint,
 	cancelProgressEncoded: cancelProgressEndpoint,
+	watchTextEncoded: watchTextEndpoint,
 	observePage: observePageEndpoint,
 	abortEncoded: abortEndpoint,
 	resolveApprovalEncoded: resolveApprovalEndpoint,
@@ -850,7 +1056,7 @@ const threadRpc = {
 * The producer comes from the actual runtime configuration, never from caller input. These
 * guards supplement the existing current model/Tool and operation authorization policies.
 */
-const handleRpc = Effect.fn("ThreadObject.handleRpc")(function* (threadId, operation, encoded) {
+const handleRpc = Effect.fnUntraced(function* (threadId, operation, encoded) {
 	if (!(yield* ThreadObjectPlacement).ownsThread(threadId)) return yield* HostProtocolError.make({ message: "The Thread belongs to another Object" });
 	const { producerId } = yield* DurableRuntimeConfig;
 	return yield* threadRpc[operation](encoded).pipe(Effect.provideService(ThreadObjectIdentity, {
@@ -858,9 +1064,8 @@ const handleRpc = Effect.fn("ThreadObject.handleRpc")(function* (threadId, opera
 		producerId
 	}));
 });
-const alarmEndpoint = Effect.gen(function* () {
-	yield* (yield* ThreadMaintenance).pass;
-});
+/** Compose with application registrations on a shared physical object. */
+const alarms = ThreadMaintenanceAlarm.handlers({ "@yielded/agent/thread-maintenance": () => Effect.flatMap(ThreadMaintenance, (maintenance) => Effect.asVoid(maintenance.pass)) });
 const gateEndpoint = Effect.gen(function* () {
 	yield* (yield* ThreadMaintenance).ensureAlarm;
 });
@@ -917,21 +1122,15 @@ const make = (applicationLayer, options) => {
 		retryEncoded: (encoded) => retryEndpoint(encoded),
 		obligationsEncoded: (encoded) => obligationsEndpoint(encoded)
 	};
-	const EffectCfThreadObject = DurableObject.make(runtime, {
+	return DurableObject.make(runtime, {
 		...options.rpcTracing === true ? { rpcTracing: { service: options.namespaceBinding } } : {},
 		...options.eventLayer === void 0 ? {} : { eventLayer: options.eventLayer },
 		initialize: Effect.void,
 		rpc,
-		alarm: () => alarmEndpoint
+		alarms: options.alarms === void 0 ? alarms : DurableObjectAlarm.mergeAll(options.alarms, alarms)
 	});
-	class ThreadObject extends EffectCfThreadObject {
-		alarm(alarmInfo) {
-			return super.alarm?.(alarmInfo);
-		}
-	}
-	return ThreadObject;
 };
 //#endregion
-export { layer as C, layerInHost as E, ThreadObjectPorts as S, layerHostConfig as T, encodeAdminResponse as _, AdminVerifyRequest as a, portCall as b, RetryExecuted as c, VerifiedIntegrity as d, decodeAdminExplainRequest as f, decodeRetryCommand as g, decodeObligationThresholds as h, AdminResponse as i, ThreadObject_exports as l, decodeAdminVerifyRequest as m, AdminFailed as n, ExplainedRecovery as o, decodeAdminResponse as p, AdminFailure as r, ObligationsScanned as s, AdminExplainRequest as t, ThreadRpcOperation as u, handleRpc as v, layerConfig as w, submit as x, make as y };
+export { ThreadObjectPorts as C, layerInHost as D, layerHostConfig as E, submit as S, layerConfig as T, decodeRetryCommand as _, AdminVerifyRequest as a, make as b, RetryExecuted as c, VerifiedIntegrity as d, alarms as f, decodeObligationThresholds as g, decodeAdminVerifyRequest as h, AdminResponse as i, ThreadObject_exports as l, decodeAdminResponse as m, AdminFailed as n, ExplainedRecovery as o, decodeAdminExplainRequest as p, AdminFailure as r, ObligationsScanned as s, AdminExplainRequest as t, ThreadRpcOperation as u, encodeAdminResponse as v, layer$1 as w, portCall as x, handleRpc as y };
 
-//# sourceMappingURL=ThreadObject-DHjrnlX4.mjs.map
+//# sourceMappingURL=ThreadObject-C0vrcDrw.mjs.map