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

package/dist/PortRouting.mjs

@@ -1,13 +1,17 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { LedgerAdmitCall, LedgerAdmitResult, LedgerInspectWorkerCall, LedgerInspectWorkerResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, LedgerStopWorkerCall, LedgerStopWorkerResult, MessageDeliveryCompleteCall, MessageDeliveryCompleteResult, MessageDeliveryListCall, MessageDeliveryListResult, PortFailed, PortProtocolError, PortSucceeded, StoreAppendCall, StoreAppendResult, StoreCountPeerMessagesCall, StoreCountPeerMessagesResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreReadIdentityCall, StoreReadIdentityResult, StoreReadPageCall, StoreReadPageResult, WorkerAdmitCall, WorkerAdmitResult, boundPortDiagnostic, decodePortRequest, decodePortResponse, encodePortRequest, encodePortResponse } from "./PortProtocol.mjs";
+import { LedgerAdmitCall, LedgerAdmitResult, LedgerFundingOwnerCall, LedgerFundingOwnerResult, LedgerInspectWorkerCall, LedgerInspectWorkerResult, LedgerLookupCall, LedgerLookupResult, LedgerMarkReadyCall, LedgerMarkReadyResult, LedgerRecordChildSettledCall, LedgerRecordChildSettledResult, LedgerRequestAbortCall, LedgerRequestAbortResult, LedgerResolveAdmissionCall, LedgerResolveAdmissionResult, LedgerStopWorkerCall, LedgerStopWorkerResult, MessageDeliveryCompleteCall, MessageDeliveryCompleteResult, MessageDeliveryListCall, MessageDeliveryListResult, PortFailed, PortProtocolError, PortSucceeded, SettlementPublishCall, SettlementPublishResult, StoreAppendCall, StoreAppendResult, StoreCountPeerMessagesCall, StoreCountPeerMessagesResult, StoreExportCall, StoreExportResult, StoreInspectTailCall, StoreInspectTailResult, StoreMaterializeCall, StoreMaterializeResult, StoreRangeArchiveCall, StoreRangeArchiveResult, StoreRangePageCall, StoreRangePageResult, StoreRangeSealCall, StoreRangeSealResult, StoreRangeVerifyCall, StoreRangeVerifyResult, StoreReadExecutionCall, StoreReadExecutionResult, StoreReadIdentityCall, StoreReadIdentityResult, StoreReadPageCall, StoreReadPageResult, StoreReadPromptCall, StoreReadPromptResult, StoreVerificationCall, StoreVerificationResult, StoreWorkPageCall, StoreWorkPageResult, StoreWorkRebuildCall, StoreWorkRebuildResult, StoreWorkerCapacityCall, StoreWorkerCapacityResult, WorkerAdmitCall, WorkerAdmitResult, boundPortDiagnostic, decodePortRequest, decodePortResponse, encodePortRequest, encodePortResponse } from "./PortProtocol.mjs";
 import { MessageDeliveryError, MessageDeliveryStore } from "@yielded/agent/message-delivery";
 import { Cause, Clock, Context, Effect, Layer, Option, Predicate, Schema, Stream } from "effect";
 import { LifecyclePublicationError } from "@yielded/agent/lifecycle-publication";
-import { AppendConflict, FenceRejected, ThreadMaterialization, ThreadNotMaterialized, ThreadStore, ThreadStoreError } from "@yielded/agent/thread-store";
-import { AdmissionConflict, AdmissionIndeterminate, AdmissionPolicyError, ChildAttachmentSnapshot, JoinedToHost, LedgerError, RecoverySnapshot, SettlementConflict, SubmissionLedger, SubmissionLookupById } from "@yielded/agent/submission-ledger";
+import { AppendConflict, ThreadExportRejected, ThreadMaterialization, ThreadNotMaterialized, ThreadReader, ThreadStore, ThreadStoreError } from "@yielded/agent/thread-store";
+import { SettlementPublisher } from "@yielded/agent/settlement-publisher";
+import { AdmissionConflict, AdmissionIndeterminate, AdmissionPolicyError, ChildAttachmentSnapshot, JoinedToHost, LedgerError, OwnershipLost, RecoverySnapshot, SettlementConflict, SubmissionLedger, SubmissionLookupById } from "@yielded/agent/submission-ledger";
+import { checkExportSource } from "@yielded/agent/thread-transfer";
+import { WorkDiscoveryUnavailable } from "@yielded/agent/thread-work";
 import { WorkerAdmissionFailure, WorkerAdmissionPort, admitWorker } from "@yielded/agent/worker-admission";
 //#region src/PortRouting.ts
 var PortRouting_exports = /* @__PURE__ */ __exportAll({
+	CurrentNativeSource: () => CurrentNativeSource,
 	PortTransportError: () => PortTransportError,
 	ThreadPortTransport: () => ThreadPortTransport,
 	executePortRequest: () => executePortRequest,
@@ -15,12 +19,15 @@ var PortRouting_exports = /* @__PURE__ */ __exportAll({
 	makeLocalSubmissionLookup: () => makeLocalSubmissionLookup,
 	portTransportFailure: () => portTransportFailure,
 	routedMessageDeliveryStoreLayer: () => routedMessageDeliveryStoreLayer,
+	routedSettlementPublisherLayer: () => routedSettlementPublisherLayer,
 	routedSubmissionLedgerLayer: () => routedSubmissionLedgerLayer,
 	routedThreadStoreLayer: () => routedThreadStoreLayer,
 	routedWorkerAdmissionLayer: () => routedWorkerAdmissionLayer
 });
 const ThreadIdSchema = ThreadMaterialization.fields.threadId;
 const decodeThreadId = Schema.decodeUnknownEffect(ThreadIdSchema);
+/** Owner-local maintenance scope; permits local inventory without global Object enumeration. */
+const CurrentNativeSource = Context.Reference("@effect-agent/storage-cloudflare/CurrentNativeSource", { defaultValue: () => false });
 /**
 * The ledger row bound routable Submission identities must respect (mirrors the local
 * facet's `MAX_IDENTIFIER_LENGTH`; the minting side already refuses longer identities typed
@@ -91,7 +98,7 @@ const LOCAL = { _tag: "local" };
 * Identities beyond the ledger's 1,024-character row bound fail typed: the minting side
 * refused them at admission, so they cannot name any stored row anywhere.
 */
-const routableSubmissionTarget = (ownsThread) => Effect.fn("DoPortRouting.routableSubmissionTarget")(function* (operation, submissionId) {
+const routableSubmissionTarget = (ownsThread) => Effect.fnUntraced(function* (operation, submissionId) {
 	if (submissionId.length > MAX_ROUTABLE_SUBMISSION_ID_LENGTH) return yield* LedgerError.make({
 		operation,
 		message: `A Submission identity of ${submissionId.length} characters exceeds the ${MAX_ROUTABLE_SUBMISSION_ID_LENGTH}-character routable identity bound; admission refuses such identities, so it cannot name any stored row.`
@@ -112,7 +119,7 @@ const routableSubmissionTarget = (ownsThread) => Effect.fn("DoPortRouting.routab
 */
 const makeLocalSubmissionLookup = (options) => {
 	const submissionTarget = routableSubmissionTarget(options.ownsThread);
-	return Effect.fn("DoPortRouting.lookupLocalSubmission")(function* (submissionId) {
+	return Effect.fnUntraced(function* (submissionId) {
 		const operation = "local Submission lookup";
 		if ((yield* submissionTarget(operation, submissionId))._tag === "foreign") return yield* LedgerError.make({
 			operation,
@@ -131,7 +138,7 @@ const AbortPortFailure = Schema.Union([SettlementConflict, JoinedToHost]);
 const AppendPortFailure = Schema.Union([
 	ThreadNotMaterialized,
 	AppendConflict,
-	FenceRejected
+	OwnershipLost
 ]);
 /**
 * The fail-fast refusal for any foreign operation OUTSIDE the closed route-capable subset
@@ -143,14 +150,14 @@ const crossThreadLedgerError = (operation, target) => LedgerError.make({
 });
 const crossThreadStoreError = (operation, target) => ThreadStoreError.make({
 	operation,
-	message: `${operation} addressed to foreign Thread ${target} is not route-capable; the closed cross-Object subset is materialize, append, read (paged), inspectTail, and export. Observation and checkpoints are lane-local by construction and must execute inside the owning Thread's Durable Object.`
+	message: `${operation} addressed to foreign Thread ${target} is not route-capable; the closed cross-Object subset is materialize, append, read and readPrompt (paged), inspectTail, and export. Observation and checkpoints are lane-local by construction and must execute inside the owning Thread's Durable Object.`
 });
-const makeTransportCall = (transport) => Effect.fn("DoPortRouting.transportCall")(function* (target, call) {
+const makeTransportCall = (transport) => Effect.fnUntraced(function* (target, call) {
 	const encoded = yield* encodePortRequest(call).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be encoded: ${error.message}`) })));
 	const raw = yield* transport.call(target, encoded);
 	return yield* decodePortResponse(raw).pipe(Effect.mapError((error) => PortProtocolError.make({ message: boundPortDiagnostic(`The port response could not be decoded: ${error.message}`) })));
 });
-const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServices")(function* (options) {
+const makeRoutedLedgerServices = Effect.fnUntraced(function* (options) {
 	const local = yield* SubmissionLedger;
 	const transport = yield* ThreadPortTransport;
 	const transportCall = makeTransportCall(transport);
@@ -218,7 +225,7 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 	* local nor marker-settled. A transport failure surfaces as `LedgerError` so the alarm
 	* pass retries; the child's canonical Settlement remains the only authority (DUR-015).
 	*/
-	const enrichChildAttachments = Effect.fn("DoPortRouting.enrichChildAttachments")(function* (snapshot) {
+	const enrichChildAttachments = Effect.fnUntraced(function* (snapshot) {
 		const operation = "ledger load recovery snapshot";
 		const attachments = new Map(snapshot.childAttachments.map((attachment) => [attachment.childSubmissionId, attachment]));
 		let enriched = false;
@@ -254,6 +261,13 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 		admit: (request) => options.ownsThread(request.threadId) ? local.admit(request) : foreignLedgerCall("ledger admit", request.threadId, LedgerAdmitCall.make({ request }), LedgerAdmitResult, Schema.Union([AdmissionConflict, AdmissionPolicyError])).pipe(Effect.map((reply) => reply.result)),
 		markReady: (request) => submissionTarget("ledger mark ready", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markReady(request) : foreignLedgerCall("ledger mark ready", target.threadId, LedgerMarkReadyCall.make({ request }), LedgerMarkReadyResult, NoAdditionalPortFailure).pipe(Effect.asVoid))),
 		lookup: (request) => request._tag === "SubmissionLookupById" ? submissionTarget("ledger lookup", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.lookup(request) : foreignLookupById("ledger lookup", target.threadId, request.submissionId))) : options.ownsThread(request.threadId) ? local.lookup(request) : foreignLedgerCall("ledger lookup", request.threadId, LedgerLookupCall.make({ request }), LedgerLookupResult, NoAdditionalPortFailure).pipe(Effect.map((result) => result.submission === void 0 ? Option.none() : Option.some(result.submission))),
+		resolveFundingOwner: (request) => (options.ownsThread(request.threadId) ? local.resolveFundingOwner === void 0 ? Effect.fail(LedgerError.make({
+			operation: "resolve funding owner",
+			message: "Native funding-owner lookup unavailable."
+		})) : local.resolveFundingOwner(request) : foreignLedgerCall("resolve funding owner", request.threadId, LedgerFundingOwnerCall.make({ request }), LedgerFundingOwnerResult, NoAdditionalPortFailure).pipe(Effect.map((reply) => reply.funding))).pipe(Effect.filterOrFail((funding) => funding.selected.submissionId === request.submissionId && funding.selected.threadId === request.threadId && funding.owner.threadId === request.threadId, () => LedgerError.make({
+			operation: "resolve funding owner",
+			message: "Funding-owner response belongs to another input or Thread."
+		}))),
 		resolveAdmission: (request) => options.ownsThread(request.threadId) ? local.resolveAdmission(request) : resolveForeignAdmission(request.threadId, request),
 		inspectWorker: (threadId) => options.ownsThread(threadId) ? local.inspectWorker === void 0 ? Effect.fail(LedgerError.make({
 			operation: "inspectWorker",
@@ -265,12 +279,9 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 		})) : local.stopWorker(request) : foreignLedgerCall("ledger stop worker", request.threadId, LedgerStopWorkerCall.make({ request }), LedgerStopWorkerResult, NoAdditionalPortFailure).pipe(Effect.map((reply) => reply.owned)),
 		requestAbort: (request) => submissionTarget("ledger request abort", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.requestAbort(request) : foreignLedgerCall("ledger request abort", target.threadId, LedgerRequestAbortCall.make({ request }), LedgerRequestAbortResult, AbortPortFailure).pipe(Effect.map((reply) => reply.intent)))),
 		recordChildSettled: (request) => submissionTarget("ledger record child settled", request.parentSubmissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.recordChildSettled(request) : foreignLedgerCall("ledger record child settled", target.threadId, LedgerRecordChildSettledCall.make({ request }), LedgerRecordChildSettledResult, NoAdditionalPortFailure).pipe(Effect.map((reply) => reply.outcome)))),
-		claim: (request) => options.ownsThread(request.threadId) ? local.claim(request) : Effect.fail(crossThreadLedgerError("ledger claim", request.threadId)),
+		selectHead: (request) => options.ownsThread(request.threadId) ? local.selectHead(request) : Effect.fail(crossThreadLedgerError("ledger claim", request.threadId)),
 		claimJoining: (request) => options.ownsThread(request.threadId) ? local.claimJoining(request) : Effect.fail(crossThreadLedgerError("ledger claim joining", request.threadId)),
-		renewOwnership: (request) => submissionTarget("ledger renew ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.renewOwnership(request) : Effect.fail(crossThreadLedgerError("ledger renew ownership", target.threadId)))),
-		releaseOwnership: (request) => submissionTarget("ledger release ownership", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.releaseOwnership(request) : Effect.fail(crossThreadLedgerError("ledger release ownership", target.threadId)))),
 		markInputApplied: (request) => submissionTarget("ledger mark input applied", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markInputApplied(request) : Effect.fail(crossThreadLedgerError("ledger mark input applied", target.threadId)))),
-		reserveSettlement: (request) => submissionTarget("ledger reserve settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.reserveSettlement(request) : Effect.fail(crossThreadLedgerError("ledger reserve settlement", target.threadId)))),
 		finalizeSettlement: (request) => submissionTarget("ledger finalize settlement", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.finalizeSettlement(request) : Effect.fail(crossThreadLedgerError("ledger finalize settlement", target.threadId)))),
 		markJoined: (request) => submissionTarget("ledger mark joined", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.markJoined(request) : Effect.fail(crossThreadLedgerError("ledger mark joined", target.threadId)))),
 		revertJoining: (request) => submissionTarget("ledger revert joining", request.submissionId).pipe(Effect.flatMap((target) => target._tag === "local" ? local.revertJoining(request) : Effect.fail(crossThreadLedgerError("ledger revert joining", target.threadId)))),
@@ -288,10 +299,41 @@ const makeRoutedLedgerServices = Effect.fn("DoPortRouting.makeRoutedLedgerServic
 	});
 	return Context.make(SubmissionLedger, routed);
 });
-const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices")(function* (options) {
+/** Route the data-only atomic publication to the same owner as its canonical Thread. */
+const routedSettlementPublisherLayer = (options) => Layer.effect(SettlementPublisher)(Effect.gen(function* () {
+	const local = yield* SettlementPublisher;
+	const call = makeTransportCall(yield* ThreadPortTransport);
+	const isFailure = Schema.is(Schema.Union([
+		LedgerError,
+		OwnershipLost,
+		SettlementConflict,
+		ThreadStoreError,
+		ThreadNotMaterialized,
+		AppendConflict
+	]));
+	return SettlementPublisher.of({ publish: (request) => {
+		if (options.ownsThread(request.append.threadId)) return local.publish(request);
+		return call(request.append.threadId, SettlementPublishCall.make({ request })).pipe(Effect.mapError((cause) => LedgerError.make({
+			operation: "route settlement publication",
+			message: cause.message,
+			cause
+		})), Effect.flatMap((response) => {
+			if (response._tag === "PortFailed") return isFailure(response.failure) ? Effect.fail(response.failure) : Effect.fail(LedgerError.make({
+				operation: "route settlement publication",
+				message: "Unexpected publication failure",
+				cause: response.failure
+			}));
+			return response.result._tag === "SettlementPublishResult" ? Effect.succeed(response.result.result) : Effect.fail(LedgerError.make({
+				operation: "route settlement publication",
+				message: "Mismatched publication result"
+			}));
+		}));
+	} });
+}));
+const makeRoutedStoreServices = Effect.fnUntraced(function* (options) {
 	const local = yield* ThreadStore;
 	const checkpoints = local.checkpoints;
-	const recoveryCheckpoints = local.recoveryCheckpoints;
+	const promptCheckpoints = local.promptCheckpoints;
 	const lifecyclePublications = local.lifecyclePublications;
 	const acknowledgeMany = lifecyclePublications?.acknowledgeMany;
 	const transport = yield* ThreadPortTransport;
@@ -328,16 +370,43 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
 		} }));
 	};
 	const routed = ThreadStore.of({
+		readExecution: (request) => options.ownsThread(request.threadId) ? local.readExecution(request) : foreignStoreCall("read execution", request.threadId, StoreReadExecutionCall.make({ request }), StoreReadExecutionResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.checkpoint)),
+		archives: {
+			page: (request) => options.ownsThread(request.threadId) ? local.archives === void 0 ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId)) : local.archives.page(request) : foreignStoreCall("archive page", request.threadId, StoreRangePageCall.make({ request }), StoreRangePageResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.page)),
+			seal: (request) => options.ownsThread(request.threadId) ? local.archives === void 0 ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId)) : local.archives.seal(request) : foreignStoreCall("archive seal", request.threadId, StoreRangeSealCall.make({ request }), StoreRangeSealResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.range)),
+			archive: (request) => options.ownsThread(request.threadId) ? local.archives === void 0 ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId)) : local.archives.archive(request) : foreignStoreCall("archive archive", request.threadId, StoreRangeArchiveCall.make({ request }), StoreRangeArchiveResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.range)),
+			verify: (request) => options.ownsThread(request.threadId) ? local.archives === void 0 ? Effect.fail(crossThreadStoreError("archive unavailable", request.threadId)) : local.archives.verify(request) : foreignStoreCall("archive verify", request.threadId, StoreRangeVerifyCall.make({ request }), StoreRangeVerifyResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.range))
+		},
+		work: {
+			threads: (request) => Effect.flatMap(CurrentNativeSource, (nativeSource) => nativeSource && local.work !== void 0 ? local.work.threads(request) : Effect.fail(ThreadStoreError.make({
+				operation: "work threads",
+				message: nativeSource ? "The local Thread owner does not provide work inventory." : "Global Thread enumeration is unsupported by the owner-local Durable Object namespace. Use the local owner's work storage."
+			}))),
+			page: (request) => options.ownsThread(request.threadId) ? local.work === void 0 ? Effect.fail(WorkDiscoveryUnavailable.make({
+				threadId: request.threadId,
+				reason: "unsupported"
+			})) : local.work.page(request) : foreignStoreCall("work page", request.threadId, StoreWorkPageCall.make({ request }), StoreWorkPageResult, WorkDiscoveryUnavailable).pipe(Effect.map((reply) => reply.page)),
+			rebuild: (request) => options.ownsThread(request.threadId) ? local.work === void 0 ? Effect.fail(WorkDiscoveryUnavailable.make({
+				threadId: request.threadId,
+				reason: "unsupported"
+			})) : local.work.rebuild(request) : foreignStoreCall("rebuild work", request.threadId, StoreWorkRebuildCall.make({ request }), StoreWorkRebuildResult, WorkDiscoveryUnavailable).pipe(Effect.flatMap((reply) => reply.progress.threadId === request.threadId ? Effect.succeed(reply.progress) : Effect.fail(ThreadStoreError.make({
+				operation: "rebuild work",
+				message: "The rebuild progress belongs to another Thread."
+			}))))
+		},
+		readWorkerCapacity: (request) => (options.ownsThread(request.threadId) ? local.readWorkerCapacity === void 0 ? Effect.fail(crossThreadStoreError("worker capacity unavailable", request.threadId)) : local.readWorkerCapacity(request) : foreignStoreCall("worker capacity", request.threadId, StoreWorkerCapacityCall.make({ request }), StoreWorkerCapacityResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.capacity))).pipe(Effect.filterOrFail((capacity) => capacity.threadId === request.threadId && capacity.tailSequence === request.expectedTailSequence, () => crossThreadStoreError("worker capacity response mismatch", request.threadId))),
+		verification: { verify: (request) => options.ownsThread(request.threadId) ? local.verification === void 0 ? Effect.fail(crossThreadStoreError("verification unavailable", request.threadId)) : local.verification.verify(request) : foreignStoreCall("thread verification", request.threadId, StoreVerificationCall.make({ request }), StoreVerificationResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.report)) },
 		countPeerMessages: (request) => options.ownsThread(request.threadId) ? local.countPeerMessages === void 0 ? Effect.fail(crossThreadStoreError("peer count unavailable", request.threadId)) : local.countPeerMessages(request) : foreignStoreCall("thread countPeerMessages", request.threadId, StoreCountPeerMessagesCall.make({ request }), StoreCountPeerMessagesResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.count)),
-		materialize: (request) => options.ownsThread(request.threadId) ? local.materialize(request) : foreignStoreCall("thread materialize", request.threadId, StoreMaterializeCall.make({ request }), StoreMaterializeResult, FenceRejected).pipe(Effect.asVoid),
+		materialize: (request) => options.ownsThread(request.threadId) ? local.materialize(request) : foreignStoreCall("thread materialize", request.threadId, StoreMaterializeCall.make({ request }), StoreMaterializeResult, NoAdditionalPortFailure).pipe(Effect.asVoid),
 		append: (request) => options.ownsThread(request.threadId) ? local.append(request) : foreignStoreCall("thread append", request.threadId, StoreAppendCall.make({ request }), StoreAppendResult, AppendPortFailure).pipe(Effect.map((reply) => reply.result)),
 		read: (request) => options.ownsThread(request.threadId) ? local.read(request) : Stream.unwrap(foreignStoreCall("thread read", request.threadId, StoreReadPageCall.make({ request }), StoreReadPageResult, ThreadNotMaterialized).pipe(Effect.map((reply) => Stream.fromIterable(reply.records)))),
+		readPrompt: (request) => options.ownsThread(request.threadId) ? local.readPrompt(request) : Stream.unwrap(foreignStoreCall("thread read prompt", request.threadId, StoreReadPromptCall.make({ request }), StoreReadPromptResult, ThreadNotMaterialized).pipe(Effect.map((reply) => Stream.fromIterable(reply.records)))),
 		inspectTail: (request) => options.ownsThread(request.threadId) ? local.inspectTail(request) : foreignStoreCall("thread inspect tail", request.threadId, StoreInspectTailCall.make({ request }), StoreInspectTailResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.tail)),
 		readIdentity: (request) => options.ownsThread(request.threadId) ? local.readIdentity(request) : foreignStoreCall("thread read identity", request.threadId, StoreReadIdentityCall.make({ request }), StoreReadIdentityResult, ThreadNotMaterialized).pipe(Effect.flatMap((reply) => reply.identity.threadId === request.threadId ? Effect.succeed(reply.identity) : Effect.fail(ThreadStoreError.make({
 			operation: "thread read identity",
 			message: "The identity snapshot belongs to another Thread."
 		})))),
-		export: (request) => options.ownsThread(request.threadId) ? local.export(request) : foreignStoreCall("thread export", request.threadId, StoreExportCall.make({ request }), StoreExportResult, ThreadNotMaterialized).pipe(Effect.map((reply) => reply.export)),
+		export: (request) => checkExportSource(request.threadId).pipe(Effect.andThen(options.ownsThread(request.threadId) ? local.export(request) : foreignStoreCall("thread export", request.threadId, StoreExportCall.make({ request }), StoreExportResult, Schema.Union([ThreadNotMaterialized, ThreadExportRejected])).pipe(Effect.map((reply) => reply.export)))),
 		observe: (request) => options.ownsThread(request.threadId) ? local.observe(request) : Stream.unwrap(Effect.fail(crossThreadStoreError("thread observe", request.threadId))),
 		...lifecyclePublications === void 0 ? {} : { lifecyclePublications: {
 			...lifecyclePublications,
@@ -346,13 +415,13 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
 			claim: (batch, nowMillis, timeoutMillis) => batch.every((publication) => options.ownsThread(publication.ownerThreadId)) ? lifecyclePublications.claim(batch, nowMillis, timeoutMillis) : Effect.fail(LifecyclePublicationError.make({ reason: "unavailable" })),
 			retryParked: (ownerThreadId, nowMillis) => options.ownsThread(ownerThreadId) ? lifecyclePublications.retryParked(ownerThreadId, nowMillis) : Effect.fail(LifecyclePublicationError.make({ reason: "unavailable" }))
 		} },
-		...recoveryCheckpoints === void 0 ? {} : { recoveryCheckpoints: {
-			save: (request) => options.ownsThread(request.checkpoint.threadId) ? recoveryCheckpoints.save(request) : Effect.fail(crossThreadStoreError("thread save recovery checkpoint", request.checkpoint.threadId)),
-			load: (request) => options.ownsThread(request.threadId) ? recoveryCheckpoints.load(request) : Effect.succeed(Option.none())
-		} },
 		...checkpoints === void 0 ? {} : { checkpoints: {
 			save: (request) => options.ownsThread(request.checkpoint.threadId) ? checkpoints.save(request) : Effect.fail(crossThreadStoreError("thread save checkpoint", request.checkpoint.threadId)),
 			load: (request) => options.ownsThread(request.threadId) ? checkpoints.load(request) : Effect.fail(crossThreadStoreError("thread load checkpoint", request.threadId))
+		} },
+		...promptCheckpoints === void 0 ? {} : { promptCheckpoints: {
+			save: (request) => options.ownsThread(request.threadId) ? promptCheckpoints.save(request) : Effect.fail(crossThreadStoreError("save prompt checkpoint", request.threadId)),
+			load: (request) => options.ownsThread(request.threadId) ? promptCheckpoints.load(request) : Effect.fail(crossThreadStoreError("load prompt checkpoint", request.threadId))
 		} }
 	});
 	return Context.make(ThreadStore, routed);
@@ -367,11 +436,11 @@ const makeRoutedStoreServices = Effect.fn("DoPortRouting.makeRoutedStoreServices
 const routedSubmissionLedgerLayer = (options) => Layer.effectContext(makeRoutedLedgerServices(options));
 /**
 * Routing decorator over the LOCAL `ThreadStore` facet (plan §1.3): this-thread
-* requests execute locally; foreign materialize/append/read/inspectTail/export travel the
-* transport. Foreign recovery-cache loads return none for canonical replay; other foreign
-* checkpoint operations and observation fail fast typed.
+* requests execute locally; foreign store reads, writes, and exact-Thread work pages/rebuild
+* travel the transport. Work enumeration stays local under CurrentNativeSource; global
+* enumeration, foreign checkpoints, and observation fail typed.
 */
-const routedThreadStoreLayer = (options) => Layer.effectContext(makeRoutedStoreServices(options));
+const routedThreadStoreLayer = (options) => ThreadReader.layer().pipe(Layer.provideMerge(Layer.effectContext(makeRoutedStoreServices(options))));
 /** Route validated worker admission as one operation; source policy hooks stay at the caller. */
 const routedWorkerAdmissionLayer = (options) => Layer.effect(WorkerAdmissionPort, Effect.gen(function* () {
 	const call = makeTransportCall(yield* ThreadPortTransport);
@@ -432,8 +501,42 @@ const capture = (effect) => effect.pipe(Effect.map((result) => PortSucceeded.mak
 * Failures never escape — every typed port failure becomes a `PortFailed` envelope that
 * re-decodes on the caller side.
 */
-const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(function* (request) {
+const executePortRequest = Effect.fnUntraced(function* (request) {
 	switch (request._tag) {
+		case "StoreRangePage": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.archives === void 0 ? crossThreadStoreError("archive unavailable", request.request.threadId) : store.archives.page(request.request).pipe(Effect.map((page) => StoreRangePageResult.make({ page }))));
+		}
+		case "StoreRangeSeal": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.archives === void 0 ? crossThreadStoreError("archive unavailable", request.request.threadId) : store.archives.seal(request.request).pipe(Effect.map((range) => StoreRangeSealResult.make({ range }))));
+		}
+		case "StoreRangeArchive": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.archives === void 0 ? crossThreadStoreError("archive unavailable", request.request.threadId) : store.archives.archive(request.request).pipe(Effect.map((range) => StoreRangeArchiveResult.make({ range }))));
+		}
+		case "StoreRangeVerify": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.archives === void 0 ? crossThreadStoreError("archive unavailable", request.request.threadId) : store.archives.verify(request.request).pipe(Effect.map((range) => StoreRangeVerifyResult.make({ range }))));
+		}
+		case "StoreWorkPage": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.work === void 0 ? Effect.fail(WorkDiscoveryUnavailable.make({
+				threadId: request.request.threadId,
+				reason: "unsupported"
+			})) : store.work.page(request.request).pipe(Effect.map((page) => StoreWorkPageResult.make({ page }))));
+		}
+		case "StoreWorkRebuild": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.work === void 0 ? Effect.fail(WorkDiscoveryUnavailable.make({
+				threadId: request.request.threadId,
+				reason: "unsupported"
+			})) : store.work.rebuild(request.request).pipe(Effect.map((progress) => StoreWorkRebuildResult.make({ progress }))));
+		}
+		case "SettlementPublish": {
+			const publisher = yield* SettlementPublisher;
+			return yield* capture(publisher.publish(request.request).pipe(Effect.map((result) => SettlementPublishResult.make({ result }))));
+		}
 		case "MessageDeliveryComplete": {
 			const store = yield* MessageDeliveryStore;
 			return yield* capture(store.change(request.key, {
@@ -463,6 +566,13 @@ const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(functio
 			const ledger = yield* SubmissionLedger;
 			return yield* capture(ledger.lookup(request.request).pipe(Effect.map((submission) => Option.isSome(submission) ? LedgerLookupResult.make({ submission: submission.value }) : LedgerLookupResult.make({}))));
 		}
+		case "LedgerFundingOwner": {
+			const ledger = yield* SubmissionLedger;
+			return yield* capture(ledger.resolveFundingOwner === void 0 ? Effect.fail(LedgerError.make({
+				operation: "resolve funding owner",
+				message: "Native funding-owner lookup unavailable."
+			})) : ledger.resolveFundingOwner(request.request).pipe(Effect.map((funding) => LedgerFundingOwnerResult.make({ funding }))));
+		}
 		case "LedgerResolveAdmission": {
 			const ledger = yield* SubmissionLedger;
 			return yield* capture(ledger.resolveAdmission(request.request).pipe(Effect.map((resolution) => LedgerResolveAdmissionResult.make({ resolution }))));
@@ -501,14 +611,30 @@ const executePortRequest = Effect.fn("DoPortRouting.executePortRequest")(functio
 			const store = yield* ThreadStore;
 			return yield* capture(store.read(request.request).pipe(Stream.runCollect, Effect.map((records) => StoreReadPageResult.make({ records: [...records] }))));
 		}
+		case "StoreReadPrompt": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.readPrompt(request.request).pipe(Stream.runCollect, Effect.map((records) => StoreReadPromptResult.make({ records }))));
+		}
 		case "StoreInspectTail": {
 			const store = yield* ThreadStore;
 			return yield* capture(store.inspectTail(request.request).pipe(Effect.map((tail) => StoreInspectTailResult.make({ tail }))));
 		}
+		case "StoreReadExecution": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.readExecution(request.request).pipe(Effect.map((checkpoint) => StoreReadExecutionResult.make({ checkpoint }))));
+		}
 		case "StoreReadIdentity": {
 			const store = yield* ThreadStore;
 			return yield* capture(store.readIdentity(request.request).pipe(Effect.map((identity) => StoreReadIdentityResult.make({ identity }))));
 		}
+		case "StoreWorkerCapacity": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.readWorkerCapacity === void 0 ? Effect.fail(crossThreadStoreError("worker capacity unavailable", request.request.threadId)) : store.readWorkerCapacity(request.request).pipe(Effect.map((capacity) => StoreWorkerCapacityResult.make({ capacity }))));
+		}
+		case "StoreVerification": {
+			const store = yield* ThreadStore;
+			return yield* capture(store.verification === void 0 ? Effect.fail(crossThreadStoreError("verification unavailable", request.request.threadId)) : store.verification.verify(request.request).pipe(Effect.map((report) => StoreVerificationResult.make({ report }))));
+		}
 		case "StoreExport": {
 			const store = yield* ThreadStore;
 			return yield* capture(store.export(request.request).pipe(Effect.map((threadExport) => StoreExportResult.make({ export: threadExport }))));
@@ -534,11 +660,11 @@ const encodedProtocolFailure = (message) => ({
 * cannot be encoded, answers `PortFailed(PortProtocolError)` instead of throwing, so the
 * transport never has to interpret exceptions as protocol answers.
 */
-const handleEncodedPortRequest = Effect.fn("DoPortRouting.handleEncodedPortRequest")(function* (encoded) {
+const handleEncodedPortRequest = Effect.fnUntraced(function* (encoded) {
 	const response = yield* decodePortRequest(encoded).pipe(Effect.flatMap(executePortRequest), Effect.catch((error) => Effect.succeed(PortFailed.make({ failure: PortProtocolError.make({ message: boundPortDiagnostic(`The port request could not be decoded: ${error.message}`) }) }))));
 	return yield* encodePortResponse(response).pipe(Effect.catch((error) => Effect.succeed(encodedProtocolFailure(`The port response could not be encoded: ${error.message}`))));
 });
 //#endregion
-export { PortTransportError, ThreadPortTransport, executePortRequest, handleEncodedPortRequest, makeLocalSubmissionLookup, portTransportFailure, routedMessageDeliveryStoreLayer, routedSubmissionLedgerLayer, routedThreadStoreLayer, routedWorkerAdmissionLayer, PortRouting_exports as t };
+export { CurrentNativeSource, PortTransportError, ThreadPortTransport, executePortRequest, handleEncodedPortRequest, makeLocalSubmissionLookup, portTransportFailure, routedMessageDeliveryStoreLayer, routedSettlementPublisherLayer, routedSubmissionLedgerLayer, routedThreadStoreLayer, routedWorkerAdmissionLayer, PortRouting_exports as t };
 
 //# sourceMappingURL=PortRouting.mjs.map