@effect-agent/platform-cloudflare 0.1.0-beta.79 → 0.1.0-beta.80

package/dist/{ThreadObject-KJf_5Isr.mjs → ThreadObject-DGkXv41C.mjs}

@@ -1,16 +1,16 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, threadNamespaceFromEnv } from "./CloudflareBindings.mjs";
+import { DurableObjectContext, ThreadObjectIdentity, ThreadObjectNamespace, ThreadObjectPlacement, threadNamespaceFromEnv } from "./CloudflareBindings.mjs";
 import { AdmissionLimitExceeded, CLOUDFLARE_RUNTIME_DEFAULTS, CloudflareDurableRuntimeConfig, CloudflareDurableRuntimeConfigValue, CloudflarePlatformConfigError } from "./CloudflareConfig.mjs";
 import { DurableAlarmError, DurableAlarmService, ThreadMaintenance, ThreadMaintenanceFailpoint, ThreadMessageDelivery, ThreadMutationGate, ThreadPublication, publishCommitted } from "./Alarm.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-G7N4DDqS.mjs";
+import { t as cloudflarePreparedInputAdmissionLayer } from "./prepared-admission-DSi55W-7.mjs";
 import { cloudflareWakeSchedulerLayer } from "./WakeScheduler.mjs";
+import { SubmissionId, ThreadId } from "@effect-agent/core/Identifiers";
 import { compileRegistrations } from "@effect-agent/thread/AgentRegistration";
 import { DurableAgentRuntime, DurableRuntimeConfig, RecoveryReport } from "@effect-agent/thread/DurableAgentRuntime";
-import { AdmissionPolicyError, LedgerError, OwnershipLost, SettlementConflict, SubmissionLedger, SubmissionLookupByKey } from "@effect-agent/thread/SubmissionLedger";
+import { AdmissionPolicyError, LedgerError, OwnershipLost, SettlementConflict, SubmissionLedger, SubmissionLookupById, SubmissionLookupByKey } from "@effect-agent/thread/SubmissionLedger";
 import { ThreadProjectionMaintenance } from "@effect-agent/thread/ThreadProjectionMaintenance";
 import { Cause, Clock, Context, Deferred, Duration, Effect, Layer, Option, Ref, Schema, Semaphore, Stream } from "effect";
-import { SubmissionId, ThreadId } from "@effect-agent/core/Identifiers";
 import { PersistedJson, ProducerId } from "@effect-agent/thread/Records";
 import { DurableObject, DurableObjectState, WorkerEnvironment } from "effect-cf";
 import { BrowserCrypto } from "@effect/platform-browser";
@@ -19,7 +19,8 @@ import { DigestError } from "@effect-agent/thread/Digest";
 import { DurableRuntimeFailpoint, DurableRuntimeFailpointError } from "@effect-agent/thread/DurableFailpoint";
 import { OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, operationAuthorizerLayer } from "@effect-agent/thread/OperationAuthorizer";
 import { AppendConflict, FenceRejected, ThreadNotMaterialized, ThreadRead, ThreadStore, ThreadStoreError } from "@effect-agent/thread/ThreadStore";
-import { decodePortRequest, encodePortResponse } from "@effect-agent/storage-cloudflare/PortProtocol";
+import "@effect-agent/thread/PreparedInputAdmission";
+import { LedgerLookupResult, PortFailed, PortProtocolError, PortSucceeded, decodePortRequest, encodePortResponse } from "@effect-agent/storage-cloudflare/PortProtocol";
 import { IntegrityReport, ObligationReport, ObligationThresholds, RecoveryExplanation, RetryCommand, RetryRefused } from "@effect-agent/thread/Admin";
 import { RunJournalError } from "@effect-agent/thread/RunJournal";
 import { WakeScheduler } from "@effect-agent/thread/WakeScheduler";
@@ -38,10 +39,10 @@ const guardedMessageDeliveryStoreLayer = Layer.effect(MessageDeliveryStore, Effe
 	const store = yield* MessageDeliveryStore;
 	const mutations = yield* ThreadMutationGate;
 	const wakes = yield* WakeScheduler;
-	const { threadId } = yield* ThreadObjectIdentity;
+	const { ownsThread } = yield* ThreadObjectPlacement;
 	const deadline = yield* Ref.make(void 0);
 	const cacheGate = yield* Semaphore.make(1);
-	const local = (owner, body) => owner === threadId ? body : Effect.fail(MessageDeliveryError.make({
+	const local = (owner, body) => owner === void 0 || ownsThread(owner) ? body : Effect.fail(MessageDeliveryError.make({
 		reason: "validation",
 		operation: "message owner"
 	}));
@@ -52,17 +53,20 @@ const guardedMessageDeliveryStoreLayer = Layer.effect(MessageDeliveryStore, Effe
 	const nextDeadline = cacheGate.withPermit(Effect.gen(function* () {
 		const cached = yield* Ref.get(deadline);
 		if (cached !== void 0) return cached;
-		const current = yield* store.nextDeadline(threadId);
+		const current = yield* store.nextDeadline();
 		yield* Ref.set(deadline, current);
 		return current;
 	}));
 	return MessageDeliveryStore.of({
-		insert: (record) => local(record.key.ownerThreadId, mutate(store.insert(record)).pipe(Effect.tap(() => wakes.notify(threadId)))),
+		insert: (record) => local(record.key.ownerThreadId, mutate(store.insert(record)).pipe(Effect.tap(() => wakes.notify(record.key.ownerThreadId)))),
 		get: (key) => local(key.ownerThreadId, store.get(key)),
 		list: (request) => local(request.ownerThreadId, store.list(request)),
 		change: (key, change) => local(key.ownerThreadId, mutate(store.change(key, change))),
-		due: (nowMillis, limit, owner = threadId) => local(owner, store.due(nowMillis, limit, threadId)),
-		nextDeadline: (owner = threadId) => local(owner, nextDeadline)
+		due: (nowMillis, limit, owner) => local(owner, store.due(nowMillis, limit, owner)).pipe(Effect.flatMap((keys) => keys.every((key) => ownsThread(key.ownerThreadId)) ? Effect.succeed(keys) : Effect.fail(MessageDeliveryError.make({
+			reason: "validation",
+			operation: "message owner"
+		})))),
+		nextDeadline: (owner) => local(owner, owner === void 0 ? nextDeadline : store.nextDeadline(owner))
 	});
 }));
 /** Message progress shares the native alarm slot without blocking source runtime work. */
@@ -71,27 +75,26 @@ const threadMessageDeliveryLayer = Layer.effectContext(Effect.gen(function* () {
 	const store = yield* MessageDeliveryStore;
 	const wakes = yield* WakeScheduler;
 	const config = yield* CloudflareDurableRuntimeConfig;
-	const { threadId } = yield* ThreadObjectIdentity;
 	const failure = (operation) => () => DurableAlarmError.make({
 		operation,
 		message: "Durable message recovery remains pending"
 	});
 	const drain = Effect.gen(function* () {
-		const deadline = yield* store.nextDeadline(threadId);
-		if (deadline !== null && deadline <= (yield* Clock.currentTimeMillis)) yield* driver.runDue(threadId);
+		const deadline = yield* store.nextDeadline();
+		if (deadline !== null && deadline <= (yield* Clock.currentTimeMillis)) yield* driver.runDue();
 	}).pipe(Effect.mapError(failure("drain message delivery")));
 	return Context.make(ThreadMessageDelivery, {
 		drain,
 		drainUntil: Effect.fn("ThreadMessageDelivery.drainUntil")(function* (finished) {
+			const notified = (yield* Stream.toPull(wakes.wakes)).pipe(Effect.catch(() => Effect.never));
 			yield* Effect.gen(function* () {
-				const notified = yield* wakes.subscribe(threadId);
 				yield* drain;
-				const deadline = yield* store.nextDeadline(threadId).pipe(Effect.mapError(failure("read message deadline")));
+				const deadline = yield* store.nextDeadline().pipe(Effect.mapError(failure("read message deadline")));
 				const delay = deadline === null ? config.wakeScanInterval : Math.min(config.wakeScanInterval, Math.max(1, deadline - (yield* Clock.currentTimeMillis)));
 				yield* Effect.raceFirst(Deferred.await(finished), Effect.raceFirst(notified, Effect.sleep(delay)));
-			}).pipe(Effect.scoped, Effect.repeat({ until: () => Deferred.isDone(finished) }));
-		}),
-		pendingDeadline: store.nextDeadline(threadId).pipe(Effect.map(Option.fromNullishOr), Effect.mapError(failure("read message deadline")))
+			}).pipe(Effect.repeat({ until: () => Deferred.isDone(finished) }));
+		}, Effect.scoped),
+		pendingDeadline: store.nextDeadline().pipe(Effect.map(Option.fromNullishOr), Effect.mapError(failure("read message deadline")))
 	});
 }));
 //#endregion
@@ -172,9 +175,9 @@ var ProgressWaitRegistry = class ProgressWaitRegistry extends Context.Service()(
 * turns exactly this error into `AdmissionIndeterminate` (SUB-031).
 */
 const threadPortTransportLayer = Layer.effect(ThreadPortTransport)(Effect.gen(function* () {
-	const { namespace } = yield* ThreadObjectNamespace;
+	const { get } = yield* ThreadObjectNamespace;
 	return ThreadPortTransport.of({ call: (threadId, request) => Effect.tryPromise({
-		try: () => namespace.get(namespace.idFromName(threadId)).portCall(request),
+		try: () => get(threadId).portCall(request),
 		catch: (cause) => portTransportFailure(threadId, cause)
 	}).pipe(Effect.withSpan("CloudflarePortTransport.call", { attributes: { threadId } })) });
 }));
@@ -226,18 +229,10 @@ const threadIdFromState = (ctx) => ctx.id.name === void 0 ? Effect.fail(Cloudfla
 * The native class factory builds this Layer inside its constructor gate. Custom Effect hosts
 * can provide it around the complete application Layer with the native context already supplied.
 */
-const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
+const runtimeConfigLayer = (options, producerId) => Layer.unwrap(Effect.gen(function* () {
 	const { ctx } = yield* DurableObjectContext;
 	const config = yield* configFromOptions(options);
-	const threadId = yield* threadIdFromState(ctx);
-	const producerId = yield* decodeProducerId(`${config.producerPrefix}:${threadId}`).pipe(Effect.mapError((error) => CloudflarePlatformConfigError.make({
-		message: `The minted producer identity is invalid: ${error.message}`,
-		cause: error
-	})));
-	return Layer.mergeAll(Layer.succeed(CloudflareDurableRuntimeConfig, config), Layer.succeed(ThreadObjectIdentity, {
-		threadId,
-		producerId
-	}), DurableRuntimeConfig.layer({
+	return Layer.mergeAll(Layer.succeed(CloudflareDurableRuntimeConfig, config), DurableRuntimeConfig.layer({
 		deploymentId: config.deploymentId,
 		producerId,
 		settlementPollInterval: Duration.millis(config.settlementPollInterval),
@@ -249,6 +244,30 @@ const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
 		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);
 }));
+const producerIdentity = (prefix, owner) => decodeProducerId(`${prefix}:${owner}`).pipe(Effect.mapError((error) => CloudflarePlatformConfigError.make({
+	message: `The minted producer identity is invalid: ${error.message}`,
+	cause: error
+})));
+/** Native one-Thread configuration; retains its existing producer and logical identities. */
+const layerConfig = (options) => Layer.unwrap(Effect.gen(function* () {
+	const { ctx } = yield* DurableObjectContext;
+	const threadId = yield* threadIdFromState(ctx);
+	const producerId = yield* producerIdentity(options.producerPrefix, threadId);
+	return Layer.mergeAll(runtimeConfigLayer(options, producerId), Layer.succeed(ThreadObjectIdentity, {
+		threadId,
+		producerId
+	}), Layer.succeed(ThreadObjectPlacement, { ownsThread: (target) => target === threadId }));
+}));
+/**
+* Configuration for an application Object owning several logical Threads. The producer is
+* the stable physical Object. No logical identity is installed globally: handleRpc binds and
+* validates it per request using the placement guard and this actual runtime producer.
+*/
+const layerHostConfig = (options, ownsThread) => Layer.unwrap(Effect.gen(function* () {
+	const { ctx } = yield* DurableObjectContext;
+	const producerId = yield* producerIdentity(options.producerPrefix, ctx.id.toString());
+	return Layer.merge(runtimeConfigLayer(options, producerId), Layer.succeed(ThreadObjectPlacement, { ownsThread }));
+}));
 /**
 * Register typed Agents and version declarations. Hashing and dependency capture happen in
 * this Layer's Scope, after application Layers have been provided. Every Agent's instruction,
@@ -265,10 +284,14 @@ function layer(registrations, options = {}) {
 * Supply host services through `ThreadObject.make` or `ThreadObject.layerConfig` and
 * the Durable Object context and namespace Layers when composing a custom host.
 */
-const boundLayer = (bindings, options = {}) => Layer.unwrap(Effect.gen(function* () {
+const boundLayer = (bindings, options = {}) => Layer.unwrap(Effect.map(DurableObjectContext, ({ ctx }) => sharedLayer(DurableAgentRuntime.layerWithBindings(bindings), options).pipe(Layer.provideMerge(SqliteClient.layer({ storage: ctx.storage })))));
+function layerInHost(application, options = {}) {
+	return sharedLayer(application, options);
+}
+const sharedLayer = (application, options = {}) => Layer.unwrap(Effect.gen(function* () {
 	const { ctx } = yield* DurableObjectContext;
 	const config = yield* CloudflareDurableRuntimeConfig;
-	const { threadId } = yield* ThreadObjectIdentity;
+	const { ownsThread } = yield* ThreadObjectPlacement;
 	const storageOptions = {
 		storage: ctx.storage,
 		observationPollInterval: config.observationPollInterval,
@@ -276,7 +299,7 @@ const boundLayer = (bindings, options = {}) => Layer.unwrap(Effect.gen(function*
 		maxStoredValueBytes: config.maxStoredValueBytes,
 		verifyOnOpen: config.verifyOnOpen
 	};
-	const infrastructure = Layer.mergeAll(storageConfigLayer(storageOptions), SqliteClient.layer({ storage: ctx.storage }));
+	const infrastructure = Layer.mergeAll(storageConfigLayer(storageOptions), Layer.effect(SqlClient)(SqlClient));
 	const rawLocalPorts = Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(Layer.provide(infrastructure));
 	const base = Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer);
 	const wakes = cloudflareWakeSchedulerLayer.pipe(Layer.provide(base));
@@ -317,10 +340,14 @@ const boundLayer = (bindings, options = {}) => Layer.unwrap(Effect.gen(function*
 	})).pipe(Layer.provide(rawLocalPorts));
 	const portsEndpointLayer = Layer.effect(ThreadObjectPorts)(Effect.gen(function* () {
 		const local = yield* Effect.context();
-		return ThreadObjectPorts.of({ handle: (request) => executePortRequest(request).pipe(Effect.provide(local)) });
+		const ledger = Context.get(local, SubmissionLedger);
+		return ThreadObjectPorts.of({
+			handle: (request) => executePortRequest(request).pipe(Effect.provide(local)),
+			lookupSubmission: (submissionId) => ledger.lookup(SubmissionLookupById.make({ submissionId }))
+		});
 	})).pipe(Layer.provide(localPorts));
-	const routedPorts = Layer.mergeAll(routedSubmissionLedgerLayer({ localThreadId: threadId }), routedThreadStoreLayer({ localThreadId: threadId })).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
-	const runtimeStack = DurableAgentRuntime.layerWithBindings(bindings).pipe(Layer.provide(cloudflarePreparedInputAdmissionLayer.pipe(Layer.provide(CloudflareThreadClient.layer))), Layer.provideMerge(messageStore), Layer.provideMerge(routedPorts), Layer.provideMerge(wakes), Layer.provideMerge(base));
+	const routedPorts = Layer.mergeAll(routedSubmissionLedgerLayer({ ownsThread }), routedThreadStoreLayer({ ownsThread })).pipe(Layer.provide(localPorts), Layer.provide(threadPortTransportLayer));
+	const runtimeStack = application.pipe(Layer.provide(cloudflarePreparedInputAdmissionLayer.pipe(Layer.provide(CloudflareThreadClient.layer))), Layer.provideMerge(messageStore), Layer.provideMerge(routedPorts), Layer.provideMerge(wakes), Layer.provideMerge(base), Layer.provideMerge(portsEndpointLayer));
 	return Layer.mergeAll(runtimeStack, ThreadMaintenance.layer.pipe(Layer.provide(runtimeStack), Layer.provide(messageRecovery)), portsEndpointLayer, messageStore, messageRecovery).pipe(Layer.provideMerge(publication), Layer.provideMerge(projection), Layer.provideMerge(ThreadMutationGate.layer), Layer.provideMerge(infrastructure));
 }));
 //#endregion
@@ -334,6 +361,8 @@ var ThreadObject_exports = /* @__PURE__ */ __exportAll({
 	ExplainedRecovery: () => ExplainedRecovery,
 	ObligationsScanned: () => ObligationsScanned,
 	RetryExecuted: () => RetryExecuted,
+	ThreadObjectPorts: () => ThreadObjectPorts,
+	ThreadRpcOperation: () => ThreadRpcOperation,
 	VerifiedIntegrity: () => VerifiedIntegrity,
 	decodeAdminExplainRequest: () => decodeAdminExplainRequest,
 	decodeAdminResponse: () => decodeAdminResponse,
@@ -341,9 +370,14 @@ var ThreadObject_exports = /* @__PURE__ */ __exportAll({
 	decodeObligationThresholds: () => decodeObligationThresholds,
 	decodeRetryCommand: () => decodeRetryCommand,
 	encodeAdminResponse: () => encodeAdminResponse,
+	handleRpc: () => handleRpc,
 	layer: () => layer,
 	layerConfig: () => layerConfig,
-	make: () => make
+	layerHostConfig: () => layerHostConfig,
+	layerInHost: () => layerInHost,
+	make: () => make,
+	portCall: () => portCall,
+	submit: () => submit
 });
 /** Classify only a decoded port request so new protocol members cannot bypass pre-arming. */
 const isMutatingPortRequest = (request) => {
@@ -388,13 +422,12 @@ 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* (request) {
-	const identity = yield* ThreadObjectIdentity;
+const gateAdmissionLimits = Effect.fn("ThreadObject.gateAdmissionLimits")(function* (threadId, request) {
 	const config = yield* CloudflareDurableRuntimeConfig;
 	const ledger = yield* SubmissionLedger;
 	const { ctx } = yield* DurableObjectContext;
 	const existing = yield* ledger.lookup(SubmissionLookupByKey.make({
-		threadId: identity.threadId,
+		threadId,
 		principal: request.principal,
 		idempotencyKey: request.idempotencyKey
 	}));
@@ -405,7 +438,7 @@ const gateAdmissionLimits = Effect.fn("ThreadObject.gateAdmissionLimits")(functi
 		actual: inputBytes,
 		maximum: config.limits.maxInputBytes
 	});
-	const nonterminal = yield* Stream.runCollect(ledger.scanNonterminal);
+	const nonterminal = yield* ledger.scanNonterminal.pipe(Stream.filter((submission) => submission.threadId === threadId), Stream.runCollect);
 	if (nonterminal.length >= config.limits.maxQueueDepthPerLane) return yield* AdmissionLimitExceeded.make({
 		limit: "queue-depth",
 		actual: nonterminal.length,
@@ -428,13 +461,51 @@ const passthroughSubmitAgent = (agentId) => ({ definition: {
 	id: agentId,
 	input: PersistedJson
 } });
-const submitEndpoint = (encoded) => decodeSubmitRequest(encoded).pipe(Effect.mapError(protocolFailure("The submit request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	const identity = yield* ThreadObjectIdentity;
-	const maintenance = yield* ThreadMaintenance;
+/** A physical owner may hold other Threads; an addressed request cannot act on their IDs. */
+const lookupAddressedSubmission = Effect.fn("ThreadObject.lookupAddressedSubmission")(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 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) {
+	if (threadId !== (yield* ThreadObjectIdentity).threadId) return yield* HostProtocolError.make({ message: "The Receipt belongs to another Thread" });
+});
+const requirePortThread = (request) => {
+	switch (request._tag) {
+		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 "LedgerAdmit":
+		case "LedgerResolveAdmission":
+		case "StoreMaterialize":
+		case "StoreAppend":
+		case "StoreReadPage":
+		case "StoreInspectTail":
+		case "StoreExport": 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,
+* idempotent receipts and the pre-admission generation/alarm commit have one owner.
+*/
+const submit = Effect.fn("ThreadObject.submit")(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;
-	yield* gateAdmissionLimits(request);
-	const receipt = yield* maintenance.withMutation(runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
-		threadId: identity.threadId,
+	yield* gateAdmissionLimits(threadId, request);
+	return yield* mutations.withMutation(runtime.submit(passthroughSubmitAgent(request.agentId), request.inputPayload, {
+		threadId,
 		principal: request.principal,
 		idempotencyKey: request.idempotencyKey,
 		...request.admissionGroup === void 0 ? {} : { admissionGroup: request.admissionGroup },
@@ -442,14 +513,32 @@ const submitEndpoint = (encoded) => decodeSubmitRequest(encoded).pipe(Effect.map
 		...request.workerAdmission === void 0 ? {} : { workerAdmission: request.workerAdmission },
 		...request.messageAdmission === void 0 ? {} : { messageAdmission: request.messageAdmission },
 		definitions: request.definitions
-	}));
+	}).pipe(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);
 	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* () {
+	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+		operation: "awaitSettlement",
+		threadId: receipt.threadId,
+		submissionId: receipt.submissionId
+	}));
+	yield* requireReceiptThread(receipt.threadId);
+	yield* requireSubmissionThread(receipt.submissionId);
 	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({
+		operation: "awaitSettlement",
+		threadId: receipt.threadId,
+		submissionId: receipt.submissionId
+	}));
+	yield* requireReceiptThread(receipt.threadId);
+	yield* requireSubmissionThread(receipt.submissionId);
 	const settlement = yield* (yield* DurableAgentRuntime).awaitSettlement(receipt);
 	return SettlementReached.make({ settlement });
 })), respond, Effect.flatMap(encodeResponse));
@@ -458,13 +547,14 @@ const awaitProgressEndpoint = (encoded) => decodeAwaitProgressRequest(encoded).p
 	const runtime = yield* DurableAgentRuntime;
 	const registry = yield* ProgressWaitRegistry;
 	yield* Effect.scoped(Effect.gen(function* () {
-		const cancelled = yield* registry.subscribe(request.waiterId);
+		const cancelled = yield* registry.subscribe(JSON.stringify([identity.threadId, request.waiterId]));
 		yield* Effect.raceFirst(runtime.awaitProgress(identity.threadId, request.afterSequence), cancelled);
 	}));
 	return ProgressObserved.make();
 })), respond, Effect.flatMap(encodeResponse));
 const cancelProgressEndpoint = (encoded) => decodeCancelProgressRequest(encoded).pipe(Effect.mapError(protocolFailure("The progress cancellation could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
-	yield* (yield* ProgressWaitRegistry).cancel(request.waiterId);
+	const identity = yield* ThreadObjectIdentity;
+	yield* (yield* ProgressWaitRegistry).cancel(JSON.stringify([identity.threadId, request.waiterId]));
 	return ProgressCancelled.make();
 })), respond, Effect.flatMap(encodeResponse));
 const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(Effect.mapError(protocolFailure("The observe request could not be decoded")), Effect.flatMap((request) => Effect.gen(function* () {
@@ -482,18 +572,33 @@ const observePageEndpoint = (encoded) => decodeObservePageRequest(encoded).pipe(
 	return ObservedPage.make({ records: [...records] });
 })), respond, Effect.flatMap(encodeResponse));
 const abortEndpoint = (encoded) => decodeAbortCommand(encoded).pipe(Effect.mapError(protocolFailure("The abort command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
+	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+		operation: "abort",
+		submissionId: command.submissionId
+	}));
+	yield* requireSubmissionThread(command.submissionId);
 	const maintenance = yield* ThreadMaintenance;
 	const runtime = yield* DurableAgentRuntime;
 	const intent = yield* maintenance.withMutation(runtime.abort(command));
 	return AbortRecorded.make({ intent });
 })), respond, Effect.flatMap(encodeResponse));
 const resolveApprovalEndpoint = (encoded) => decodeApprovalDecisionCommand(encoded).pipe(Effect.mapError(protocolFailure("The approval command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
+	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+		operation: "resolveApproval",
+		submissionId: command.submissionId
+	}));
+	yield* requireSubmissionThread(command.submissionId);
 	const maintenance = yield* ThreadMaintenance;
 	const runtime = yield* DurableAgentRuntime;
 	const intent = yield* maintenance.withMutation(runtime.resolveApproval(command));
 	return ApprovalRecorded.make({ intent });
 })), respond, Effect.flatMap(encodeResponse));
 const resolveUnknownEndpoint = (encoded) => decodeUnknownResolutionCommand(encoded).pipe(Effect.mapError(protocolFailure("The resolution command could not be decoded")), Effect.flatMap((command) => Effect.gen(function* () {
+	yield* (yield* OperationAuthorizer).authorize(OperationAuthorizationRequest.make({
+		operation: "resolveUnknown",
+		submissionId: command.submissionId
+	}));
+	yield* requireSubmissionThread(command.submissionId);
 	const maintenance = yield* ThreadMaintenance;
 	const runtime = yield* DurableAgentRuntime;
 	const intent = yield* maintenance.withMutation(runtime.resolveUnknown(command));
@@ -579,7 +684,9 @@ const obligationsEndpoint = (encoded) => decodeObligationThresholds(encoded).pip
 * alarm so the mutated lane is processed promptly. Protocol anomalies answer
 * `PortFailed(PortProtocolError)`.
 */
-const portCallEndpoint = (encoded) => Effect.gen(function* () {
+const encodePortResponseTotal = (response) => encodePortResponse(response).pipe(Effect.catch((error) => Effect.succeed(encodedPortProtocolFailure(`The port response could not be encoded: ${error.message}`))));
+const portGuardFailure = (failure) => PortFailed.make({ failure: failure._tag === "LedgerError" ? failure : PortProtocolError.make({ message: "The port request is not for the addressed Thread" }) });
+const portCall = (encoded) => Effect.gen(function* () {
 	const ports = yield* ThreadObjectPorts;
 	const maintenance = yield* ThreadMaintenance;
 	const alarm = yield* DurableAlarmService;
@@ -591,10 +698,16 @@ const portCallEndpoint = (encoded) => Effect.gen(function* () {
 		message: error.message
 	})));
 	if (decoded._tag === "failure") return encodedPortProtocolFailure(`The port request could not be decoded: ${decoded.message}`);
+	if (decoded.request._tag === "LedgerLookup" && decoded.request.request._tag === "SubmissionLookupById") {
+		const response = yield* lookupAddressedSubmission(decoded.request.request.submissionId).pipe(Effect.map((submission) => PortSucceeded.make({ result: LedgerLookupResult.make(Option.isSome(submission) ? { submission: submission.value } : {}) })), Effect.catch((failure) => Effect.succeed(portGuardFailure(failure))));
+		return yield* encodePortResponseTotal(response);
+	}
+	const identityCheck = yield* requirePortThread(decoded.request).pipe(Effect.result);
+	if (identityCheck._tag === "Failure") return yield* encodePortResponseTotal(portGuardFailure(identityCheck.failure));
 	const mutating = isMutatingPortRequest(decoded.request);
 	const handled = yield* (mutating ? maintenance.withMutation(ports.handle(decoded.request)) : ports.handle(decoded.request)).pipe(Effect.exit);
 	if (handled._tag === "Failure") return encodedPortProtocolFailure("The owner Object could not arm its maintenance alarm before the mutation.");
-	const response = yield* encodePortResponse(handled.value).pipe(Effect.catch((error) => Effect.succeed(encodedPortProtocolFailure(`The port response could not be encoded: ${error.message}`))));
+	const response = yield* encodePortResponseTotal(handled.value);
 	if (mutating) yield* alarm.scheduleNow.pipe(Effect.catch((error) => Effect.logWarning("ThreadObject.portCall: immediate re-arm failed", error)));
 	return response;
 });
@@ -602,6 +715,48 @@ const wakeEndpoint = Effect.gen(function* () {
 	const identity = yield* ThreadObjectIdentity;
 	yield* (yield* WakeScheduler).notify(identity.threadId);
 });
+/** The per-Thread wire operations supported by native and application-owned endpoints. */
+const ThreadRpcOperation = Schema.Literals([
+	"submitEncoded",
+	"submissionStatusEncoded",
+	"awaitSettlementEncoded",
+	"awaitProgressEncoded",
+	"cancelProgressEncoded",
+	"observePage",
+	"abortEncoded",
+	"resolveApprovalEncoded",
+	"resolveUnknownEncoded",
+	"portCall",
+	"wake"
+]);
+const threadRpc = {
+	submitEncoded: submitEndpoint,
+	submissionStatusEncoded: submissionStatusEndpoint,
+	awaitSettlementEncoded: awaitSettlementEndpoint,
+	awaitProgressEncoded: awaitProgressEndpoint,
+	cancelProgressEncoded: cancelProgressEndpoint,
+	observePage: observePageEndpoint,
+	abortEncoded: abortEndpoint,
+	resolveApprovalEncoded: resolveApprovalEndpoint,
+	resolveUnknownEncoded: resolveUnknownEndpoint,
+	portCall,
+	wake: () => wakeEndpoint
+};
+/**
+* Bind an addressed request to its logical Thread while sharing one physical runtime. This
+* validates local placement before invoking the same native handlers. Receipts, Submission
+* commands and port envelopes must match this identity; progress cancellation is Thread-scoped.
+* 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) {
+	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, {
+		threadId,
+		producerId
+	}));
+});
 const alarmEndpoint = Effect.gen(function* () {
 	yield* (yield* ThreadMaintenance).pass;
 });
@@ -626,7 +781,7 @@ const effectCfPlatformLayer = (namespaceBinding, rpcTracing = false) => {
 		const env = yield* WorkerEnvironment;
 		const binding = yield* threadNamespaceFromEnv(env, namespaceBinding);
 		return ThreadObjectNamespace.of({
-			namespace: binding,
+			get: (threadId) => binding.get(binding.idFromName(threadId)),
 			...rpcTracing === true ? { rpcTracing: namespaceBinding } : {}
 		});
 	}));
@@ -655,21 +810,11 @@ const make = (applicationLayer, options) => {
 		}));
 	}));
 	const rpc = {
-		submitEncoded: (encoded) => submitEndpoint(encoded),
-		submissionStatusEncoded: (encoded) => submissionStatusEndpoint(encoded),
-		awaitSettlementEncoded: (encoded) => awaitSettlementEndpoint(encoded),
-		awaitProgressEncoded: (encoded) => awaitProgressEndpoint(encoded),
-		cancelProgressEncoded: (encoded) => cancelProgressEndpoint(encoded),
-		observePage: (encoded) => observePageEndpoint(encoded),
-		abortEncoded: (encoded) => abortEndpoint(encoded),
-		resolveApprovalEncoded: (encoded) => resolveApprovalEndpoint(encoded),
-		resolveUnknownEncoded: (encoded) => resolveUnknownEndpoint(encoded),
+		...threadRpc,
 		explainEncoded: (encoded) => explainEndpoint(encoded),
 		verifyEncoded: (encoded) => verifyEndpoint(encoded),
 		retryEncoded: (encoded) => retryEndpoint(encoded),
-		obligationsEncoded: (encoded) => obligationsEndpoint(encoded),
-		portCall: (encoded) => portCallEndpoint(encoded),
-		wake: () => wakeEndpoint
+		obligationsEncoded: (encoded) => obligationsEndpoint(encoded)
 	};
 	const EffectCfThreadObject = DurableObject.make(runtime, {
 		...options.rpcTracing === true ? { rpcTracing: { service: options.namespaceBinding } } : {},
@@ -686,6 +831,6 @@ const make = (applicationLayer, options) => {
 	return ThreadObject;
 };
 //#endregion
-export { make as _, AdminVerifyRequest as a, RetryExecuted as c, decodeAdminExplainRequest as d, decodeAdminResponse as f, encodeAdminResponse as g, decodeRetryCommand as h, AdminResponse as i, ThreadObject_exports as l, decodeObligationThresholds as m, AdminFailed as n, ExplainedRecovery as o, decodeAdminVerifyRequest as p, AdminFailure as r, ObligationsScanned as s, AdminExplainRequest as t, VerifiedIntegrity as u, layer as v, layerConfig as y };
+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 };
 
-//# sourceMappingURL=ThreadObject-KJf_5Isr.mjs.map
+//# sourceMappingURL=ThreadObject-DGkXv41C.mjs.map