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

package/src/MemorySubscriptionStore.ts

@@ -3,6 +3,7 @@ import { compareScheduleNames } from "@effect-agent/thread/ScheduleTransition";
 import {
   AcceptedEvent,
   DeliveryChange,
+  SubscriptionChange,
   SourcePartition,
   SubscriptionDelivery,
   SubscriptionDeliveryKey,
@@ -10,6 +11,7 @@ import {
   SubscriptionFailpoint,
   SubscriptionKey,
   SubscriptionLimits,
+  SubscriptionRetentionPolicy,
   SubscriptionName,
   SubscriptionRecord,
   SubscriptionScanCursors,
@@ -19,6 +21,8 @@ import {
 } from "@effect-agent/thread/Subscription";
 import {
   applySubscriptionDeliveryChange,
+  applySubscriptionChange,
+  validateEventRetention,
   subscriptionCanSelect,
   subscriptionDeliveryCanSelect,
 } from "@effect-agent/thread/SubscriptionTransition";
@@ -26,6 +30,15 @@ import { Clock, Effect, Layer, Ref, Result, Schema } from "effect";
 
 interface MemorySubscriptionState {
   readonly sequence: number;
+  readonly retentionDeadline: number | null;
+  readonly tombstoneCount: number;
+  readonly eventKeys: ReadonlyArray<string>;
+  readonly deliveryKeys: ReadonlyArray<string>;
+  readonly maintenanceEvents: string;
+  readonly maintenanceDeliveries: string;
+  readonly recoveryCounts: ReadonlyMap<string, number>;
+  readonly eventDeliveryCounts: ReadonlyMap<string, number>;
+  readonly retentionHorizon: number | null;
   readonly registrations: ReadonlyMap<string, string>;
   readonly events: ReadonlyMap<string, string>;
   readonly deliveries: ReadonlyMap<string, string>;
@@ -42,6 +55,7 @@ interface RegistrationIndex {
   readonly key: SubscriptionKey;
   readonly ordinal: number;
   readonly state: SubscriptionRecord["state"];
+  readonly recoveryKey: string | null;
   readonly recoveryAt: number | null;
 }
 interface EventIndex {
@@ -51,6 +65,8 @@ interface EventIndex {
 interface DeliveryIndex {
   readonly key: SubscriptionDeliveryKey;
   readonly state: SubscriptionDelivery["state"];
+  readonly parked?: boolean;
+  readonly observeSettlement?: boolean;
   readonly nextAttemptAtMillis: number;
 }
 
@@ -117,7 +133,8 @@ const sameEventIdentity = (left: AcceptedEvent, right: AcceptedEvent): boolean =
   left.eventId === right.eventId &&
   sameSource(left.source, right.source) &&
   left.matchingKey === right.matchingKey &&
-  left.payloadDigest === right.payloadDigest;
+  left.payloadDigest === right.payloadDigest &&
+  left.occurredAtMillis === right.occurredAtMillis;
 
 const deliveryBelongsTo = (
   delivery: SubscriptionDelivery,
@@ -128,6 +145,65 @@ const deliveryBelongsTo = (
   delivery.key.eventId === event.eventId &&
   sameSource(delivery.source, event.source);
 
+// Ordered in-memory indexes allow bounded maintenance pages without scanning retained values.
+const removeKeys = (
+  keys: ReadonlyArray<string>,
+  removed: ReadonlySet<string>,
+): ReadonlyArray<string> => {
+  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: ReadonlyArray<string>, after: string): number => {
+  let low = 0;
+  let high = keys.length;
+
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    const key = keys[middle];
+
+    if (key !== undefined && compareScheduleNames(key, after) <= 0) low = middle + 1;
+    else high = middle;
+  }
+
+  return low;
+};
+
+const insertKey = (keys: ReadonlyArray<string>, key: string): ReadonlyArray<string> => {
+  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: MemorySubscriptionState,
+  next: ReadonlyMap<string, RegistrationIndex>,
+  keys: ReadonlyArray<string>,
+): ReadonlyMap<string, number> => {
+  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 !== undefined) counts.set(before, (counts.get(before) ?? 0) - 1);
+    if (after !== null && after !== undefined) counts.set(after, (counts.get(after) ?? 0) + 1);
+  }
+
+  return counts;
+};
+
 const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (
   ownedPartition: SourcePartition,
 ) {
@@ -135,6 +211,15 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
   const state = yield* Ref.make<MemorySubscriptionState>({
     sequence: 0,
+    retentionDeadline: null,
+    tombstoneCount: 0,
+    eventKeys: [],
+    deliveryKeys: [],
+    maintenanceEvents: "",
+    maintenanceDeliveries: "",
+    recoveryCounts: new Map(),
+    eventDeliveryCounts: new Map(),
+    retentionHorizon: null,
     registrations: new Map(),
     events: new Map(),
     deliveries: new Map(),
@@ -197,8 +282,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
           if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes)
             return [Result.fail(error("capacity", "parameters-bytes")), current];
           if (
-            record.configuration.expiresAtMillis - record.createdAtMillis >
-            limits.maxLifetimeMillis
+            record.configuration.expiresAtMillis !== null &&
+            record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis
           )
             return [Result.fail(error("capacity", "lifetime")), current];
           if (current.registrations.size >= limits.maxRegistrations)
@@ -220,6 +305,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);
@@ -237,6 +323,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
               sequence: assigned.ordinal,
               registrations,
               registrationIndex,
+              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [key]),
               candidateIndex,
               ownerRegistrationCounts,
             },
@@ -281,9 +368,92 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
     },
   );
 
+  const change: SubscriptionStore["Service"]["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,
+        ): readonly [
+          Result.Result<SubscriptionRecord, SubscriptionError>,
+          MemorySubscriptionState,
+        ] => {
+          const storageKey = subscriptionKeyString(key);
+          const text = current.registrations.get(storageKey);
+
+          if (text === undefined) 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: SubscriptionStore["Service"]["cancel"] = Effect.fn(
     "MemorySubscriptionStore.cancel",
-  )(function* (input) {
+  )(function* (input, expectedRevision) {
     const key = yield* requireKey(input, "cancel-key");
 
     yield* failpoint.hit("subscription:cancel:before");
@@ -304,9 +474,35 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
           const decoded = decode(SubscriptionRecord, text, "cancel-record");
 
           if (Result.isFailure(decoded)) return [decoded, current];
+          if (
+            expectedRevision !== undefined &&
+            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, state: "cancelled" as const, recovery: null };
+
+          const cancelled = {
+            ...decoded.success,
+            configurationRevision: decoded.success.configurationRevision + 1,
+            state: "cancelled" as const,
+            recovery: null,
+          };
+
           const encoded = encode(SubscriptionRecord, cancelled, "cancel-encode");
 
           if (Result.isFailure(encoded)) return [Result.fail(encoded.failure), current];
@@ -318,9 +514,22 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
           if (indexed === undefined)
             return [Result.fail(error("corrupt", "cancel-index")), current];
-          registrationIndex.set(storageKey, { ...indexed, state: "cancelled", recoveryAt: null });
+          registrationIndex.set(storageKey, {
+            ...indexed,
+            state: "cancelled",
+            recoveryAt: null,
+            recoveryKey: null,
+          });
 
-          return [Result.succeed(cancelled), { ...current, registrations, registrationIndex }];
+          return [
+            Result.succeed(cancelled),
+            {
+              ...current,
+              registrations,
+              registrationIndex,
+              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
+            },
+          ];
         },
       ),
     ).pipe(Effect.flatMap(Effect.fromResult));
@@ -334,6 +543,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
     "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");
@@ -356,9 +566,17 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
               ? [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)
+          if (current.events.size - current.tombstoneCount >= limits.maxEvents)
             return [Result.fail(error("capacity", "events")), current];
 
           const accepted: AcceptedEvent = {
@@ -384,7 +602,18 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
           return [
             Result.succeed(accepted),
-            { ...current, sequence: accepted.cutoff, events, eventIndex },
+            {
+              ...current,
+              sequence: accepted.cutoff,
+              events,
+              eventIndex,
+              eventKeys: insertKey(current.eventKeys, accepted.eventId),
+              retentionHorizon: limits.retention?.replayHorizonMillis ?? current.retentionHorizon,
+              retentionDeadline:
+                limits.retention === undefined
+                  ? current.retentionDeadline
+                  : accepted.acceptedAtMillis,
+            },
           ];
         },
       ),
@@ -573,7 +802,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
                 return [Result.fail(error("corrupt", "selection-index")), current];
               registrationUpdates.push([
                 consumedKey,
-                { ...indexed, state: "consumed", recoveryAt: null },
+                { ...indexed, state: "consumed", recoveryAt: null, recoveryKey: null },
               ]);
             }
           }
@@ -592,6 +821,13 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
           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: AcceptedEvent = {
             ...accepted,
             cursor,
@@ -618,9 +854,19 @@ 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,
             },
@@ -720,7 +966,12 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
           if (indexed === undefined)
             return [Result.fail(error("corrupt", "catch-up-index")), current];
-          registrationIndex.set(consumedKey, { ...indexed, state: "consumed", recoveryAt: null });
+          registrationIndex.set(consumedKey, {
+            ...indexed,
+            state: "consumed",
+            recoveryAt: null,
+            recoveryKey: null,
+          });
           const deliveryIndex = new Map(current.deliveryIndex);
 
           deliveryIndex.set(key, {
@@ -729,6 +980,12 @@ 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);
 
@@ -738,9 +995,12 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
               ...current,
               deliveries,
               deliveryIndex,
+              deliveryKeys: insertKey(current.deliveryKeys, key),
               ownerDeliveryCounts,
               registrations,
               registrationIndex,
+              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [consumedKey]),
+              eventDeliveryCounts,
             },
           ];
         },
@@ -809,8 +1069,8 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
     for (const [storageKey, item] of (yield* Ref.get(state)).deliveryIndex) {
       if (
-        item.state !== "delivered" &&
-        item.state !== "refused" &&
+        ((item.state !== "delivered" && item.state !== "refused" && item.parked !== true) ||
+          (item.state === "delivered" && item.observeSettlement === true)) &&
         item.nextAttemptAtMillis <= nowMillis &&
         compareScheduleNames(storageKey, after) > 0
       )
@@ -921,6 +1181,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,
           });
 
@@ -955,7 +1217,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
   const deferRecovery: SubscriptionStore["Service"]["deferRecovery"] = Effect.fn(
     "MemorySubscriptionStore.deferRecovery",
-  )(function* (input, recovery) {
+  )(function* (input, expectedRevision, recovery) {
     const key = yield* requireKey(input, "defer-recovery-key");
 
     yield* failpoint.hit("subscription:defer-recovery:before");
@@ -971,9 +1233,15 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 
           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");
@@ -989,10 +1257,19 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
             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 }];
+          return [
+            Result.void,
+            {
+              ...current,
+              registrations,
+              registrationIndex,
+              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
+            },
+          ];
         },
       ),
     ).pipe(Effect.flatMap(Effect.fromResult));
@@ -1030,10 +1307,14 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
       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")
+      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);
@@ -1041,12 +1322,213 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
     return deadline;
   }).pipe(Effect.withSpan("MemorySubscriptionStore.nextDeadline"));
 
+  const compact: SubscriptionStore["Service"]["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): readonly [Result.Result<number, SubscriptionError>, MemorySubscriptionState] => {
+          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);
+
+          // Page indexes before decoding. Each pass reads at most 2 * limit event values and
+          // limit delivery values; relationship checks use maintained reference counts.
+          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 = new Set<string>();
+          const removedDeliveries = new Set<string>();
+
+          for (const key of deliveryPage) {
+            const text = deliveries.get(key);
+
+            if (text === undefined) 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 === undefined)
+            )
+              continue;
+            if (
+              (delivery.settledAtMillis ??
+                delivery.completedAtMillis ??
+                delivery.selectedAtMillis) > cutoff
+            )
+              continue;
+            const eventText = events.get(delivery.key.eventId);
+
+            if (eventText === undefined) 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 === undefined ||
+              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 === undefined) 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 === undefined) 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 + 60_000,
+            },
+          ];
+        },
+      ),
+    ).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,