@effect-agent/storage-memory 0.1.0-beta.38 → 0.1.0-beta.39

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AttemptId, ConversationId, ReceiptId, SubmissionId } from "@effect-agent/core";
-import { AbortCommand, AbortIntent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, ConversationExport, ConversationExportRequest, ConversationMaterialization, ConversationNotMaterialized, ConversationObservation, ConversationRead, ConversationStore, ConversationStoreError, ConversationTail, ConversationTailRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SuspendRequest, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, compareScheduleKeys, compareScheduleNames, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity, settlementFailureFromRecord } from "@effect-agent/session";
+import { AttemptId, ReceiptId, SubmissionId, ThreadId } from "@effect-agent/core";
+import { AbortCommand, AbortIntent, AcceptedEvent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DeliveryChange, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SourcePartition, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, SuspendRequest, SuspensionSnapshot, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, applySubscriptionDeliveryChange, compareScheduleKeys, compareScheduleNames, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity, settlementFailureFromRecord, subscriptionCanSelect, subscriptionDeliveryCanSelect, subscriptionDeliveryKeyString, subscriptionKeyString } from "@effect-agent/thread";
 import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
 //#region src/memory-ledger.ts
 const MAX_SUBMISSIONS = 65536;
@@ -46,7 +46,7 @@ const ledgerError = (operation, message, cause) => cause === void 0 ? LedgerErro
 	message,
 	cause
 });
-const validate$1 = Effect.fn("MemorySubmissionLedger.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => ledgerError(operation, `Invalid ${operation} request`, error))));
+const validate$2 = Effect.fn("MemorySubmissionLedger.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => ledgerError(operation, `Invalid ${operation} request`, error))));
 const decodeSubmissionId = Schema.decodeSync(SubmissionId);
 const decodeReceiptId = Schema.decodeSync(ReceiptId);
 const decodeAttemptId = Schema.decodeSync(AttemptId);
@@ -56,10 +56,10 @@ const decodeProducerEpoch = Schema.decodeSync(ProducerEpoch);
 const equivalentPersistedJson = Schema.toEquivalence(PersistedJson);
 const equivalentUnknownResolution = Schema.toEquivalence(UnknownResolution);
 const utc = (millis) => DateTime.toUtc(DateTime.makeUnsafe(millis));
-const admissionKey = (conversationId, principal, idempotencyKey) => `${conversationId}\u001f${principal}\u001f${idempotencyKey}`;
+const admissionKey = (threadId, principal, idempotencyKey) => `${threadId}\u001f${principal}\u001f${idempotencyKey}`;
 const toSnapshot = (row) => SubmissionSnapshot.make({
 	submissionId: row.submissionId,
-	conversationId: row.conversationId,
+	threadId: row.threadId,
 	queueSequence: row.queueSequence,
 	principal: row.principal,
 	idempotencyKey: row.idempotencyKey,
@@ -90,10 +90,10 @@ const toReservationSnapshot = (row) => ChildBudgetReservationSnapshot.make({
 });
 /** Linkage equality: both absent, or both present naming the same parent Tool Call. */
 const sameParentLinkage = (left, right) => left === void 0 ? right === void 0 : right !== void 0 && left.parentSubmissionId === right.parentSubmissionId && left.parentToolCallId === right.parentToolCallId;
-const laneEpoch = (state, conversationId) => state.lanes.get(conversationId)?.producerEpoch ?? 0;
+const laneEpoch = (state, threadId) => state.lanes.get(threadId)?.producerEpoch ?? 0;
 const ownershipLost = (state, stored) => OwnershipLost.make({
 	submissionId: stored.row.submissionId,
-	actualEpoch: decodeProducerEpoch(laneEpoch(state, stored.row.conversationId))
+	actualEpoch: decodeProducerEpoch(laneEpoch(state, stored.row.threadId))
 });
 /** The presented token owns the lane only while it matches the live ownership record. */
 const ownsLane = (stored, ownershipToken) => stored.ownership !== void 0 && stored.ownership.ownershipToken === ownershipToken;
@@ -105,10 +105,10 @@ const withChildReservation = (state, reservation) => ({
 	...state,
 	childReservations: new Map(state.childReservations).set(reservation.reservationId, reservation)
 });
-const findHead = (state, conversationId) => {
+const findHead = (state, threadId) => {
 	let head;
 	for (const stored of state.submissions.values()) {
-		if (stored.row.conversationId !== conversationId || stored.row.state === "settled") continue;
+		if (stored.row.threadId !== threadId || stored.row.state === "settled") continue;
 		if (head === void 0 || stored.row.queueSequence < head.row.queueSequence) head = stored;
 	}
 	return head;
@@ -158,16 +158,16 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 	const leaseMillis = Duration.toMillis(DEFAULT_OWNERSHIP_LEASE_DURATION);
 	const capabilities = Effect.succeed(LedgerCapabilities.make({ durability: "non-durable" }));
 	const admit = Effect.fn("MemorySubmissionLedger.admit")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AdmissionRequest, "admit", unvalidated);
+		const request = yield* validate$2(AdmissionRequest, "admit", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
-			const key = admissionKey(request.conversationId, request.principal, request.idempotencyKey);
+			const key = admissionKey(request.threadId, request.principal, request.idempotencyKey);
 			const existingId = current.admissionIndex.get(key);
 			if (existingId !== void 0) {
 				const existing = current.submissions.get(existingId);
 				if (existing === void 0) return [failure(ledgerError("admit", "Admission index references a missing Submission")), current];
 				if (existing.row.inputDigest !== request.inputDigest || !sameParentLinkage(existing.row.parentLinkage, request.parentLinkage)) return [failure(AdmissionConflict.make({
-					conversationId: request.conversationId,
+					threadId: request.threadId,
 					principal: request.principal,
 					idempotencyKey: request.idempotencyKey,
 					existingInputDigest: existing.row.inputDigest,
@@ -182,14 +182,14 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 				})), current];
 			}
 			if (current.submissions.size >= MAX_SUBMISSIONS) return [failure(ledgerError("admit", `In-memory submission limit ${MAX_SUBMISSIONS} exceeded`)), current];
-			const lane = current.lanes.get(request.conversationId) ?? {
+			const lane = current.lanes.get(request.threadId) ?? {
 				nextQueueSequence: 1,
 				producerEpoch: 0
 			};
 			const mintCounter = current.mintCounter + 1;
 			const row = {
 				submissionId: decodeSubmissionId(`submission-memory-${mintCounter}`),
-				conversationId: request.conversationId,
+				threadId: request.threadId,
 				queueSequence: decodeQueueSequence(lane.nextQueueSequence),
 				principal: request.principal,
 				idempotencyKey: request.idempotencyKey,
@@ -218,7 +218,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 				unknownResolutions: /* @__PURE__ */ new Map()
 			});
 			const admissionIndex = new Map(current.admissionIndex).set(key, row.submissionId);
-			const lanes = new Map(current.lanes).set(request.conversationId, {
+			const lanes = new Map(current.lanes).set(request.threadId, {
 				nextQueueSequence: lane.nextQueueSequence + 1,
 				producerEpoch: lane.producerEpoch
 			});
@@ -240,7 +240,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const markReady = Effect.fn("MemorySubmissionLedger.markReady")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkReadyRequest, "markReady", unvalidated);
+		const request = yield* validate$2(MarkReadyRequest, "markReady", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
@@ -258,33 +258,33 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const lookup = Effect.fn("MemorySubmissionLedger.lookup")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SubmissionLookup, "lookup", unvalidated);
+		const request = yield* validate$2(SubmissionLookup, "lookup", unvalidated);
 		const current = yield* Ref.get(state);
-		const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.conversationId, request.principal, request.idempotencyKey));
+		const submissionId = request._tag === "SubmissionLookupById" ? request.submissionId : current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
 		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
 		return stored === void 0 ? Option.none() : Option.some(toSnapshot(stored.row));
 	}));
 	const resolveAdmission = Effect.fn("MemorySubmissionLedger.resolveAdmission")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SubmissionLookupByKey, "resolveAdmission", unvalidated);
+		const request = yield* validate$2(SubmissionLookupByKey, "resolveAdmission", unvalidated);
 		if (options.resolveAdmissionFault !== void 0) {
 			const fault = yield* options.resolveAdmissionFault;
 			if (Option.isSome(fault)) return AdmissionIndeterminate.make({ reason: fault.value });
 		}
 		const current = yield* Ref.get(state);
-		const submissionId = current.admissionIndex.get(admissionKey(request.conversationId, request.principal, request.idempotencyKey));
+		const submissionId = current.admissionIndex.get(admissionKey(request.threadId, request.principal, request.idempotencyKey));
 		const stored = submissionId === void 0 ? void 0 : current.submissions.get(submissionId);
 		return stored === void 0 ? AdmissionNotAdmitted.make() : AdmissionAdmitted.make({ submission: toSnapshot(stored.row) });
 	}));
 	const claim = Effect.fn("MemorySubmissionLedger.claim")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ClaimRequest, "claim", unvalidated);
+		const request = yield* validate$2(ClaimRequest, "claim", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
-			const head = findHead(current, request.conversationId);
+			const head = findHead(current, request.threadId);
 			if (head === void 0) return [success(Option.none()), current];
 			if (BLOCKED_HEAD_STATES.has(head.row.state) || head.row.state === "unknown" && head.abortIntent === void 0) return [success(Option.none()), current];
 			if (head.ownership !== void 0 && head.ownership.leaseExpiresAtMillis > nowMillis && head.ownership.ownerProducerId !== request.producerId) return [success(Option.none()), current];
-			const lane = current.lanes.get(request.conversationId);
-			if (lane === void 0) return [failure(ledgerError("claim", "Claimable head without a Conversation lane")), current];
+			const lane = current.lanes.get(request.threadId);
+			if (lane === void 0) return [failure(ledgerError("claim", "Claimable head without a Thread lane")), current];
 			const producerEpoch = decodeProducerEpoch(lane.producerEpoch + 1);
 			const mintCounter = current.mintCounter + 1;
 			const ownership = {
@@ -303,7 +303,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 				row,
 				ownership
 			});
-			const lanes = new Map(next.lanes).set(request.conversationId, {
+			const lanes = new Map(next.lanes).set(request.threadId, {
 				nextQueueSequence: lane.nextQueueSequence,
 				producerEpoch: lane.producerEpoch + 1
 			});
@@ -324,7 +324,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const renewOwnership = Effect.fn("MemorySubmissionLedger.renewOwnership")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RenewOwnershipRequest, "renewOwnership", unvalidated);
+		const request = yield* validate$2(RenewOwnershipRequest, "renewOwnership", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
@@ -346,7 +346,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const releaseOwnership = Effect.fn("MemorySubmissionLedger.releaseOwnership")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ReleaseOwnershipRequest, "releaseOwnership", unvalidated);
+		const request = yield* validate$2(ReleaseOwnershipRequest, "releaseOwnership", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("releaseOwnership", `Unknown Submission ${request.submissionId}`)), current];
@@ -359,7 +359,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const markInputApplied = Effect.fn("MemorySubmissionLedger.markInputApplied")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkInputAppliedRequest, "markInputApplied", unvalidated);
+		const request = yield* validate$2(MarkInputAppliedRequest, "markInputApplied", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("markInputApplied", `Unknown Submission ${request.submissionId}`)), current];
@@ -381,7 +381,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const reserveSettlement = Effect.fn("MemorySubmissionLedger.reserveSettlement")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SettlementReservation, "reserveSettlement", unvalidated);
+		const request = yield* validate$2(SettlementReservation, "reserveSettlement", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("reserveSettlement", `Unknown Submission ${request.submissionId}`)), current];
@@ -431,7 +431,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const finalizeSettlement = Effect.fn("MemorySubmissionLedger.finalizeSettlement")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SettlementFinalization, "finalizeSettlement", unvalidated);
+		const request = yield* validate$2(SettlementFinalization, "finalizeSettlement", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
@@ -478,7 +478,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const requestAbort = Effect.fn("MemorySubmissionLedger.requestAbort")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AbortCommand, "requestAbort", unvalidated);
+		const request = yield* validate$2(AbortCommand, "requestAbort", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
@@ -513,13 +513,13 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const claimJoining = Effect.fn("MemorySubmissionLedger.claimJoining")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ClaimJoiningRequest, "claimJoining", unvalidated);
+		const request = yield* validate$2(ClaimJoiningRequest, "claimJoining", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const host = current.submissions.get(request.hostSubmissionId);
 			if (host === void 0) return [failure(ledgerError("claimJoining", `Unknown Submission ${request.hostSubmissionId}`)), current];
-			if (host.row.conversationId !== request.conversationId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Conversation ${request.conversationId}`)), current];
+			if (host.row.threadId !== request.threadId) return [failure(ledgerError("claimJoining", `Host Submission ${request.hostSubmissionId} does not belong to Thread ${request.threadId}`)), current];
 			if (!ownsLane(host, request.ownershipToken)) return [failure(ownershipLost(current, host)), current];
-			const later = [...current.submissions.values()].filter((stored) => stored.row.conversationId === request.conversationId && stored.row.queueSequence > host.row.queueSequence).sort((left, right) => left.row.queueSequence - right.row.queueSequence);
+			const later = [...current.submissions.values()].filter((stored) => stored.row.threadId === request.threadId && stored.row.queueSequence > host.row.queueSequence).sort((left, right) => left.row.queueSequence - right.row.queueSequence);
 			const claims = [];
 			const submissions = new Map(current.submissions);
 			for (const stored of later) {
@@ -550,7 +550,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const markJoined = Effect.fn("MemorySubmissionLedger.markJoined")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkJoinedRequest, "markJoined", unvalidated);
+		const request = yield* validate$2(MarkJoinedRequest, "markJoined", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("markJoined", `Unknown Submission ${request.submissionId}`)), current];
@@ -579,7 +579,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const revertJoining = Effect.fn("MemorySubmissionLedger.revertJoining")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RevertJoiningRequest, "revertJoining", unvalidated);
+		const request = yield* validate$2(RevertJoiningRequest, "revertJoining", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("revertJoining", `Unknown Submission ${request.submissionId}`)), current];
@@ -596,7 +596,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const suspend = Effect.fn("MemorySubmissionLedger.suspend")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(SuspendRequest, "suspend", unvalidated);
+		const request = yield* validate$2(SuspendRequest, "suspend", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
@@ -631,7 +631,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const recordApprovalDecision = Effect.fn("MemorySubmissionLedger.recordApprovalDecision")((unvalidated) => Effect.gen(function* () {
-		const command = yield* validate$1(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
+		const command = yield* validate$2(ApprovalDecisionCommand, "recordApprovalDecision", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(command.submissionId);
@@ -676,7 +676,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const markUnknown = Effect.fn("MemorySubmissionLedger.markUnknown")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(MarkUnknownRequest, "markUnknown", unvalidated);
+		const request = yield* validate$2(MarkUnknownRequest, "markUnknown", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(request.submissionId);
 			if (stored === void 0) return [failure(ledgerError("markUnknown", `Unknown Submission ${request.submissionId}`)), current];
@@ -709,7 +709,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
 	const recordUnknownResolution = Effect.fn("MemorySubmissionLedger.recordUnknownResolution")((unvalidated) => Effect.gen(function* () {
-		const command = yield* validate$1(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
+		const command = yield* validate$2(UnknownResolutionCommand, "recordUnknownResolution", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const stored = current.submissions.get(command.submissionId);
@@ -750,7 +750,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const recordChildSettled = Effect.fn("MemorySubmissionLedger.recordChildSettled")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ChildSettledNotification, "recordChildSettled", unvalidated);
+		const request = yield* validate$2(ChildSettledNotification, "recordChildSettled", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const parent = current.submissions.get(request.parentSubmissionId);
 			if (parent === void 0) return [failure(ledgerError("recordChildSettled", `Unknown Submission ${request.parentSubmissionId}`)), current];
@@ -776,7 +776,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const reserveChildBudget = Effect.fn("MemorySubmissionLedger.reserveChildBudget")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
+		const request = yield* validate$2(ChildBudgetReservationRequest, "reserveChildBudget", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const existing = current.childReservations.get(request.reservationId);
@@ -821,7 +821,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const attachChildToReservation = Effect.fn("MemorySubmissionLedger.attachChildToReservation")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
+		const request = yield* validate$2(AttachChildToReservationRequest, "attachChildToReservation", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const reservation = current.childReservations.get(request.reservationId);
 			if (reservation === void 0) return [failure(ledgerError("attachChildToReservation", `Unknown child reservation ${request.reservationId}`)), current];
@@ -852,7 +852,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const beginChildBudgetRelease = Effect.fn("MemorySubmissionLedger.beginChildBudgetRelease")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
+		const request = yield* validate$2(BeginChildBudgetReleaseRequest, "beginChildBudgetRelease", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const reservation = current.childReservations.get(request.reservationId);
@@ -877,7 +877,7 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const releaseChildBudget = Effect.fn("MemorySubmissionLedger.releaseChildBudget")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
+		const request = yield* validate$2(ReleaseChildBudgetRequest, "releaseChildBudget", unvalidated);
 		const nowMillis = yield* Clock.currentTimeMillis;
 		const decision = yield* Ref.modify(state, (current) => {
 			const reservation = current.childReservations.get(request.reservationId);
@@ -899,11 +899,11 @@ const makeSubmissionLedger = (options = {}) => Effect.gen(function* () {
 		return decision.value;
 	}));
 	const scanNonterminal = Stream.unwrap(Ref.get(state).pipe(Effect.map((current) => {
-		const snapshots = [...current.submissions.values()].filter((stored) => stored.row.state !== "settled").sort((left, right) => left.row.conversationId < right.row.conversationId ? -1 : left.row.conversationId > right.row.conversationId ? 1 : left.row.queueSequence - right.row.queueSequence).map((stored) => toSnapshot(stored.row));
+		const snapshots = [...current.submissions.values()].filter((stored) => stored.row.state !== "settled").sort((left, right) => left.row.threadId < right.row.threadId ? -1 : left.row.threadId > right.row.threadId ? 1 : left.row.queueSequence - right.row.queueSequence).map((stored) => toSnapshot(stored.row));
 		return Stream.fromIterable(snapshots);
 	})));
 	const loadRecoverySnapshot = Effect.fn("MemorySubmissionLedger.loadRecoverySnapshot")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate$1(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
+		const request = yield* validate$2(RecoverySnapshotRequest, "loadRecoverySnapshot", unvalidated);
 		const current = yield* Ref.get(state);
 		const stored = current.submissions.get(request.submissionId);
 		if (stored === void 0) return yield* ledgerError("loadRecoverySnapshot", `Unknown Submission ${request.submissionId}`);
@@ -1150,77 +1150,667 @@ const makeScheduleStore = Effect.gen(function* () {
 const memoryScheduleStoreLayer = () => Layer.effect(ScheduleStore, makeScheduleStore);
 const MemoryScheduleStoreLive = memoryScheduleStoreLayer();
 //#endregion
+//#region src/memory-subscription-store.ts
+const error = (reason, code) => SubscriptionError.make({
+	reason,
+	code
+});
+const samePartition = (left, right) => left.tenantId === right.tenantId && left.address === right.address;
+const sameSource = (left, right) => left.name === right.name && left.version === right.version;
+const encode = (schema, value, code) => Result.try({
+	try: () => Schema.encodeSync(Schema.fromJsonString(schema))(value),
+	catch: () => error("corrupt", code)
+});
+const decode = (schema, value, code) => Result.try({
+	try: () => Schema.decodeSync(Schema.fromJsonString(schema))(value),
+	catch: () => error("corrupt", code)
+});
+const decodeEffect = (schema, value, code) => Effect.fromResult(decode(schema, value, code));
+const validate$1 = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error("validation", code)));
+const jsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const sameDeliveryIdentity = (left, right) => subscriptionDeliveryKeyString(left.key) === subscriptionDeliveryKeyString(right.key) && left.deliveryId === right.deliveryId && left.source.name === right.source.name && left.source.version === right.source.version && left.threadId === right.threadId && left.admissionKey === right.admissionKey && left.subscriptionFingerprint === right.subscriptionFingerprint && left.eventDigest === right.eventDigest;
+const candidateIndexKey = (record) => JSON.stringify([
+	record.configuration.source.name,
+	record.configuration.source.version,
+	record.configuration.matchingKey
+]);
+const eventCandidateIndexKey = (event) => JSON.stringify([
+	event.source.name,
+	event.source.version,
+	event.matchingKey
+]);
+const sameEventIdentity = (left, right) => samePartition(left.partition, right.partition) && left.eventId === right.eventId && sameSource(left.source, right.source) && left.matchingKey === right.matchingKey && left.payloadDigest === right.payloadDigest;
+const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource(delivery.source, event.source);
+const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
+	const partition = yield* validate$1(SourcePartition, ownedPartition, "partition");
+	const state = yield* Ref.make({
+		sequence: 0,
+		registrations: /* @__PURE__ */ new Map(),
+		events: /* @__PURE__ */ new Map(),
+		deliveries: /* @__PURE__ */ new Map(),
+		registrationIndex: /* @__PURE__ */ new Map(),
+		candidateIndex: /* @__PURE__ */ new Map(),
+		ownerRegistrationCounts: /* @__PURE__ */ new Map(),
+		eventIndex: /* @__PURE__ */ new Map(),
+		deliveryIndex: /* @__PURE__ */ new Map(),
+		ownerDeliveryCounts: /* @__PURE__ */ new Map(),
+		scanCursors: {
+			events: "",
+			deliveries: "",
+			recovery: 0
+		}
+	});
+	const failpoint = yield* SubscriptionFailpoint;
+	const requirePartition = (value, code) => samePartition(value.partition, partition) ? Effect.succeed(value) : Effect.fail(error("validation", code));
+	const requireKey = (key, code) => validate$1(SubscriptionKey, key, code).pipe(Effect.flatMap((decoded) => requirePartition(decoded, code)));
+	const register = Effect.fn("MemorySubscriptionStore.register")(function* (input, inputLimits) {
+		const record = yield* validate$1(SubscriptionRecord, input, "register-record");
+		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "register-limits");
+		yield* requirePartition(record.key, "register-partition");
+		yield* failpoint.hit("subscription:register:before");
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const key = subscriptionKeyString(record.key);
+			const existingText = current.registrations.get(key);
+			if (existingText !== void 0) {
+				const existing = decode(SubscriptionRecord, existingText, "register-existing");
+				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
+				return existing.success.creationFingerprint === record.creationFingerprint ? [Result.succeed(existing.success), current] : [Result.fail(error("conflict", "registration-identity")), current];
+			}
+			if (jsonBytes(record.configuration.context) > limits.maxContextBytes) return [Result.fail(error("capacity", "context-bytes")), current];
+			if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "parameters-bytes")), current];
+			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return [Result.fail(error("capacity", "lifetime")), current];
+			if (current.registrations.size >= limits.maxRegistrations) return [Result.fail(error("capacity", "registrations")), current];
+			const ownerCount = current.ownerRegistrationCounts.get(record.key.ownerId) ?? 0;
+			if (ownerCount >= limits.maxRegistrationsPerOwner) return [Result.fail(error("capacity", "owner-registrations")), current];
+			const assigned = {
+				...record,
+				ordinal: current.sequence + 1
+			};
+			const encoded = encode(SubscriptionRecord, assigned, "register-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const registrations = new Map(current.registrations);
+			registrations.set(key, encoded.success);
+			const registrationIndex = new Map(current.registrationIndex);
+			registrationIndex.set(key, {
+				key: assigned.key,
+				ordinal: assigned.ordinal,
+				state: assigned.state,
+				recoveryAt: assigned.recovery?.nextAttemptAtMillis ?? null
+			});
+			const candidateIndex = new Map(current.candidateIndex);
+			const candidateKey = candidateIndexKey(assigned);
+			candidateIndex.set(candidateKey, [...candidateIndex.get(candidateKey) ?? [], key]);
+			const ownerRegistrationCounts = new Map(current.ownerRegistrationCounts);
+			ownerRegistrationCounts.set(assigned.key.ownerId, ownerCount + 1);
+			return [Result.succeed(assigned), {
+				...current,
+				sequence: assigned.ordinal,
+				registrations,
+				registrationIndex,
+				candidateIndex,
+				ownerRegistrationCounts
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:register:after");
+		return result;
+	});
+	const get = Effect.fn("MemorySubscriptionStore.get")(function* (input) {
+		const key = yield* requireKey(input, "get-key");
+		const text = (yield* Ref.get(state)).registrations.get(subscriptionKeyString(key));
+		return text === void 0 ? null : yield* decodeEffect(SubscriptionRecord, text, "get-record");
+	});
+	const list = Effect.fn("MemorySubscriptionStore.list")(function* (ownerId, after, limit) {
+		if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit <= 0) return yield* error("validation", "list-page");
+		const current = yield* Ref.get(state);
+		const records = [];
+		for (const [storageKey, indexed] of current.registrationIndex) {
+			if (indexed.key.ownerId !== ownerId || indexed.ordinal <= after) continue;
+			const text = current.registrations.get(storageKey);
+			if (text === void 0) return yield* error("corrupt", "list-index");
+			records.push(yield* decodeEffect(SubscriptionRecord, text, "list-record"));
+		}
+		records.sort((a, b) => a.ordinal - b.ordinal);
+		return records.slice(0, limit);
+	});
+	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input) {
+		const key = yield* requireKey(input, "cancel-key");
+		yield* failpoint.hit("subscription:cancel:before");
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const storageKey = subscriptionKeyString(key);
+			const text = current.registrations.get(storageKey);
+			if (text === void 0) return [Result.fail(error("not-found", "subscription")), current];
+			const decoded = decode(SubscriptionRecord, text, "cancel-record");
+			if (Result.isFailure(decoded)) return [decoded, current];
+			if (decoded.success.state === "cancelled") return [Result.succeed(decoded.success), current];
+			const cancelled = {
+				...decoded.success,
+				state: "cancelled",
+				recovery: null
+			};
+			const encoded = encode(SubscriptionRecord, cancelled, "cancel-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const registrations = new Map(current.registrations);
+			registrations.set(storageKey, encoded.success);
+			const registrationIndex = new Map(current.registrationIndex);
+			const indexed = registrationIndex.get(storageKey);
+			if (indexed === void 0) return [Result.fail(error("corrupt", "cancel-index")), current];
+			registrationIndex.set(storageKey, {
+				...indexed,
+				state: "cancelled",
+				recoveryAt: null
+			});
+			return [Result.succeed(cancelled), {
+				...current,
+				registrations,
+				registrationIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:cancel:after");
+		return result;
+	});
+	const accept = Effect.fn("MemorySubscriptionStore.accept")(function* (input, inputLimits) {
+		const event = yield* validate$1(AcceptedEvent, input, "accept-event");
+		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "accept-limits");
+		yield* requirePartition(event, "accept-partition");
+		yield* failpoint.hit("subscription:accept:before");
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const existingText = current.events.get(event.eventId);
+			if (existingText !== void 0) {
+				const existing = decode(AcceptedEvent, existingText, "accept-existing");
+				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
+				return sameEventIdentity(existing.success, event) ? [Result.succeed(existing.success), current] : [Result.fail(error("conflict", "event-identity")), current];
+			}
+			if (jsonBytes(event.payload) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "payload-bytes")), current];
+			if (current.events.size >= limits.maxEvents) return [Result.fail(error("capacity", "events")), current];
+			const accepted = {
+				...event,
+				cutoff: current.sequence + 1,
+				cursor: 0,
+				routingComplete: false,
+				routingFailure: null
+			};
+			const encoded = encode(AcceptedEvent, accepted, "accept-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const events = new Map(current.events);
+			events.set(accepted.eventId, encoded.success);
+			const eventIndex = new Map(current.eventIndex);
+			eventIndex.set(accepted.eventId, {
+				routingComplete: false,
+				nextAttemptAtMillis: accepted.nextAttemptAtMillis
+			});
+			return [Result.succeed(accepted), {
+				...current,
+				sequence: accepted.cutoff,
+				events,
+				eventIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:accept:after");
+		return result;
+	});
+	const event = Effect.fn("MemorySubscriptionStore.event")(function* (eventId) {
+		const text = (yield* Ref.get(state)).events.get(eventId);
+		return text === void 0 ? null : yield* decodeEffect(AcceptedEvent, text, "event-record");
+	});
+	const pendingEvents = Effect.fn("MemorySubscriptionStore.pendingEvents")(function* (nowMillis, after, limit) {
+		const events = [];
+		for (const [eventId, indexed] of (yield* Ref.get(state)).eventIndex) if (!indexed.routingComplete && indexed.nextAttemptAtMillis <= nowMillis && compareScheduleNames(eventId, after) > 0) events.push(eventId);
+		events.sort(compareScheduleNames);
+		return events.slice(0, limit);
+	});
+	const candidates = Effect.fn("MemorySubscriptionStore.candidates")(function* (input, limit) {
+		const accepted = yield* validate$1(AcceptedEvent, input, "candidates-event");
+		yield* requirePartition(accepted, "candidates-partition");
+		const stored = yield* event(accepted.eventId);
+		if (stored === null || !sameEventIdentity(stored, accepted)) return yield* error(stored === null ? "not-found" : "conflict", "event");
+		const current = yield* Ref.get(state);
+		const records = [];
+		for (const storageKey of current.candidateIndex.get(eventCandidateIndexKey(stored)) ?? []) {
+			const indexed = current.registrationIndex.get(storageKey);
+			if (indexed === void 0) return yield* error("corrupt", "candidate-index");
+			if (indexed.ordinal <= stored.cursor || indexed.ordinal > stored.cutoff) continue;
+			const text = current.registrations.get(storageKey);
+			if (text === void 0) return yield* error("corrupt", "candidate-record");
+			records.push(yield* decodeEffect(SubscriptionRecord, text, "candidate-record"));
+		}
+		records.sort((a, b) => a.ordinal - b.ordinal);
+		return records.slice(0, limit);
+	});
+	const select = Effect.fn("MemorySubscriptionStore.select")(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
+		const suppliedEvent = yield* validate$1(AcceptedEvent, inputEvent, "select-event");
+		const deliveries = yield* validate$1(Schema.Array(SubscriptionDelivery), inputDeliveries, "select-deliveries");
+		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "select-limits");
+		yield* requirePartition(suppliedEvent, "select-partition");
+		yield* failpoint.hit("subscription:select:before");
+		const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const eventText = current.events.get(suppliedEvent.eventId);
+			if (eventText === void 0) return [Result.fail(error("not-found", "event")), current];
+			const decodedEvent = decode(AcceptedEvent, eventText, "select-event-record");
+			if (Result.isFailure(decodedEvent)) return [Result.fail(decodedEvent.failure), current];
+			const accepted = decodedEvent.success;
+			if (!sameEventIdentity(accepted, suppliedEvent) || suppliedEvent.cursor !== accepted.cursor) return [Result.fail(error("conflict", "event-cursor")), current];
+			if (accepted.routingComplete) return [complete && cursor === accepted.cursor ? Result.void : Result.fail(error("conflict", "routing-complete")), current];
+			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return [Result.fail(error("validation", "cursor")), current];
+			const additions = [];
+			const updates = [];
+			const additionIndex = [];
+			const registrationUpdates = [];
+			const owners = new Map(current.ownerDeliveryCounts);
+			for (const delivery of deliveries) {
+				const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
+				if (recordText === void 0) return [Result.fail(error("not-found", "subscription")), current];
+				const record = decode(SubscriptionRecord, recordText, "select-registration");
+				if (Result.isFailure(record)) return [Result.fail(record.failure), current];
+				if (!deliveryBelongsTo(delivery, record.success, accepted) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted) || record.success.ordinal <= accepted.cursor || record.success.ordinal > cursor) return [Result.fail(error("conflict", "selection")), current];
+				if (!subscriptionCanSelect(record.success, accepted, effectiveNowMillis, false)) continue;
+				const deliveryKey = subscriptionDeliveryKeyString(delivery.key);
+				const existingText = current.deliveries.get(deliveryKey);
+				if (existingText !== void 0) {
+					const existing = decode(SubscriptionDelivery, existingText, "select-existing");
+					if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
+					if (!sameDeliveryIdentity(existing.success, delivery)) return [Result.fail(error("conflict", "delivery-identity")), current];
+					continue;
+				}
+				const encodedDelivery = encode(SubscriptionDelivery, delivery, "select-delivery-encode");
+				if (Result.isFailure(encodedDelivery)) return [Result.fail(encodedDelivery.failure), current];
+				additions.push([deliveryKey, encodedDelivery.success]);
+				additionIndex.push([
+					deliveryKey,
+					{
+						key: delivery.key,
+						state: delivery.state,
+						nextAttemptAtMillis: delivery.retry.nextAttemptAtMillis
+					},
+					record.success.key.ownerId
+				]);
+				const ownerId = record.success.key.ownerId;
+				owners.set(ownerId, (owners.get(ownerId) ?? 0) + 1);
+				if ((owners.get(ownerId) ?? 0) > limits.maxDeliveriesPerOwner) return [Result.fail(error("capacity", "owner-deliveries")), current];
+				if (record.success.configuration.mode === "once") {
+					const consumed = {
+						...record.success,
+						state: "consumed",
+						recovery: null
+					};
+					const encodedRecord = encode(SubscriptionRecord, consumed, "select-registration-encode");
+					if (Result.isFailure(encodedRecord)) return [Result.fail(encodedRecord.failure), current];
+					const consumedKey = subscriptionKeyString(consumed.key);
+					updates.push([consumedKey, encodedRecord.success]);
+					const indexed = current.registrationIndex.get(consumedKey);
+					if (indexed === void 0) return [Result.fail(error("corrupt", "selection-index")), current];
+					registrationUpdates.push([consumedKey, {
+						...indexed,
+						state: "consumed",
+						recoveryAt: null
+					}]);
+				}
+			}
+			if (current.deliveries.size + additions.length > limits.maxDeliveries) return [Result.fail(error("capacity", "deliveries")), current];
+			const registrations = new Map(current.registrations);
+			for (const [key, value] of updates) registrations.set(key, value);
+			const nextDeliveries = new Map(current.deliveries);
+			for (const [key, value] of additions) nextDeliveries.set(key, value);
+			const deliveryIndex = new Map(current.deliveryIndex);
+			for (const [key, value] of additionIndex) deliveryIndex.set(key, value);
+			const registrationIndex = new Map(current.registrationIndex);
+			for (const [key, value] of registrationUpdates) registrationIndex.set(key, value);
+			const nextEvent = {
+				...accepted,
+				cursor,
+				routingComplete: complete,
+				routingFailure: null
+			};
+			const encodedEvent = encode(AcceptedEvent, nextEvent, "select-event-encode");
+			if (Result.isFailure(encodedEvent)) return [Result.fail(encodedEvent.failure), current];
+			const events = new Map(current.events);
+			events.set(nextEvent.eventId, encodedEvent.success);
+			const eventIndex = new Map(current.eventIndex);
+			eventIndex.set(nextEvent.eventId, {
+				routingComplete: nextEvent.routingComplete,
+				nextAttemptAtMillis: nextEvent.nextAttemptAtMillis
+			});
+			return [Result.void, {
+				...current,
+				registrations,
+				registrationIndex,
+				events,
+				eventIndex,
+				deliveries: nextDeliveries,
+				deliveryIndex,
+				ownerDeliveryCounts: owners
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:select:after");
+	});
+	const catchUp = Effect.fn("MemorySubscriptionStore.catchUp")(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
+		const suppliedEvent = yield* validate$1(AcceptedEvent, inputEvent, "catch-up-event");
+		const delivery = yield* validate$1(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
+		const limits = yield* validate$1(SubscriptionLimits, inputLimits, "catch-up-limits");
+		yield* requirePartition(suppliedEvent, "catch-up-partition");
+		yield* failpoint.hit("subscription:catch-up:before");
+		const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const eventText = current.events.get(suppliedEvent.eventId);
+			const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
+			if (eventText === void 0 || recordText === void 0) return [Result.fail(error("not-found", eventText === void 0 ? "event" : "subscription")), current];
+			const accepted = decode(AcceptedEvent, eventText, "catch-up-event-record");
+			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
+			const record = decode(SubscriptionRecord, recordText, "catch-up-registration");
+			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
+			if (!sameEventIdentity(accepted.success, suppliedEvent) || !deliveryBelongsTo(delivery, record.success, accepted.success) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted.success) || record.success.configuration.mode !== "once") return [Result.fail(error("conflict", "catch-up-identity")), current];
+			const key = subscriptionDeliveryKeyString(delivery.key);
+			const existingText = current.deliveries.get(key);
+			if (existingText !== void 0) {
+				const existing = decode(SubscriptionDelivery, existingText, "catch-up-existing");
+				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
+				return sameDeliveryIdentity(existing.success, delivery) ? [Result.void, current] : [Result.fail(error("conflict", "delivery-identity")), current];
+			}
+			if (!subscriptionCanSelect(record.success, accepted.success, effectiveNowMillis, true)) return [Result.fail(error("conflict", "catch-up-eligibility")), current];
+			if (current.deliveries.size >= limits.maxDeliveries) return [Result.fail(error("capacity", "deliveries")), current];
+			const ownerCount = current.ownerDeliveryCounts.get(record.success.key.ownerId) ?? 0;
+			if (ownerCount >= limits.maxDeliveriesPerOwner) return [Result.fail(error("capacity", "owner-deliveries")), current];
+			const encodedDelivery = encode(SubscriptionDelivery, delivery, "catch-up-delivery-encode");
+			if (Result.isFailure(encodedDelivery)) return [Result.fail(encodedDelivery.failure), current];
+			const consumed = {
+				...record.success,
+				state: "consumed",
+				recovery: null
+			};
+			const encodedRecord = encode(SubscriptionRecord, consumed, "catch-up-registration-encode");
+			if (Result.isFailure(encodedRecord)) return [Result.fail(encodedRecord.failure), current];
+			const deliveries = new Map(current.deliveries);
+			deliveries.set(key, encodedDelivery.success);
+			const registrations = new Map(current.registrations);
+			const consumedKey = subscriptionKeyString(consumed.key);
+			registrations.set(consumedKey, encodedRecord.success);
+			const registrationIndex = new Map(current.registrationIndex);
+			const indexed = registrationIndex.get(consumedKey);
+			if (indexed === void 0) return [Result.fail(error("corrupt", "catch-up-index")), current];
+			registrationIndex.set(consumedKey, {
+				...indexed,
+				state: "consumed",
+				recoveryAt: null
+			});
+			const deliveryIndex = new Map(current.deliveryIndex);
+			deliveryIndex.set(key, {
+				key: delivery.key,
+				state: delivery.state,
+				nextAttemptAtMillis: delivery.retry.nextAttemptAtMillis
+			});
+			const ownerDeliveryCounts = new Map(current.ownerDeliveryCounts);
+			ownerDeliveryCounts.set(consumed.key.ownerId, ownerCount + 1);
+			return [Result.void, {
+				...current,
+				deliveries,
+				deliveryIndex,
+				ownerDeliveryCounts,
+				registrations,
+				registrationIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:catch-up:after");
+	});
+	const deferEvent = Effect.fn("MemorySubscriptionStore.deferEvent")(function* (eventId, nextAttemptAtMillis, code) {
+		const routingFailure = code === void 0 ? "routing-failed" : yield* validate$1(SubscriptionName, code, "routing-failure");
+		yield* failpoint.hit("subscription:defer-event:before");
+		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const text = current.events.get(eventId);
+			if (text === void 0) return [Result.fail(error("not-found", "event")), current];
+			const accepted = decode(AcceptedEvent, text, "defer-event-record");
+			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
+			const updated = {
+				...accepted.success,
+				nextAttemptAtMillis,
+				routingFailure
+			};
+			const encoded = encode(AcceptedEvent, updated, "defer-event-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const events = new Map(current.events);
+			events.set(eventId, encoded.success);
+			const eventIndex = new Map(current.eventIndex);
+			const indexed = eventIndex.get(eventId);
+			if (indexed === void 0) return [Result.fail(error("corrupt", "defer-event-index")), current];
+			eventIndex.set(eventId, {
+				...indexed,
+				nextAttemptAtMillis
+			});
+			return [Result.void, {
+				...current,
+				events,
+				eventIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:defer-event:after");
+	});
+	const delivery = Effect.fn("MemorySubscriptionStore.delivery")(function* (input) {
+		const key = yield* validate$1(SubscriptionDeliveryKey, input, "delivery-key");
+		yield* requirePartition(key.subscription, "delivery-partition");
+		const text = (yield* Ref.get(state)).deliveries.get(subscriptionDeliveryKeyString(key));
+		return text === void 0 ? null : yield* decodeEffect(SubscriptionDelivery, text, "delivery-record");
+	});
+	const pendingDeliveries = Effect.fn("MemorySubscriptionStore.pendingDeliveries")(function* (nowMillis, after, limit) {
+		const items = [];
+		for (const [storageKey, item] of (yield* Ref.get(state)).deliveryIndex) if (item.state !== "delivered" && item.state !== "refused" && item.nextAttemptAtMillis <= nowMillis && compareScheduleNames(storageKey, after) > 0) items.push(item.key);
+		items.sort((a, b) => compareScheduleNames(subscriptionDeliveryKeyString(a), subscriptionDeliveryKeyString(b)));
+		return items.slice(0, limit);
+	});
+	const listDeliveries = Effect.fn("MemorySubscriptionStore.listDeliveries")(function* (input, after, limit) {
+		const key = yield* requireKey(input, "list-deliveries-key");
+		const items = [];
+		for (const text of (yield* Ref.get(state)).deliveries.values()) {
+			const item = yield* decodeEffect(SubscriptionDelivery, text, "list-delivery");
+			const itemKey = subscriptionDeliveryKeyString(item.key);
+			if (subscriptionKeyString(item.key.subscription) === subscriptionKeyString(key) && compareScheduleNames(itemKey, after) > 0) items.push(item);
+		}
+		items.sort((a, b) => compareScheduleNames(subscriptionDeliveryKeyString(a.key), subscriptionDeliveryKeyString(b.key)));
+		return items.slice(0, limit);
+	});
+	const changeDelivery = Effect.fn("MemorySubscriptionStore.changeDelivery")(function* (inputKey, inputDeliveryId, inputChange) {
+		const key = yield* validate$1(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
+		const deliveryId = yield* validate$1(Digest, inputDeliveryId, "change-delivery-id");
+		const change = yield* validate$1(DeliveryChange, inputChange, "change-delivery-change");
+		yield* requirePartition(key.subscription, "change-delivery-partition");
+		yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:before`);
+		const effectiveChange = change._tag === "Prepare" ? {
+			...change,
+			nowMillis: Math.max(change.nowMillis, yield* Clock.currentTimeMillis)
+		} : change;
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const storageKey = subscriptionDeliveryKeyString(key);
+			const text = current.deliveries.get(storageKey);
+			if (text === void 0) return [Result.fail(error("not-found", "delivery")), current];
+			const decoded = decode(SubscriptionDelivery, text, "change-delivery-record");
+			if (Result.isFailure(decoded)) return [decoded, current];
+			const registrationText = current.registrations.get(subscriptionKeyString(key.subscription));
+			if (registrationText === void 0) return [Result.fail(error("corrupt", "delivery-registration")), current];
+			const registration = decode(SubscriptionRecord, registrationText, "delivery-registration");
+			if (Result.isFailure(registration)) return [Result.fail(registration.failure), current];
+			const transition = applySubscriptionDeliveryChange(decoded.success, registration.success, deliveryId, effectiveChange);
+			if (Result.isFailure(transition)) return [Result.fail(transition.failure), current];
+			if (transition.success === decoded.success) return [Result.succeed(decoded.success), current];
+			const updated = transition.success;
+			const encoded = encode(SubscriptionDelivery, updated, "change-delivery-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const deliveries = new Map(current.deliveries);
+			deliveries.set(storageKey, encoded.success);
+			const deliveryIndex = new Map(current.deliveryIndex);
+			const indexed = deliveryIndex.get(storageKey);
+			if (indexed === void 0) return [Result.fail(error("corrupt", "delivery-index")), current];
+			deliveryIndex.set(storageKey, {
+				...indexed,
+				state: updated.state,
+				nextAttemptAtMillis: updated.retry.nextAttemptAtMillis
+			});
+			return [Result.succeed(updated), {
+				...current,
+				deliveries,
+				deliveryIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
+		return result;
+	});
+	const recovering = Effect.fn("MemorySubscriptionStore.recovering")(function* (nowMillis, after, limit) {
+		const records = [];
+		for (const item of (yield* Ref.get(state)).registrationIndex.values()) if (item.ordinal > after && item.state === "active" && item.recoveryAt !== null && item.recoveryAt <= nowMillis) records.push({
+			key: item.key,
+			ordinal: item.ordinal
+		});
+		records.sort((a, b) => a.ordinal - b.ordinal);
+		return records.slice(0, limit);
+	});
+	const deferRecovery = Effect.fn("MemorySubscriptionStore.deferRecovery")(function* (input, recovery) {
+		const key = yield* requireKey(input, "defer-recovery-key");
+		yield* failpoint.hit("subscription:defer-recovery:before");
+		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			const storageKey = subscriptionKeyString(key);
+			const text = current.registrations.get(storageKey);
+			if (text === void 0) return [Result.fail(error("not-found", "subscription")), current];
+			const record = decode(SubscriptionRecord, text, "defer-recovery-record");
+			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
+			const updated = {
+				...record.success,
+				recovery: record.success.state === "active" ? recovery : null
+			};
+			const encoded = encode(SubscriptionRecord, updated, "defer-recovery-encode");
+			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
+			const registrations = new Map(current.registrations);
+			registrations.set(storageKey, encoded.success);
+			const registrationIndex = new Map(current.registrationIndex);
+			const indexed = registrationIndex.get(storageKey);
+			if (indexed === void 0) return [Result.fail(error("corrupt", "recovery-index")), current];
+			registrationIndex.set(storageKey, {
+				...indexed,
+				recoveryAt: updated.recovery?.nextAttemptAtMillis ?? null
+			});
+			return [Result.void, {
+				...current,
+				registrations,
+				registrationIndex
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:defer-recovery:after");
+	});
+	const readScanCursors = Ref.get(state).pipe(Effect.map((current) => current.scanCursors));
+	const advanceScanCursors = Effect.fn("MemorySubscriptionStore.advanceScanCursors")(function* (input) {
+		const cursors = yield* validate$1(SubscriptionScanCursors, input, "scan-cursors");
+		yield* failpoint.hit("subscription:advance-scan-cursors:before");
+		yield* Effect.uninterruptible(Ref.update(state, (current) => ({
+			...current,
+			scanCursors: cursors
+		})));
+		yield* failpoint.hit("subscription:advance-scan-cursors:after");
+	});
+	const nextDeadline = Effect.gen(function* () {
+		let deadline = null;
+		const current = yield* Ref.get(state);
+		if (current.scanCursors.events !== "" || current.scanCursors.deliveries !== "" || current.scanCursors.recovery !== 0) return 0;
+		const consider = (value) => {
+			if (deadline === null || value < deadline) deadline = value;
+		};
+		for (const accepted of current.eventIndex.values()) if (!accepted.routingComplete) consider(accepted.nextAttemptAtMillis);
+		for (const item of current.deliveryIndex.values()) if (item.state !== "delivered" && item.state !== "refused") consider(item.nextAttemptAtMillis);
+		for (const record of current.registrationIndex.values()) if (record.state === "active" && record.recoveryAt !== null) consider(record.recoveryAt);
+		return deadline;
+	}).pipe(Effect.withSpan("MemorySubscriptionStore.nextDeadline"));
+	return SubscriptionStore.of({
+		partition,
+		register,
+		get,
+		list,
+		cancel,
+		accept,
+		event,
+		pendingEvents,
+		candidates,
+		select,
+		catchUp,
+		deferEvent,
+		delivery,
+		pendingDeliveries,
+		listDeliveries,
+		changeDelivery,
+		recovering,
+		deferRecovery,
+		readScanCursors,
+		advanceScanCursors,
+		nextDeadline
+	});
+});
+const memorySubscriptionStoreLayer = (partition) => Layer.effect(SubscriptionStore, makeMemorySubscriptionStore(partition));
+//#endregion
 //#region src/memory-storage.ts
-const MAX_CONVERSATIONS = 256;
-const MAX_RECORDS_PER_CONVERSATION = 65536;
-const MAX_CHECKPOINTS_PER_CONVERSATION = 1024;
-const storeError = (operation, message, cause) => cause === void 0 ? ConversationStoreError.make({
+const MAX_THREADS = 256;
+const MAX_RECORDS_PER_THREAD = 65536;
+const MAX_CHECKPOINTS_PER_THREAD = 1024;
+const storeError = (operation, message, cause) => cause === void 0 ? ThreadStoreError.make({
 	operation,
 	message
-}) : ConversationStoreError.make({
+}) : ThreadStoreError.make({
 	operation,
 	message,
 	cause
 });
-const validate = Effect.fn("MemoryConversationStore.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error))));
+const validate = Effect.fn("MemoryThreadStore.validate")((schema, operation, value) => Schema.encodeUnknownEffect(schema)(value).pipe(Effect.flatMap(Schema.decodeUnknownEffect(schema)), Effect.mapError((error) => storeError(operation, `Invalid ${operation} request`, error))));
 const decodeCanonicalSequence = Schema.decodeSync(CanonicalSequence);
 const ZERO_CANONICAL_SEQUENCE = decodeCanonicalSequence(0);
-const offsetSequence = Effect.fn("MemoryConversationStore.offsetSequence")((conversationId, offset) => {
+const offsetSequence = Effect.fn("MemoryThreadStore.offsetSequence")((threadId, offset) => {
 	if (offset === void 0) return Effect.succeed(ZERO_CANONICAL_SEQUENCE);
-	const prefix = `memory:v1:${Encoding.encodeBase64(conversationId)}:`;
+	const prefix = `memory:v1:${Encoding.encodeBase64(threadId)}:`;
 	const encodedSequence = offset.startsWith(prefix) ? offset.slice(prefix.length) : "";
 	if (!/^\d+$/.test(encodedSequence)) return Effect.fail(storeError("observe", "Malformed observation offset"));
 	const sequence = Number(encodedSequence);
 	return Number.isSafeInteger(sequence) ? Schema.decodeUnknownEffect(CanonicalSequence)(sequence).pipe(Effect.mapError(() => storeError("observe", "Malformed observation offset"))) : Effect.fail(storeError("observe", "Malformed observation offset"));
 });
-const observationOffset = (conversationId, sequence) => Schema.decodeSync(ObservationOffset)(`memory:v1:${Encoding.encodeBase64(conversationId)}:${sequence}`);
-const findConversation = Effect.fn("MemoryConversationStore.findConversation")((state, conversationId) => {
-	const conversation = state.conversations.get(conversationId);
-	return conversation === void 0 ? Effect.fail(ConversationNotMaterialized.make({ conversationId })) : Effect.succeed(conversation);
+const observationOffset = (threadId, sequence) => Schema.decodeSync(ObservationOffset)(`memory:v1:${Encoding.encodeBase64(threadId)}:${sequence}`);
+const findThread = Effect.fn("MemoryThreadStore.findThread")((state, threadId) => {
+	const thread = state.threads.get(threadId);
+	return thread === void 0 ? Effect.fail(ThreadNotMaterialized.make({ threadId })) : Effect.succeed(thread);
 });
 const CheckpointVersionEnvelope = Schema.Struct({ checkpoint: Schema.Struct({
-	conversationId: ConversationId,
+	threadId: ThreadId,
 	schemaVersion: Schema.Natural
 }) });
-const validateCheckpointVersion = Effect.fn("MemoryConversationStore.validateCheckpointVersion")(function* (value) {
+const validateCheckpointVersion = Effect.fn("MemoryThreadStore.validateCheckpointVersion")(function* (value) {
 	const envelope = yield* Schema.decodeUnknownEffect(CheckpointVersionEnvelope)(value).pipe(Effect.mapError(() => storeError("saveCheckpoint", "Invalid saveCheckpoint request")));
 	if (envelope.checkpoint.schemaVersion !== 1) return yield* CheckpointRejected.make({
-		conversationId: envelope.checkpoint.conversationId,
+		threadId: envelope.checkpoint.threadId,
 		reason: "unsupported-version"
 	});
 });
-const makeConversationStore = Effect.gen(function* () {
+const makeThreadStore = Effect.gen(function* () {
 	const crypto = yield* Crypto.Crypto;
-	const state = yield* Ref.make({ conversations: /* @__PURE__ */ new Map() });
+	const state = yield* Ref.make({ threads: /* @__PURE__ */ new Map() });
 	const updates = yield* PubSub.sliding(1);
 	yield* Effect.addFinalizer(() => PubSub.shutdown(updates));
-	const materialize = Effect.fn("MemoryConversationStore.materialize")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationMaterialization, "materialize", unvalidated);
+	const materialize = Effect.fn("MemoryThreadStore.materialize")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ThreadMaterialization, "materialize", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
-			const existing = current.conversations.get(request.conversationId);
+			const existing = current.threads.get(request.threadId);
 			if (existing !== void 0) {
 				if (request.producerEpoch < existing.producerEpoch) return [{
 					_tag: "failure",
 					error: FenceRejected.make({
-						conversationId: request.conversationId,
+						threadId: request.threadId,
 						actualEpoch: existing.producerEpoch,
 						attemptedEpoch: request.producerEpoch
 					})
 				}, current];
 				if (request.producerEpoch === existing.producerEpoch) return [{ _tag: "success" }, current];
-				const conversations = new Map(current.conversations);
-				conversations.set(request.conversationId, {
+				const threads = new Map(current.threads);
+				threads.set(request.threadId, {
 					...existing,
 					producerEpoch: request.producerEpoch
 				});
-				return [{ _tag: "success" }, { conversations }];
+				return [{ _tag: "success" }, { threads }];
 			}
-			if (current.conversations.size >= MAX_CONVERSATIONS) return [{
+			if (current.threads.size >= MAX_THREADS) return [{
 				_tag: "failure",
-				error: storeError("materialize", `In-memory conversation limit ${MAX_CONVERSATIONS} exceeded`)
+				error: storeError("materialize", `In-memory thread limit ${MAX_THREADS} exceeded`)
 			}, current];
-			const conversations = new Map(current.conversations);
-			conversations.set(request.conversationId, {
+			const threads = new Map(current.threads);
+			threads.set(request.threadId, {
 				producerEpoch: request.producerEpoch,
 				tailSequence: ZERO_CANONICAL_SEQUENCE,
 				tailDigest: EMPTY_TAIL_DIGEST,
@@ -1230,33 +1820,33 @@ const makeConversationStore = Effect.gen(function* () {
 				tailDigests: /* @__PURE__ */ new Map([[ZERO_CANONICAL_SEQUENCE, EMPTY_TAIL_DIGEST]]),
 				checkpoints: /* @__PURE__ */ new Map()
 			});
-			return [{ _tag: "success" }, { conversations }];
+			return [{ _tag: "success" }, { threads }];
 		});
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
-	const append = Effect.fn("MemoryConversationStore.append")((unvalidated) => Effect.gen(function* () {
+	const append = Effect.fn("MemoryThreadStore.append")((unvalidated) => Effect.gen(function* () {
 		const request = yield* validate(FencedAppendRequest, "append", unvalidated);
 		const digest = yield* digestCanonicalBatch(request.expectedTailDigest, request.batch).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.mapError((error) => storeError("append", error.message, error)));
 		const decision = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
-			const conversation = current.conversations.get(request.conversationId);
-			if (conversation === void 0) return [{
+			const thread = current.threads.get(request.threadId);
+			if (thread === void 0) return [{
 				_tag: "failure",
-				error: ConversationNotMaterialized.make({ conversationId: request.conversationId })
+				error: ThreadNotMaterialized.make({ threadId: request.threadId })
 			}, current];
-			if (request.producerEpoch !== conversation.producerEpoch) return [{
+			if (request.producerEpoch !== thread.producerEpoch) return [{
 				_tag: "failure",
 				error: FenceRejected.make({
-					conversationId: request.conversationId,
-					actualEpoch: conversation.producerEpoch,
+					threadId: request.threadId,
+					actualEpoch: thread.producerEpoch,
 					attemptedEpoch: request.producerEpoch
 				})
 			}, current];
-			const previous = conversation.batches.get(request.batch.batchId);
+			const previous = thread.batches.get(request.batch.batchId);
 			if (previous !== void 0) {
 				if (previous.digest !== digest) return [{
 					_tag: "failure",
 					error: AppendConflict.make({
-						conversationId: request.conversationId,
+						threadId: request.threadId,
 						batchId: request.batch.batchId,
 						reason: "batch-digest"
 					})
@@ -1272,26 +1862,26 @@ const makeConversationStore = Effect.gen(function* () {
 					records: []
 				}, current];
 			}
-			if (request.expectedTailSequence !== conversation.tailSequence || request.expectedTailDigest !== conversation.tailDigest) return [{
+			if (request.expectedTailSequence !== thread.tailSequence || request.expectedTailDigest !== thread.tailDigest) return [{
 				_tag: "failure",
 				error: AppendConflict.make({
-					conversationId: request.conversationId,
+					threadId: request.threadId,
 					batchId: request.batch.batchId,
 					reason: "tail",
-					actualTailSequence: conversation.tailSequence,
-					actualTailDigest: conversation.tailDigest
+					actualTailSequence: thread.tailSequence,
+					actualTailDigest: thread.tailDigest
 				})
 			}, current];
-			if (conversation.records.length + request.batch.records.length > MAX_RECORDS_PER_CONVERSATION) return [{
+			if (thread.records.length + request.batch.records.length > MAX_RECORDS_PER_THREAD) return [{
 				_tag: "failure",
-				error: storeError("append", `In-memory record limit ${MAX_RECORDS_PER_CONVERSATION} exceeded`)
+				error: storeError("append", `In-memory record limit ${MAX_RECORDS_PER_THREAD} exceeded`)
 			}, current];
 			const batchRecordIds = /* @__PURE__ */ new Set();
 			for (const record of request.batch.records) {
-				if (conversation.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
+				if (thread.recordIds.has(record.recordId) || batchRecordIds.has(record.recordId)) return [{
 					_tag: "failure",
 					error: AppendConflict.make({
-						conversationId: request.conversationId,
+						threadId: request.threadId,
 						batchId: request.batch.batchId,
 						reason: "record-identity"
 					})
@@ -1299,37 +1889,37 @@ const makeConversationStore = Effect.gen(function* () {
 				batchRecordIds.add(record.recordId);
 			}
 			const records = request.batch.records.map((record, index) => {
-				const sequence = decodeCanonicalSequence(conversation.tailSequence + index + 1);
+				const sequence = decodeCanonicalSequence(thread.tailSequence + index + 1);
 				return CanonicalRecordEnvelope.make({
-					conversationId: request.conversationId,
+					threadId: request.threadId,
 					batchId: request.batch.batchId,
 					sequence,
-					offset: observationOffset(request.conversationId, sequence),
+					offset: observationOffset(request.threadId, sequence),
 					record
 				});
 			});
-			const lastSequence = decodeCanonicalSequence(conversation.tailSequence + records.length);
+			const lastSequence = decodeCanonicalSequence(thread.tailSequence + records.length);
 			const result = AppendResult.make({
-				firstSequence: decodeCanonicalSequence(conversation.tailSequence + 1),
+				firstSequence: decodeCanonicalSequence(thread.tailSequence + 1),
 				lastSequence,
 				tailDigest: digest,
 				replayed: false
 			});
-			const batches = new Map(conversation.batches);
+			const batches = new Map(thread.batches);
 			batches.set(request.batch.batchId, {
 				digest,
 				result
 			});
-			const recordIds = new Set(conversation.recordIds);
+			const recordIds = new Set(thread.recordIds);
 			for (const recordId of batchRecordIds) recordIds.add(recordId);
-			const tailDigests = new Map(conversation.tailDigests);
+			const tailDigests = new Map(thread.tailDigests);
 			tailDigests.set(lastSequence, digest);
-			const conversations = new Map(current.conversations);
-			conversations.set(request.conversationId, {
-				...conversation,
+			const threads = new Map(current.threads);
+			threads.set(request.threadId, {
+				...thread,
 				tailSequence: lastSequence,
 				tailDigest: digest,
-				records: [...conversation.records, ...records],
+				records: [...thread.records, ...records],
 				recordIds,
 				batches,
 				tailDigests
@@ -1338,118 +1928,120 @@ const makeConversationStore = Effect.gen(function* () {
 				_tag: "success",
 				result,
 				records
-			}, { conversations }];
+			}, { threads }];
 		}).pipe(Effect.tap((decision) => decision._tag === "success" && decision.records.length > 0 ? PubSub.publish(updates, void 0) : Effect.void)));
 		if (decision._tag === "failure") return yield* decision.error;
 		return decision.result;
 	}));
-	const readSnapshot = Effect.fn("MemoryConversationStore.readSnapshot")((conversationId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, conversationId)), Effect.map((conversation) => conversation.records.filter((record) => record.sequence > (afterSequence ?? ZERO_CANONICAL_SEQUENCE)).slice(0, limit))));
+	const readSnapshot = Effect.fn("MemoryThreadStore.readSnapshot")((threadId, afterSequence, limit) => Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, threadId)), Effect.map((thread) => thread.records.filter((record) => record.sequence > (afterSequence ?? ZERO_CANONICAL_SEQUENCE)).slice(0, limit))));
 	const read = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ConversationRead, "read", unvalidated);
-		const records = yield* readSnapshot(request.conversationId, request.afterSequence, request.limit);
+		const request = yield* validate(ThreadRead, "read", unvalidated);
+		const records = yield* readSnapshot(request.threadId, request.afterSequence, request.limit);
 		return Stream.fromIterable(records);
 	}));
 	const observe = (unvalidated) => Stream.unwrap(Effect.gen(function* () {
-		const request = yield* validate(ConversationObservation, "observe", unvalidated);
-		const afterSequence = yield* offsetSequence(request.conversationId, request.afterOffset);
+		const request = yield* validate(ThreadObservation, "observe", unvalidated);
+		const afterSequence = yield* offsetSequence(request.threadId, request.afterOffset);
 		return Stream.unwrap(Effect.gen(function* () {
 			const subscription = yield* PubSub.subscribe(updates);
-			const initial = yield* readSnapshot(request.conversationId, afterSequence, MAX_RECORDS_PER_CONVERSATION);
+			const initial = yield* readSnapshot(request.threadId, afterSequence, MAX_RECORDS_PER_THREAD);
 			const highWater = initial.length === 0 ? afterSequence : initial.at(-1)?.sequence ?? afterSequence;
-			const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.mapAccumEffect(() => highWater, (lastSequence) => readSnapshot(request.conversationId, lastSequence, MAX_RECORDS_PER_CONVERSATION).pipe(Effect.map((records) => [records.at(-1)?.sequence ?? lastSequence, records]))));
+			const live = Stream.fromEffectRepeat(PubSub.take(subscription)).pipe(Stream.mapAccumEffect(() => highWater, (lastSequence) => readSnapshot(request.threadId, lastSequence, MAX_RECORDS_PER_THREAD).pipe(Effect.map((records) => [records.at(-1)?.sequence ?? lastSequence, records]))));
 			return Stream.fromIterable(initial).pipe(Stream.concat(live));
 		}));
 	}));
-	const exportConversation = Effect.fn("MemoryConversationStore.export")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationExportRequest, "export", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		return ConversationExport.make({
-			format: "effect-agent/conversation@1",
-			conversationId: request.conversationId,
-			tailSequence: conversation.tailSequence,
-			tailDigest: conversation.tailDigest,
-			records: conversation.records
+	const exportThread = Effect.fn("MemoryThreadStore.export")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ThreadExportRequest, "export", unvalidated);
+		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
+		return ThreadExport.make({
+			format: "effect-agent/thread@1",
+			threadId: request.threadId,
+			tailSequence: thread.tailSequence,
+			tailDigest: thread.tailDigest,
+			records: thread.records
 		});
 	}));
-	const inspectTail = Effect.fn("MemoryConversationStore.inspectTail")((unvalidated) => Effect.gen(function* () {
-		const request = yield* validate(ConversationTailRequest, "inspectTail", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		return ConversationTail.make({
-			conversationId: request.conversationId,
-			tailSequence: conversation.tailSequence,
-			tailDigest: conversation.tailDigest,
-			producerEpoch: conversation.producerEpoch
+	const inspectTail = Effect.fn("MemoryThreadStore.inspectTail")((unvalidated) => Effect.gen(function* () {
+		const request = yield* validate(ThreadTailRequest, "inspectTail", unvalidated);
+		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
+		return ThreadTail.make({
+			threadId: request.threadId,
+			tailSequence: thread.tailSequence,
+			tailDigest: thread.tailDigest,
+			producerEpoch: thread.producerEpoch
 		});
 	}));
-	const saveCheckpoint = Effect.fn("MemoryConversationStore.saveCheckpoint")((unvalidated) => Effect.gen(function* () {
+	const saveCheckpoint = Effect.fn("MemoryThreadStore.saveCheckpoint")((unvalidated) => Effect.gen(function* () {
 		yield* validateCheckpointVersion(unvalidated);
 		const request = yield* validate(SaveCheckpointRequest, "saveCheckpoint", unvalidated);
 		const decision = yield* Ref.modify(state, (current) => {
 			const checkpoint = request.checkpoint;
-			const conversation = current.conversations.get(checkpoint.conversationId);
-			if (conversation === void 0) return [{
+			const thread = current.threads.get(checkpoint.threadId);
+			if (thread === void 0) return [{
 				_tag: "failure",
-				error: ConversationNotMaterialized.make({ conversationId: checkpoint.conversationId })
+				error: ThreadNotMaterialized.make({ threadId: checkpoint.threadId })
 			}, current];
-			if (checkpoint.throughSequence > conversation.tailSequence) return [{
+			if (checkpoint.throughSequence > thread.tailSequence) return [{
 				_tag: "failure",
 				error: CheckpointRejected.make({
-					conversationId: checkpoint.conversationId,
+					threadId: checkpoint.threadId,
 					reason: "ahead-of-tail"
 				})
 			}, current];
-			if (conversation.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
+			if (thread.tailDigests.get(checkpoint.throughSequence) !== checkpoint.tailDigest) return [{
 				_tag: "failure",
 				error: CheckpointRejected.make({
-					conversationId: checkpoint.conversationId,
+					threadId: checkpoint.threadId,
 					reason: "digest-mismatch"
 				})
 			}, current];
-			if (!conversation.checkpoints.has(checkpoint.throughSequence) && conversation.checkpoints.size >= MAX_CHECKPOINTS_PER_CONVERSATION) return [{
+			if (!thread.checkpoints.has(checkpoint.throughSequence) && thread.checkpoints.size >= MAX_CHECKPOINTS_PER_THREAD) return [{
 				_tag: "failure",
-				error: storeError("saveCheckpoint", `In-memory checkpoint limit ${MAX_CHECKPOINTS_PER_CONVERSATION} exceeded`)
+				error: storeError("saveCheckpoint", `In-memory checkpoint limit ${MAX_CHECKPOINTS_PER_THREAD} exceeded`)
 			}, current];
-			const checkpoints = new Map(conversation.checkpoints);
+			const checkpoints = new Map(thread.checkpoints);
 			checkpoints.set(checkpoint.throughSequence, checkpoint);
-			const conversations = new Map(current.conversations);
-			conversations.set(checkpoint.conversationId, {
-				...conversation,
+			const threads = new Map(current.threads);
+			threads.set(checkpoint.threadId, {
+				...thread,
 				checkpoints
 			});
-			return [{ _tag: "success" }, { conversations }];
+			return [{ _tag: "success" }, { threads }];
 		});
 		if (decision._tag === "failure") return yield* decision.error;
 	}));
-	const loadCheckpoint = Effect.fn("MemoryConversationStore.loadCheckpoint")((unvalidated) => Effect.gen(function* () {
+	const loadCheckpoint = Effect.fn("MemoryThreadStore.loadCheckpoint")((unvalidated) => Effect.gen(function* () {
 		const request = yield* validate(LoadCheckpointRequest, "loadCheckpoint", unvalidated);
-		const conversation = yield* Ref.get(state).pipe(Effect.flatMap((current) => findConversation(current, request.conversationId)));
-		const maximum = request.atOrBeforeSequence ?? conversation.tailSequence;
+		const thread = yield* Ref.get(state).pipe(Effect.flatMap((current) => findThread(current, request.threadId)));
+		const maximum = request.atOrBeforeSequence ?? thread.tailSequence;
 		let selected;
-		for (const [sequence, checkpoint] of conversation.checkpoints) if (sequence <= maximum && (selected === void 0 || sequence > selected.throughSequence)) selected = checkpoint;
-		if (selected !== void 0 && conversation.tailDigests.get(selected.throughSequence) !== selected.tailDigest) return yield* CheckpointRejected.make({
-			conversationId: request.conversationId,
+		for (const [sequence, checkpoint] of thread.checkpoints) if (sequence <= maximum && (selected === void 0 || sequence > selected.throughSequence)) selected = checkpoint;
+		if (selected !== void 0 && thread.tailDigests.get(selected.throughSequence) !== selected.tailDigest) return yield* CheckpointRejected.make({
+			threadId: request.threadId,
 			reason: "digest-mismatch"
 		});
 		return Option.fromNullishOr(selected);
 	}));
-	return ConversationStore.of({
+	return ThreadStore.of({
 		materialize,
 		append,
 		read,
 		observe,
-		export: exportConversation,
+		export: exportThread,
 		inspectTail,
-		saveCheckpoint,
-		loadCheckpoint
+		checkpoints: {
+			save: saveCheckpoint,
+			load: loadCheckpoint
+		}
 	});
 });
-const MemoryConversationStoreLive = Layer.effect(ConversationStore, makeConversationStore);
+const MemoryThreadStoreLive = Layer.effect(ThreadStore, makeThreadStore);
 /**
-* In-memory canonical Conversation persistence. Durable accepted work is served by the separate
-* SubmissionLedger port; this Layer deliberately provides only the ConversationStore.
+* In-memory canonical Thread persistence. Durable accepted work is served by the separate
+* SubmissionLedger port; this Layer deliberately provides only the ThreadStore.
 */
-const MemoryStorageLive = MemoryConversationStoreLive;
+const MemoryStorageLive = MemoryThreadStoreLive;
 //#endregion
-export { MemoryConversationStoreLive, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, memoryScheduleStoreLayer, memorySubmissionLedgerLayer };
+export { MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemoryThreadStoreLive, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
 
 //# sourceMappingURL=index.mjs.map