@effect-agent/storage-memory 0.1.0-beta.49 → 0.1.0-beta.51

package/dist/MemorySubscriptionStore.mjs

@@ -2,8 +2,8 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { compareScheduleNames } from "@effect-agent/thread/ScheduleTransition";
 import { Clock, Effect, Layer, Ref, Result, Schema } from "effect";
 import { Digest } from "@effect-agent/thread/Records";
-import { AcceptedEvent, DeliveryChange, SourcePartition, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, subscriptionDeliveryKeyString, subscriptionKeyString } from "@effect-agent/thread/Subscription";
-import { applySubscriptionDeliveryChange, subscriptionCanSelect, subscriptionDeliveryCanSelect } from "@effect-agent/thread/SubscriptionTransition";
+import { AcceptedEvent, DeliveryChange, SourcePartition, SubscriptionChange, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionRetentionPolicy, SubscriptionScanCursors, SubscriptionStore, subscriptionDeliveryKeyString, subscriptionKeyString } from "@effect-agent/thread/Subscription";
+import { applySubscriptionChange, applySubscriptionDeliveryChange, subscriptionCanSelect, subscriptionDeliveryCanSelect, validateEventRetention } from "@effect-agent/thread/SubscriptionTransition";
 //#region src/MemorySubscriptionStore.ts
 var MemorySubscriptionStore_exports = /* @__PURE__ */ __exportAll({ memorySubscriptionStoreLayer: () => memorySubscriptionStoreLayer });
 const error = (reason, code) => SubscriptionError.make({
@@ -34,12 +34,61 @@ const eventCandidateIndexKey = (event) => JSON.stringify([
 	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 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 && left.occurredAtMillis === right.occurredAtMillis;
 const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource(delivery.source, event.source);
+const removeKeys = (keys, removed) => {
+	if (removed.size === 0) return keys;
+	const result = [...keys];
+	for (const key of removed) {
+		const index = upperBound(result, key) - 1;
+		if (result[index] === key) result.splice(index, 1);
+	}
+	return result;
+};
+const upperBound = (keys, after) => {
+	let low = 0;
+	let high = keys.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const key = keys[middle];
+		if (key !== void 0 && compareScheduleNames(key, after) <= 0) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+const insertKey = (keys, key) => {
+	const at = upperBound(keys, key);
+	if (at > 0 && keys[at - 1] === key) return keys;
+	return [
+		...keys.slice(0, at),
+		key,
+		...keys.slice(at)
+	];
+};
+const recoveryCountsAfter = (current, next, keys) => {
+	const counts = new Map(current.recoveryCounts);
+	for (const key of keys) {
+		const before = current.registrationIndex.get(key)?.recoveryKey;
+		const after = next.get(key)?.recoveryKey;
+		if (before === after) continue;
+		if (before !== null && before !== void 0) counts.set(before, (counts.get(before) ?? 0) - 1);
+		if (after !== null && after !== void 0) counts.set(after, (counts.get(after) ?? 0) + 1);
+	}
+	return counts;
+};
 const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
 	const partition = yield* validate(SourcePartition, ownedPartition, "partition");
 	const state = yield* Ref.make({
 		sequence: 0,
+		retentionDeadline: null,
+		tombstoneCount: 0,
+		eventKeys: [],
+		deliveryKeys: [],
+		maintenanceEvents: "",
+		maintenanceDeliveries: "",
+		recoveryCounts: /* @__PURE__ */ new Map(),
+		eventDeliveryCounts: /* @__PURE__ */ new Map(),
+		retentionHorizon: null,
 		registrations: /* @__PURE__ */ new Map(),
 		events: /* @__PURE__ */ new Map(),
 		deliveries: /* @__PURE__ */ new Map(),
@@ -73,7 +122,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			}
 			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 (record.configuration.expiresAtMillis !== null && 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];
@@ -90,6 +139,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				key: assigned.key,
 				ordinal: assigned.ordinal,
 				state: assigned.state,
+				recoveryKey: assigned.recovery === null ? null : candidateIndexKey(assigned),
 				recoveryAt: assigned.recovery?.nextAttemptAtMillis ?? null
 			});
 			const candidateIndex = new Map(current.candidateIndex);
@@ -102,6 +152,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				sequence: assigned.ordinal,
 				registrations,
 				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [key]),
 				candidateIndex,
 				ownerRegistrationCounts
 			}];
@@ -127,7 +178,53 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		records.sort((a, b) => a.ordinal - b.ordinal);
 		return records.slice(0, limit);
 	});
-	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input) {
+	const change = Effect.fn("MemorySubscriptionStore.change")(function* (input, expectedRevision, inputChange) {
+		const key = yield* requireKey(input, "change-key");
+		const change = yield* validate(SubscriptionChange, inputChange, "change");
+		yield* validate(Schema.Int.check(Schema.isGreaterThan(0)), expectedRevision, "revision");
+		yield* failpoint.hit("subscription:change:before");
+		const updated = 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 existing = decode(SubscriptionRecord, text, "change-record");
+			if (Result.isFailure(existing)) return [existing, current];
+			const updated = applySubscriptionChange(existing.success, expectedRevision, change);
+			if (Result.isFailure(updated)) return [updated, current];
+			const revised = {
+				...updated.success,
+				ordinal: current.sequence + 1
+			};
+			const encoded = encode(SubscriptionRecord, revised, "change-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);
+			registrationIndex.set(storageKey, {
+				key,
+				ordinal: revised.ordinal,
+				state: revised.state,
+				recoveryKey: revised.recovery === null ? null : candidateIndexKey(revised),
+				recoveryAt: revised.recovery?.nextAttemptAtMillis ?? null
+			});
+			const candidateIndex = new Map(current.candidateIndex);
+			const oldKey = candidateIndexKey(existing.success);
+			const nextKey = candidateIndexKey(revised);
+			candidateIndex.set(oldKey, (candidateIndex.get(oldKey) ?? []).filter((key) => key !== storageKey));
+			candidateIndex.set(nextKey, [...candidateIndex.get(nextKey) ?? [], storageKey].sort((a, b) => (registrationIndex.get(a)?.ordinal ?? 0) - (registrationIndex.get(b)?.ordinal ?? 0)));
+			return [Result.succeed(revised), {
+				...current,
+				sequence: revised.ordinal,
+				registrations,
+				registrationIndex,
+				candidateIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		yield* failpoint.hit("subscription:change:after");
+		return updated;
+	});
+	const cancel = Effect.fn("MemorySubscriptionStore.cancel")(function* (input, expectedRevision) {
 		const key = yield* requireKey(input, "cancel-key");
 		yield* failpoint.hit("subscription:cancel:before");
 		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
@@ -136,9 +233,16 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			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 (expectedRevision !== void 0 && expectedRevision !== decoded.success.configurationRevision && !(decoded.success.state === "cancelled" && expectedRevision + 1 === decoded.success.configurationRevision)) return [Result.fail(SubscriptionError.make({
+				reason: "conflict",
+				code: "configuration-revision",
+				currentRevision: decoded.success.configurationRevision,
+				currentState: decoded.success.state
+			})), current];
 			if (decoded.success.state === "cancelled") return [Result.succeed(decoded.success), current];
 			const cancelled = {
 				...decoded.success,
+				configurationRevision: decoded.success.configurationRevision + 1,
 				state: "cancelled",
 				recovery: null
 			};
@@ -152,12 +256,14 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			registrationIndex.set(storageKey, {
 				...indexed,
 				state: "cancelled",
-				recoveryAt: null
+				recoveryAt: null,
+				recoveryKey: null
 			});
 			return [Result.succeed(cancelled), {
 				...current,
 				registrations,
-				registrationIndex
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
 			}];
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:cancel:after");
@@ -165,6 +271,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 	});
 	const accept = Effect.fn("MemorySubscriptionStore.accept")(function* (input, inputLimits) {
 		const event = yield* validate(AcceptedEvent, input, "accept-event");
+		const currentTimeMillis = yield* Clock.currentTimeMillis;
 		const limits = yield* validate(SubscriptionLimits, inputLimits, "accept-limits");
 		yield* requirePartition(event, "accept-partition");
 		yield* failpoint.hit("subscription:accept:before");
@@ -175,8 +282,11 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				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 (current.retentionHorizon !== null && current.retentionHorizon !== limits.retention?.replayHorizonMillis) return [Result.fail(error("conflict", "retention-horizon")), current];
+			const horizon = validateEventRetention(event, limits, currentTimeMillis);
+			if (Result.isFailure(horizon)) return [Result.fail(horizon.failure), 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];
+			if (current.events.size - current.tombstoneCount >= limits.maxEvents) return [Result.fail(error("capacity", "events")), current];
 			const accepted = {
 				...event,
 				cutoff: current.sequence + 1,
@@ -197,7 +307,10 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				...current,
 				sequence: accepted.cutoff,
 				events,
-				eventIndex
+				eventIndex,
+				eventKeys: insertKey(current.eventKeys, accepted.eventId),
+				retentionHorizon: limits.retention?.replayHorizonMillis ?? current.retentionHorizon,
+				retentionDeadline: limits.retention === void 0 ? current.retentionDeadline : accepted.acceptedAtMillis
 			}];
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:accept:after");
@@ -297,7 +410,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 					registrationUpdates.push([consumedKey, {
 						...indexed,
 						state: "consumed",
-						recoveryAt: null
+						recoveryAt: null,
+						recoveryKey: null
 					}]);
 				}
 			}
@@ -310,6 +424,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			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 eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			eventDeliveryCounts.set(accepted.eventId, (eventDeliveryCounts.get(accepted.eventId) ?? 0) + additions.length);
 			const nextEvent = {
 				...accepted,
 				cursor,
@@ -329,9 +445,12 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				...current,
 				registrations,
 				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, registrationUpdates.map(([key]) => key)),
+				eventDeliveryCounts,
 				events,
 				eventIndex,
 				deliveries: nextDeliveries,
+				deliveryKeys: additions.reduce((keys, [key]) => insertKey(keys, key), current.deliveryKeys),
 				deliveryIndex,
 				ownerDeliveryCounts: owners
 			}];
@@ -385,7 +504,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			registrationIndex.set(consumedKey, {
 				...indexed,
 				state: "consumed",
-				recoveryAt: null
+				recoveryAt: null,
+				recoveryKey: null
 			});
 			const deliveryIndex = new Map(current.deliveryIndex);
 			deliveryIndex.set(key, {
@@ -394,14 +514,19 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				nextAttemptAtMillis: delivery.retry.nextAttemptAtMillis
 			});
 			const ownerDeliveryCounts = new Map(current.ownerDeliveryCounts);
+			const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			eventDeliveryCounts.set(accepted.success.eventId, (eventDeliveryCounts.get(accepted.success.eventId) ?? 0) + 1);
 			ownerDeliveryCounts.set(consumed.key.ownerId, ownerCount + 1);
 			return [Result.void, {
 				...current,
 				deliveries,
 				deliveryIndex,
+				deliveryKeys: insertKey(current.deliveryKeys, key),
 				ownerDeliveryCounts,
 				registrations,
-				registrationIndex
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [consumedKey]),
+				eventDeliveryCounts
 			}];
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:catch-up:after");
@@ -446,7 +571,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 	});
 	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);
+		for (const [storageKey, item] of (yield* Ref.get(state)).deliveryIndex) if ((item.state !== "delivered" && item.state !== "refused" && item.parked !== true || item.state === "delivered" && item.observeSettlement === true) && 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);
 	});
@@ -495,6 +620,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			deliveryIndex.set(storageKey, {
 				...indexed,
 				state: updated.state,
+				parked: updated.retry.parked ?? false,
+				observeSettlement: updated.observeSettlement ?? false,
 				nextAttemptAtMillis: updated.retry.nextAttemptAtMillis
 			});
 			return [Result.succeed(updated), {
@@ -515,7 +642,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		records.sort((a, b) => a.ordinal - b.ordinal);
 		return records.slice(0, limit);
 	});
-	const deferRecovery = Effect.fn("MemorySubscriptionStore.deferRecovery")(function* (input, recovery) {
+	const deferRecovery = Effect.fn("MemorySubscriptionStore.deferRecovery")(function* (input, expectedRevision, recovery) {
 		const key = yield* requireKey(input, "defer-recovery-key");
 		yield* failpoint.hit("subscription:defer-recovery:before");
 		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
@@ -524,9 +651,10 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			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];
+			if (record.success.configurationRevision !== expectedRevision) return [Result.void, current];
 			const updated = {
 				...record.success,
-				recovery: record.success.state === "active" ? recovery : null
+				recovery: record.success.state === "active" || record.success.state === "paused" ? recovery : null
 			};
 			const encoded = encode(SubscriptionRecord, updated, "defer-recovery-encode");
 			if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
@@ -537,12 +665,14 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			if (indexed === void 0) return [Result.fail(error("corrupt", "recovery-index")), current];
 			registrationIndex.set(storageKey, {
 				...indexed,
+				recoveryKey: updated.recovery === null ? null : candidateIndexKey(updated),
 				recoveryAt: updated.recovery?.nextAttemptAtMillis ?? null
 			});
 			return [Result.void, {
 				...current,
 				registrations,
-				registrationIndex
+				registrationIndex,
+				recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey])
 			}];
 		})).pipe(Effect.flatMap(Effect.fromResult));
 		yield* failpoint.hit("subscription:defer-recovery:after");
@@ -564,17 +694,136 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		const consider = (value) => {
 			if (deadline === null || value < deadline) deadline = value;
 		};
+		if (current.retentionDeadline !== null) consider(current.retentionDeadline);
 		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 item of current.deliveryIndex.values()) if (item.state !== "delivered" && item.state !== "refused" && item.parked !== true || item.state === "delivered" && item.observeSettlement === true) 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"));
+	const compact = Effect.fn("MemorySubscriptionStore.compact")(function* (nowMillis, inputPolicy, requestedLimit) {
+		nowMillis = Math.min(nowMillis, yield* Clock.currentTimeMillis);
+		const policy = yield* validate(SubscriptionRetentionPolicy, inputPolicy, "retention-policy");
+		const limit = yield* validate(Schema.Int.check(Schema.isBetween({
+			minimum: 1,
+			maximum: 100
+		})), requestedLimit, "maintenance-limit");
+		yield* failpoint.hit("subscription:compact:before");
+		let corruptCandidates = 0;
+		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
+			if (current.retentionHorizon !== null && current.retentionHorizon !== policy.replayHorizonMillis) return [Result.fail(error("conflict", "retention-horizon")), current];
+			const events = new Map(current.events);
+			const eventIndex = new Map(current.eventIndex);
+			const deliveries = new Map(current.deliveries);
+			const deliveryIndex = new Map(current.deliveryIndex);
+			const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+			const ownerDeliveryCounts = new Map(current.ownerDeliveryCounts);
+			const deliveryPage = current.deliveryKeys.slice(upperBound(current.deliveryKeys, current.maintenanceDeliveries), upperBound(current.deliveryKeys, current.maintenanceDeliveries) + limit);
+			const eventPage = current.eventKeys.slice(upperBound(current.eventKeys, current.maintenanceEvents), upperBound(current.eventKeys, current.maintenanceEvents) + limit);
+			const cutoff = nowMillis - policy.completedRetentionMillis;
+			let removed = 0;
+			const removedEvents = /* @__PURE__ */ new Set();
+			const removedDeliveries = /* @__PURE__ */ new Set();
+			for (const key of deliveryPage) {
+				const text = deliveries.get(key);
+				if (text === void 0) continue;
+				const decoded = decode(SubscriptionDelivery, text, "compact-delivery");
+				if (Result.isFailure(decoded)) {
+					corruptCandidates++;
+					continue;
+				}
+				const delivery = decoded.success;
+				if (subscriptionDeliveryKeyString(delivery.key) !== key || !samePartition(delivery.key.subscription.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (delivery.state !== "refused" && (delivery.state !== "delivered" || delivery.settledAtMillis === void 0)) continue;
+				if ((delivery.settledAtMillis ?? delivery.completedAtMillis ?? delivery.selectedAtMillis) > cutoff) continue;
+				const eventText = events.get(delivery.key.eventId);
+				if (eventText === void 0) continue;
+				const accepted = decode(AcceptedEvent, eventText, "compact-delivery-event");
+				if (Result.isFailure(accepted)) {
+					corruptCandidates++;
+					continue;
+				}
+				const event = accepted.success;
+				if (event.eventId !== delivery.key.eventId || !samePartition(event.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (!event.routingComplete || event.occurredAtMillis === void 0 || event.acceptedAtMillis > cutoff || (current.recoveryCounts.get(eventCandidateIndexKey(event)) ?? 0) > 0) continue;
+				deliveries.delete(key);
+				removedDeliveries.add(key);
+				deliveryIndex.delete(key);
+				eventDeliveryCounts.set(event.eventId, (eventDeliveryCounts.get(event.eventId) ?? 1) - 1);
+				const owner = delivery.key.subscription.ownerId;
+				ownerDeliveryCounts.set(owner, (ownerDeliveryCounts.get(owner) ?? 1) - 1);
+			}
+			let tombstones = current.tombstoneCount;
+			for (const key of eventPage) {
+				const text = events.get(key);
+				if (text === void 0) continue;
+				const decoded = decode(AcceptedEvent, text, "compact-event");
+				if (Result.isFailure(decoded)) {
+					corruptCandidates++;
+					continue;
+				}
+				const event = decoded.success;
+				if (event.eventId !== key || !samePartition(event.partition, partition)) {
+					corruptCandidates++;
+					continue;
+				}
+				if (!event.routingComplete || event.occurredAtMillis === void 0) continue;
+				const expired = event.occurredAtMillis <= nowMillis - policy.replayHorizonMillis;
+				if (event.tombstone === true && !expired) continue;
+				if (event.acceptedAtMillis > cutoff || (eventDeliveryCounts.get(key) ?? 0) > 0 || (current.recoveryCounts.get(eventCandidateIndexKey(event)) ?? 0) > 0) continue;
+				if (expired) {
+					events.delete(key);
+					removedEvents.add(key);
+					eventIndex.delete(key);
+					eventDeliveryCounts.delete(key);
+					if (event.tombstone === true) tombstones--;
+				} else {
+					if (tombstones >= policy.maxTombstones) continue;
+					const encoded = encode(AcceptedEvent, {
+						...event,
+						payload: null,
+						tombstone: true
+					}, "compact-tombstone");
+					if (Result.isFailure(encoded)) continue;
+					events.set(key, encoded.success);
+					tombstones++;
+				}
+				removed++;
+			}
+			return [Result.succeed(removed), {
+				...current,
+				events,
+				eventIndex,
+				deliveries,
+				deliveryIndex,
+				eventDeliveryCounts,
+				ownerDeliveryCounts,
+				eventKeys: removeKeys(current.eventKeys, removedEvents),
+				deliveryKeys: removeKeys(current.deliveryKeys, removedDeliveries),
+				tombstoneCount: tombstones,
+				maintenanceEvents: eventPage.length < limit ? "" : eventPage.at(-1) ?? "",
+				maintenanceDeliveries: deliveryPage.length < limit ? "" : deliveryPage.at(-1) ?? "",
+				retentionHorizon: policy.replayHorizonMillis,
+				retentionDeadline: events.size === 0 ? null : nowMillis + 6e4
+			}];
+		})).pipe(Effect.flatMap(Effect.fromResult));
+		if (corruptCandidates > 0) yield* Effect.logWarning("Subscription retention preserved corrupt candidates", { count: corruptCandidates });
+		yield* failpoint.hit("subscription:compact:after");
+		return result;
+	});
 	return SubscriptionStore.of({
 		partition,
+		compact,
 		register,
 		get,
 		list,
 		cancel,
+		change,
 		accept,
 		event,
 		pendingEvents,