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

package/src/MemorySubscriptionStore.ts

@@ -199,9 +199,7 @@ const recoveryCountsAfter = (
   return counts;
 };
 
-const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (
-  ownedPartition: SourcePartition,
-) {
+const makeMemorySubscriptionStore = Effect.fnUntraced(function* (ownedPartition: SourcePartition) {
   const partition = yield* validate(SourcePartition, ownedPartition, "partition");
 
   const state = yield* Ref.make<MemorySubscriptionState>({
@@ -242,108 +240,105 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
       Effect.flatMap((decoded) => requirePartition(decoded, code)),
     );
 
-  const register: SubscriptionStore["Service"]["register"] = Effect.fn(
-    "MemorySubscriptionStore.register",
-  )(function* (input, inputLimits) {
-    const record = yield* validate(SubscriptionRecord, input, "register-record");
-    const limits = yield* validate(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,
-        ): readonly [
-          Result.Result<SubscriptionRecord, SubscriptionError>,
-          MemorySubscriptionState,
-        ] => {
-          const key = subscriptionKeyString(record.key);
-          const existingText = current.registrations.get(key);
-
-          if (existingText !== undefined) {
-            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 !== 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];
-          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,
-            recoveryKey: assigned.recovery === null ? null : candidateIndexKey(assigned),
-            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,
-              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [key]),
-              candidateIndex,
-              ownerRegistrationCounts,
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-
-    yield* failpoint.hit("subscription:register:after");
-
-    return result;
-  });
+  const register: SubscriptionStore["Service"]["register"] = Effect.fnUntraced(
+    function* (input, inputLimits) {
+      const record = yield* validate(SubscriptionRecord, input, "register-record");
+      const limits = yield* validate(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,
+          ): readonly [
+            Result.Result<SubscriptionRecord, SubscriptionError>,
+            MemorySubscriptionState,
+          ] => {
+            const key = subscriptionKeyString(record.key);
+            const existingText = current.registrations.get(key);
 
-  const get: SubscriptionStore["Service"]["get"] = Effect.fn("MemorySubscriptionStore.get")(
-    function* (input) {
-      const key = yield* requireKey(input, "get-key");
-      const text = (yield* Ref.get(state)).registrations.get(subscriptionKeyString(key));
+            if (existingText !== undefined) {
+              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 !== 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];
+            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,
+              recoveryKey: assigned.recovery === null ? null : candidateIndexKey(assigned),
+              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,
+                recoveryCounts: recoveryCountsAfter(current, registrationIndex, [key]),
+                candidateIndex,
+                ownerRegistrationCounts,
+              },
+            ];
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
 
-      return text === undefined
-        ? null
-        : yield* decodeEffect(SubscriptionRecord, text, "get-record");
+      yield* failpoint.hit("subscription:register:after");
+
+      return result;
     },
   );
 
-  const list: SubscriptionStore["Service"]["list"] = Effect.fn("MemorySubscriptionStore.list")(
+  const get: SubscriptionStore["Service"]["get"] = Effect.fnUntraced(function* (input) {
+    const key = yield* requireKey(input, "get-key");
+    const text = (yield* Ref.get(state)).registrations.get(subscriptionKeyString(key));
+
+    return text === undefined ? null : yield* decodeEffect(SubscriptionRecord, text, "get-record");
+  });
+
+  const list: SubscriptionStore["Service"]["list"] = Effect.fnUntraced(
     function* (ownerId, after, limit) {
       if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit <= 0)
         return yield* error("validation", "list-page");
@@ -363,690 +358,696 @@ 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),
-              ),
-            );
-          }
+  const change: SubscriptionStore["Service"]["change"] = Effect.fnUntraced(
+    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);
 
-          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;
-  });
+              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),
+                ),
+              );
+            }
 
-  const cancel: SubscriptionStore["Service"]["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,
-        ): 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 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,
+              Result.succeed(revised),
+              {
+                ...current,
+                sequence: revised.ordinal,
+                registrations,
+                registrationIndex,
+                candidateIndex,
+                recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
+              },
             ];
-          if (decoded.success.state === "cancelled")
-            return [Result.succeed(decoded.success), current];
-
-          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];
-          const registrations = new Map(current.registrations);
-
-          registrations.set(storageKey, encoded.success);
-          const registrationIndex = new Map(current.registrationIndex);
-          const indexed = registrationIndex.get(storageKey);
-
-          if (indexed === undefined)
-            return [Result.fail(error("corrupt", "cancel-index")), current];
-          registrationIndex.set(storageKey, {
-            ...indexed,
-            state: "cancelled",
-            recoveryAt: null,
-            recoveryKey: null,
-          });
-
-          return [
-            Result.succeed(cancelled),
-            {
-              ...current,
-              registrations,
-              registrationIndex,
-              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-
-    yield* failpoint.hit("subscription:cancel:after");
-
-    return result;
-  });
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
 
-  const accept: SubscriptionStore["Service"]["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");
-
-    const result = yield* Effect.uninterruptible(
-      Ref.modify(
-        state,
-        (
-          current,
-        ): readonly [Result.Result<AcceptedEvent, SubscriptionError>, MemorySubscriptionState] => {
-          const existingText = current.events.get(event.eventId);
-
-          if (existingText !== undefined) {
-            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 (
-            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 - current.tombstoneCount >= limits.maxEvents)
-            return [Result.fail(error("capacity", "events")), current];
-
-          const accepted: AcceptedEvent = {
-            ...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,
-              eventKeys: insertKey(current.eventKeys, accepted.eventId),
-              retentionHorizon: limits.retention?.replayHorizonMillis ?? current.retentionHorizon,
-              retentionDeadline:
-                limits.retention === undefined
-                  ? current.retentionDeadline
-                  : accepted.acceptedAtMillis,
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-
-    yield* failpoint.hit("subscription:accept:after");
-
-    return result;
-  });
+      yield* failpoint.hit("subscription:change:after");
+
+      return updated;
+    },
+  );
 
-  const event: SubscriptionStore["Service"]["event"] = Effect.fn("MemorySubscriptionStore.event")(
-    function* (eventId) {
-      const text = (yield* Ref.get(state)).events.get(eventId);
+  const cancel: SubscriptionStore["Service"]["cancel"] = Effect.fnUntraced(
+    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,
+          ): 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 decoded = decode(SubscriptionRecord, text, "cancel-record");
 
-      return text === undefined ? null : yield* decodeEffect(AcceptedEvent, text, "event-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,
+              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];
+            const registrations = new Map(current.registrations);
+
+            registrations.set(storageKey, encoded.success);
+            const registrationIndex = new Map(current.registrationIndex);
+            const indexed = registrationIndex.get(storageKey);
+
+            if (indexed === undefined)
+              return [Result.fail(error("corrupt", "cancel-index")), current];
+            registrationIndex.set(storageKey, {
+              ...indexed,
+              state: "cancelled",
+              recoveryAt: null,
+              recoveryKey: null,
+            });
+
+            return [
+              Result.succeed(cancelled),
+              {
+                ...current,
+                registrations,
+                registrationIndex,
+                recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
+              },
+            ];
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
+
+      yield* failpoint.hit("subscription:cancel:after");
+
+      return result;
     },
   );
 
-  const pendingEvents: SubscriptionStore["Service"]["pendingEvents"] = Effect.fn(
-    "MemorySubscriptionStore.pendingEvents",
-  )(function* (nowMillis, after, limit) {
-    const events: Array<string> = [];
+  const accept: SubscriptionStore["Service"]["accept"] = Effect.fnUntraced(
+    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");
+
+      const result = yield* Effect.uninterruptible(
+        Ref.modify(
+          state,
+          (
+            current,
+          ): readonly [
+            Result.Result<AcceptedEvent, SubscriptionError>,
+            MemorySubscriptionState,
+          ] => {
+            const existingText = current.events.get(event.eventId);
 
-    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);
+            if (existingText !== undefined) {
+              const existing = decode(AcceptedEvent, existingText, "accept-existing");
 
-    return events.slice(0, limit);
-  });
+              if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
 
-  const candidates: SubscriptionStore["Service"]["candidates"] = Effect.fn(
-    "MemorySubscriptionStore.candidates",
-  )(function* (input, limit) {
-    const accepted = yield* validate(AcceptedEvent, input, "candidates-event");
+              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);
 
-    yield* requirePartition(accepted, "candidates-partition");
-    const stored = yield* event(accepted.eventId);
+            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 - current.tombstoneCount >= limits.maxEvents)
+              return [Result.fail(error("capacity", "events")), current];
 
-    if (stored === null || !sameEventIdentity(stored, accepted))
-      return yield* error(stored === null ? "not-found" : "conflict", "event");
-    const current = yield* Ref.get(state);
-    const records: Array<SubscriptionRecord> = [];
+            const accepted: AcceptedEvent = {
+              ...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);
 
-    for (const storageKey of current.candidateIndex.get(eventCandidateIndexKey(stored)) ?? []) {
-      const indexed = current.registrationIndex.get(storageKey);
+            events.set(accepted.eventId, encoded.success);
+            const eventIndex = new Map(current.eventIndex);
 
-      if (indexed === undefined) return yield* error("corrupt", "candidate-index");
-      if (indexed.ordinal <= stored.cursor || indexed.ordinal > stored.cutoff) continue;
-      const text = current.registrations.get(storageKey);
+            eventIndex.set(accepted.eventId, {
+              routingComplete: false,
+              nextAttemptAtMillis: accepted.nextAttemptAtMillis,
+            });
 
-      if (text === undefined) return yield* error("corrupt", "candidate-record");
-      records.push(yield* decodeEffect(SubscriptionRecord, text, "candidate-record"));
-    }
-    records.sort((a, b) => a.ordinal - b.ordinal);
+            return [
+              Result.succeed(accepted),
+              {
+                ...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,
+              },
+            ];
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
 
-    return records.slice(0, limit);
+      yield* failpoint.hit("subscription:accept:after");
+
+      return result;
+    },
+  );
+
+  const event: SubscriptionStore["Service"]["event"] = Effect.fnUntraced(function* (eventId) {
+    const text = (yield* Ref.get(state)).events.get(eventId);
+
+    return text === undefined ? null : yield* decodeEffect(AcceptedEvent, text, "event-record");
   });
 
-  const select: SubscriptionStore["Service"]["select"] = Effect.fn(
-    "MemorySubscriptionStore.select",
-  )(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
-    const suppliedEvent = yield* validate(AcceptedEvent, inputEvent, "select-event");
+  const pendingEvents: SubscriptionStore["Service"]["pendingEvents"] = Effect.fnUntraced(
+    function* (nowMillis, after, limit) {
+      const events: Array<string> = [];
+
+      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);
 
-    const deliveries = yield* validate(
-      Schema.Array(SubscriptionDelivery),
-      inputDeliveries,
-      "select-deliveries",
-    );
+      return events.slice(0, limit);
+    },
+  );
 
-    const limits = yield* validate(SubscriptionLimits, inputLimits, "select-limits");
+  const candidates: SubscriptionStore["Service"]["candidates"] = Effect.fnUntraced(
+    function* (input, limit) {
+      const accepted = yield* validate(AcceptedEvent, input, "candidates-event");
 
-    yield* requirePartition(suppliedEvent, "select-partition");
-    yield* failpoint.hit("subscription:select:before");
-    const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+      yield* requirePartition(accepted, "candidates-partition");
+      const stored = yield* event(accepted.eventId);
 
-    yield* Effect.uninterruptible(
-      Ref.modify(
-        state,
-        (current): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
-          const eventText = current.events.get(suppliedEvent.eventId);
+      if (stored === null || !sameEventIdentity(stored, accepted))
+        return yield* error(stored === null ? "not-found" : "conflict", "event");
+      const current = yield* Ref.get(state);
+      const records: Array<SubscriptionRecord> = [];
 
-          if (eventText === undefined) return [Result.fail(error("not-found", "event")), current];
-          const decodedEvent = decode(AcceptedEvent, eventText, "select-event-record");
+      for (const storageKey of current.candidateIndex.get(eventCandidateIndexKey(stored)) ?? []) {
+        const indexed = current.registrationIndex.get(storageKey);
 
-          if (Result.isFailure(decodedEvent)) return [Result.fail(decodedEvent.failure), current];
-          const accepted = decodedEvent.success;
+        if (indexed === undefined) return yield* error("corrupt", "candidate-index");
+        if (indexed.ordinal <= stored.cursor || indexed.ordinal > stored.cutoff) continue;
+        const text = current.registrations.get(storageKey);
 
-          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];
+        if (text === undefined) return yield* error("corrupt", "candidate-record");
+        records.push(yield* decodeEffect(SubscriptionRecord, text, "candidate-record"));
+      }
+      records.sort((a, b) => a.ordinal - b.ordinal);
 
-          const additions: Array<readonly [string, string]> = [];
-          const updates: Array<readonly [string, string]> = [];
-          const additionIndex: Array<readonly [string, DeliveryIndex, string]> = [];
-          const registrationUpdates: Array<readonly [string, RegistrationIndex]> = [];
-          const owners = new Map(current.ownerDeliveryCounts);
+      return records.slice(0, limit);
+    },
+  );
 
-          for (const delivery of deliveries) {
-            const recordText = current.registrations.get(
-              subscriptionKeyString(delivery.key.subscription),
-            );
+  const select: SubscriptionStore["Service"]["select"] = Effect.fnUntraced(
+    function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
+      const suppliedEvent = yield* validate(AcceptedEvent, inputEvent, "select-event");
 
-            if (recordText === undefined)
-              return [Result.fail(error("not-found", "subscription")), current];
-            const record = decode(SubscriptionRecord, recordText, "select-registration");
+      const deliveries = yield* validate(
+        Schema.Array(SubscriptionDelivery),
+        inputDeliveries,
+        "select-deliveries",
+      );
+
+      const limits = yield* validate(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): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
+            const eventText = current.events.get(suppliedEvent.eventId);
+
+            if (eventText === undefined) 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 (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
+              !sameEventIdentity(accepted, suppliedEvent) ||
+              suppliedEvent.cursor !== accepted.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);
+              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];
 
-            if (existingText !== undefined) {
-              const existing = decode(SubscriptionDelivery, existingText, "select-existing");
+            const additions: Array<readonly [string, string]> = [];
+            const updates: Array<readonly [string, string]> = [];
+            const additionIndex: Array<readonly [string, DeliveryIndex, string]> = [];
+            const registrationUpdates: Array<readonly [string, RegistrationIndex]> = [];
+            const owners = new Map(current.ownerDeliveryCounts);
 
-              if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-              if (!sameDeliveryIdentity(existing.success, delivery))
-                return [Result.fail(error("conflict", "delivery-identity")), current];
-              continue;
+            for (const delivery of deliveries) {
+              const recordText = current.registrations.get(
+                subscriptionKeyString(delivery.key.subscription),
+              );
+
+              if (recordText === undefined)
+                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 !== undefined) {
+                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" as const, 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 === undefined)
+                  return [Result.fail(error("corrupt", "selection-index")), current];
+                registrationUpdates.push([
+                  consumedKey,
+                  { ...indexed, state: "consumed", recoveryAt: null, recoveryKey: null },
+                ]);
+              }
             }
+            if (current.deliveries.size + additions.length > limits.maxDeliveries)
+              return [Result.fail(error("capacity", "deliveries")), current];
+            const registrations = new Map(current.registrations);
 
-            const encodedDelivery = encode(
-              SubscriptionDelivery,
-              delivery,
-              "select-delivery-encode",
+            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 eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+
+            eventDeliveryCounts.set(
+              accepted.eventId,
+              (eventDeliveryCounts.get(accepted.eventId) ?? 0) + additions.length,
             );
 
-            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;
+            const nextEvent: AcceptedEvent = {
+              ...accepted,
+              cursor,
+              routingComplete: complete,
+              routingFailure: null,
+            };
 
-            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" as const, recovery: null };
+            const encodedEvent = encode(AcceptedEvent, nextEvent, "select-event-encode");
 
-              const encodedRecord = encode(
-                SubscriptionRecord,
-                consumed,
-                "select-registration-encode",
-              );
+            if (Result.isFailure(encodedEvent)) return [Result.fail(encodedEvent.failure), current];
+            const events = new Map(current.events);
 
-              if (Result.isFailure(encodedRecord))
-                return [Result.fail(encodedRecord.failure), current];
-              const consumedKey = subscriptionKeyString(consumed.key);
+            events.set(nextEvent.eventId, encodedEvent.success);
+            const eventIndex = new Map(current.eventIndex);
 
-              updates.push([consumedKey, encodedRecord.success]);
-              const indexed = current.registrationIndex.get(consumedKey);
+            eventIndex.set(nextEvent.eventId, {
+              routingComplete: nextEvent.routingComplete,
+              nextAttemptAtMillis: nextEvent.nextAttemptAtMillis,
+            });
 
-              if (indexed === undefined)
-                return [Result.fail(error("corrupt", "selection-index")), current];
-              registrationUpdates.push([
-                consumedKey,
-                { ...indexed, state: "consumed", recoveryAt: null, recoveryKey: null },
-              ]);
-            }
-          }
-          if (current.deliveries.size + additions.length > limits.maxDeliveries)
-            return [Result.fail(error("capacity", "deliveries")), current];
-          const registrations = new Map(current.registrations);
+            return [
+              Result.void,
+              {
+                ...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,
+              },
+            ];
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
+      yield* failpoint.hit("subscription:select:after");
+    },
+  );
 
-          for (const [key, value] of updates) registrations.set(key, value);
-          const nextDeliveries = new Map(current.deliveries);
+  const catchUp: SubscriptionStore["Service"]["catchUp"] = Effect.fnUntraced(
+    function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
+      const suppliedEvent = yield* validate(AcceptedEvent, inputEvent, "catch-up-event");
+      const delivery = yield* validate(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
+      const limits = yield* validate(SubscriptionLimits, inputLimits, "catch-up-limits");
 
-          for (const [key, value] of additions) nextDeliveries.set(key, value);
-          const deliveryIndex = new Map(current.deliveryIndex);
+      yield* requirePartition(suppliedEvent, "catch-up-partition");
+      yield* failpoint.hit("subscription:catch-up:before");
+      const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
 
-          for (const [key, value] of additionIndex) deliveryIndex.set(key, value);
-          const registrationIndex = new Map(current.registrationIndex);
+      yield* Effect.uninterruptible(
+        Ref.modify(
+          state,
+          (current): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
+            const eventText = current.events.get(suppliedEvent.eventId);
 
-          for (const [key, value] of registrationUpdates) registrationIndex.set(key, value);
+            const recordText = current.registrations.get(
+              subscriptionKeyString(delivery.key.subscription),
+            );
 
-          const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
+            if (eventText === undefined || recordText === undefined)
+              return [
+                Result.fail(error("not-found", eventText === undefined ? "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");
 
-          eventDeliveryCounts.set(
-            accepted.eventId,
-            (eventDeliveryCounts.get(accepted.eventId) ?? 0) + additions.length,
-          );
+            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);
 
-          const nextEvent: AcceptedEvent = {
-            ...accepted,
-            cursor,
-            routingComplete: complete,
-            routingFailure: null,
-          };
+            if (existingText !== undefined) {
+              const existing = decode(SubscriptionDelivery, existingText, "catch-up-existing");
 
-          const encodedEvent = encode(AcceptedEvent, nextEvent, "select-event-encode");
+              if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
 
-          if (Result.isFailure(encodedEvent)) return [Result.fail(encodedEvent.failure), current];
-          const events = new Map(current.events);
+              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;
 
-          events.set(nextEvent.eventId, encodedEvent.success);
-          const eventIndex = new Map(current.eventIndex);
+            if (ownerCount >= limits.maxDeliveriesPerOwner)
+              return [Result.fail(error("capacity", "owner-deliveries")), current];
 
-          eventIndex.set(nextEvent.eventId, {
-            routingComplete: nextEvent.routingComplete,
-            nextAttemptAtMillis: nextEvent.nextAttemptAtMillis,
-          });
+            const encodedDelivery = encode(
+              SubscriptionDelivery,
+              delivery,
+              "catch-up-delivery-encode",
+            );
 
-          return [
-            Result.void,
-            {
-              ...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,
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-    yield* failpoint.hit("subscription:select:after");
-  });
+            if (Result.isFailure(encodedDelivery))
+              return [Result.fail(encodedDelivery.failure), current];
+            const consumed = { ...record.success, state: "consumed" as const, recovery: null };
 
-  const catchUp: SubscriptionStore["Service"]["catchUp"] = Effect.fn(
-    "MemorySubscriptionStore.catchUp",
-  )(function* (inputEvent, inputDelivery, nowMillis, inputLimits) {
-    const suppliedEvent = yield* validate(AcceptedEvent, inputEvent, "catch-up-event");
-    const delivery = yield* validate(SubscriptionDelivery, inputDelivery, "catch-up-delivery");
-    const limits = yield* validate(SubscriptionLimits, inputLimits, "catch-up-limits");
+            const encodedRecord = encode(
+              SubscriptionRecord,
+              consumed,
+              "catch-up-registration-encode",
+            );
 
-    yield* requirePartition(suppliedEvent, "catch-up-partition");
-    yield* failpoint.hit("subscription:catch-up:before");
-    const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+            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 === undefined)
+              return [Result.fail(error("corrupt", "catch-up-index")), current];
+            registrationIndex.set(consumedKey, {
+              ...indexed,
+              state: "consumed",
+              recoveryAt: null,
+              recoveryKey: 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);
+            const eventDeliveryCounts = new Map(current.eventDeliveryCounts);
 
-    yield* Effect.uninterruptible(
-      Ref.modify(
-        state,
-        (current): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
-          const eventText = current.events.get(suppliedEvent.eventId);
+            eventDeliveryCounts.set(
+              accepted.success.eventId,
+              (eventDeliveryCounts.get(accepted.success.eventId) ?? 0) + 1,
+            );
 
-          const recordText = current.registrations.get(
-            subscriptionKeyString(delivery.key.subscription),
-          );
+            ownerDeliveryCounts.set(consumed.key.ownerId, ownerCount + 1);
 
-          if (eventText === undefined || recordText === undefined)
             return [
-              Result.fail(error("not-found", eventText === undefined ? "event" : "subscription")),
-              current,
+              Result.void,
+              {
+                ...current,
+                deliveries,
+                deliveryIndex,
+                deliveryKeys: insertKey(current.deliveryKeys, key),
+                ownerDeliveryCounts,
+                registrations,
+                registrationIndex,
+                recoveryCounts: recoveryCountsAfter(current, registrationIndex, [consumedKey]),
+                eventDeliveryCounts,
+              },
             ];
-          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 !== undefined) {
-            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" as const, 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 === undefined)
-            return [Result.fail(error("corrupt", "catch-up-index")), current];
-          registrationIndex.set(consumedKey, {
-            ...indexed,
-            state: "consumed",
-            recoveryAt: null,
-            recoveryKey: 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);
-          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,
-              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [consumedKey]),
-              eventDeliveryCounts,
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-    yield* failpoint.hit("subscription:catch-up:after");
-  });
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
+      yield* failpoint.hit("subscription:catch-up:after");
+    },
+  );
 
-  const deferEvent: SubscriptionStore["Service"]["deferEvent"] = Effect.fn(
-    "MemorySubscriptionStore.deferEvent",
-  )(function* (eventId, nextAttemptAtMillis, code) {
-    const routingFailure =
-      code === undefined
-        ? "routing-failed"
-        : yield* validate(SubscriptionName, code, "routing-failure");
-
-    yield* failpoint.hit("subscription:defer-event:before");
-    yield* Effect.uninterruptible(
-      Ref.modify(
-        state,
-        (current): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
-          const text = current.events.get(eventId);
-
-          if (text === undefined) 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 === undefined)
-            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 deferEvent: SubscriptionStore["Service"]["deferEvent"] = Effect.fnUntraced(
+    function* (eventId, nextAttemptAtMillis, code) {
+      const routingFailure =
+        code === undefined
+          ? "routing-failed"
+          : yield* validate(SubscriptionName, code, "routing-failure");
+
+      yield* failpoint.hit("subscription:defer-event:before");
+      yield* Effect.uninterruptible(
+        Ref.modify(
+          state,
+          (current): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
+            const text = current.events.get(eventId);
+
+            if (text === undefined) 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 === undefined)
+              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: SubscriptionStore["Service"]["delivery"] = Effect.fn(
-    "MemorySubscriptionStore.delivery",
-  )(function* (input) {
+  const delivery: SubscriptionStore["Service"]["delivery"] = Effect.fnUntraced(function* (input) {
     const key = yield* validate(SubscriptionDeliveryKey, input, "delivery-key");
 
     yield* requirePartition(key.subscription, "delivery-partition");
@@ -1057,235 +1058,236 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
       : yield* decodeEffect(SubscriptionDelivery, text, "delivery-record");
   });
 
-  const pendingDeliveries: SubscriptionStore["Service"]["pendingDeliveries"] = Effect.fn(
-    "MemorySubscriptionStore.pendingDeliveries",
-  )(function* (nowMillis, after, limit) {
-    const items: Array<SubscriptionDeliveryKey> = [];
+  const pendingDeliveries: SubscriptionStore["Service"]["pendingDeliveries"] = Effect.fnUntraced(
+    function* (nowMillis, after, limit) {
+      const items: Array<SubscriptionDeliveryKey> = [];
+
+      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)),
+      );
 
-    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);
+    },
+  );
 
-    return items.slice(0, limit);
-  });
+  const listDeliveries: SubscriptionStore["Service"]["listDeliveries"] = Effect.fnUntraced(
+    function* (input, after, limit) {
+      const key = yield* requireKey(input, "list-deliveries-key");
+      const items: Array<SubscriptionDelivery> = [];
 
-  const listDeliveries: SubscriptionStore["Service"]["listDeliveries"] = Effect.fn(
-    "MemorySubscriptionStore.listDeliveries",
-  )(function* (input, after, limit) {
-    const key = yield* requireKey(input, "list-deliveries-key");
-    const items: Array<SubscriptionDelivery> = [];
+      for (const text of (yield* Ref.get(state)).deliveries.values()) {
+        const item = yield* decodeEffect(SubscriptionDelivery, text, "list-delivery");
+        const itemKey = subscriptionDeliveryKeyString(item.key);
 
-    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);
+    },
+  );
 
-      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),
-      ),
-    );
+  const changeDelivery: SubscriptionStore["Service"]["changeDelivery"] = Effect.fnUntraced(
+    function* (inputKey, inputDeliveryId, inputChange) {
+      const key = yield* validate(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
+      const deliveryId = yield* validate(Digest, inputDeliveryId, "change-delivery-id");
+      const change = yield* validate(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,
+          ): readonly [
+            Result.Result<SubscriptionDelivery, SubscriptionError>,
+            MemorySubscriptionState,
+          ] => {
+            const storageKey = subscriptionDeliveryKeyString(key);
+            const text = current.deliveries.get(storageKey);
+
+            if (text === undefined) 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),
+            );
 
-    return items.slice(0, limit);
-  });
+            if (registrationText === undefined)
+              return [Result.fail(error("corrupt", "delivery-registration")), current];
 
-  const changeDelivery: SubscriptionStore["Service"]["changeDelivery"] = Effect.fn(
-    "MemorySubscriptionStore.changeDelivery",
-  )(function* (inputKey, inputDeliveryId, inputChange) {
-    const key = yield* validate(SubscriptionDeliveryKey, inputKey, "change-delivery-key");
-    const deliveryId = yield* validate(Digest, inputDeliveryId, "change-delivery-id");
-    const change = yield* validate(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,
-        ): readonly [
-          Result.Result<SubscriptionDelivery, SubscriptionError>,
-          MemorySubscriptionState,
-        ] => {
-          const storageKey = subscriptionDeliveryKeyString(key);
-          const text = current.deliveries.get(storageKey);
-
-          if (text === undefined) 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 === undefined)
-            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 === undefined)
-            return [Result.fail(error("corrupt", "delivery-index")), current];
-          deliveryIndex.set(storageKey, {
-            ...indexed,
-            state: updated.state,
-            parked: updated.retry.parked ?? false,
-            observeSettlement: updated.observeSettlement ?? false,
-            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 registration = decode(
+              SubscriptionRecord,
+              registrationText,
+              "delivery-registration",
+            );
 
-  const recovering: SubscriptionStore["Service"]["recovering"] = Effect.fn(
-    "MemorySubscriptionStore.recovering",
-  )(function* (nowMillis, after, limit) {
-    const records: Array<{ readonly key: SubscriptionKey; readonly ordinal: number }> = [];
+            if (Result.isFailure(registration)) return [Result.fail(registration.failure), current];
 
-    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);
+            const transition = applySubscriptionDeliveryChange(
+              decoded.success,
+              registration.success,
+              deliveryId,
+              effectiveChange,
+            );
 
-    return records.slice(0, limit);
-  });
+            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 === undefined)
+              return [Result.fail(error("corrupt", "delivery-index")), current];
+            deliveryIndex.set(storageKey, {
+              ...indexed,
+              state: updated.state,
+              parked: updated.retry.parked ?? false,
+              observeSettlement: updated.observeSettlement ?? false,
+              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 deferRecovery: SubscriptionStore["Service"]["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): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
-          const storageKey = subscriptionKeyString(key);
-          const text = current.registrations.get(storageKey);
-
-          if (text === undefined) 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" || record.success.state === "paused"
-                ? 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 === undefined)
-            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,
-              recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
-            },
-          ];
-        },
-      ),
-    ).pipe(Effect.flatMap(Effect.fromResult));
-    yield* failpoint.hit("subscription:defer-recovery:after");
-  });
+  const recovering: SubscriptionStore["Service"]["recovering"] = Effect.fnUntraced(
+    function* (nowMillis, after, limit) {
+      const records: Array<{ readonly key: SubscriptionKey; readonly ordinal: number }> = [];
+
+      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: SubscriptionStore["Service"]["deferRecovery"] = Effect.fnUntraced(
+    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): readonly [Result.Result<void, SubscriptionError>, MemorySubscriptionState] => {
+            const storageKey = subscriptionKeyString(key);
+            const text = current.registrations.get(storageKey);
+
+            if (text === undefined)
+              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" || record.success.state === "paused"
+                  ? 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 === undefined)
+              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,
+                recoveryCounts: recoveryCountsAfter(current, registrationIndex, [storageKey]),
+              },
+            ];
+          },
+        ),
+      ).pipe(Effect.flatMap(Effect.fromResult));
+      yield* failpoint.hit("subscription:defer-recovery:after");
+    },
+  );
 
   const readScanCursors: SubscriptionStore["Service"]["readScanCursors"] = Ref.get(state).pipe(
     Effect.map((current) => current.scanCursors),
   );
 
-  const advanceScanCursors: SubscriptionStore["Service"]["advanceScanCursors"] = Effect.fn(
-    "MemorySubscriptionStore.advanceScanCursors",
-  )(function* (input) {
-    const cursors = yield* validate(SubscriptionScanCursors, input, "scan-cursors");
+  const advanceScanCursors: SubscriptionStore["Service"]["advanceScanCursors"] = Effect.fnUntraced(
+    function* (input) {
+      const cursors = yield* validate(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");
-  });
+      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: number | null = null;
@@ -1315,206 +1317,209 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
       if (record.state === "active" && record.recoveryAt !== null) consider(record.recoveryAt);
 
     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;
-            }
+  });
 
+  const compact: SubscriptionStore["Service"]["compact"] = Effect.fnUntraced(
+    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 (
-              !event.routingComplete ||
-              event.occurredAtMillis === undefined ||
-              event.acceptedAtMillis > cutoff ||
-              (current.recoveryCounts.get(eventCandidateIndexKey(event)) ?? 0) > 0
+              current.retentionHorizon !== null &&
+              current.retentionHorizon !== policy.replayHorizonMillis
             )
-              continue;
-            deliveries.delete(key);
-            removedDeliveries.add(key);
-            deliveryIndex.delete(key);
-            eventDeliveryCounts.set(
-              event.eventId,
-              (eventDeliveryCounts.get(event.eventId) ?? 1) - 1,
+              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 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);
+            const eventPage = current.eventKeys.slice(
+              upperBound(current.eventKeys, current.maintenanceEvents),
+              upperBound(current.eventKeys, current.maintenanceEvents) + limit,
+            );
 
-            if (text === undefined) continue;
-            const decoded = decode(AcceptedEvent, text, "compact-event");
+            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;
 
-            if (Result.isFailure(decoded)) {
-              corruptCandidates++;
-              continue;
+              ownerDeliveryCounts.set(owner, (ownerDeliveryCounts.get(owner) ?? 1) - 1);
             }
-            const event = decoded.success;
-
-            if (event.eventId !== key || !samePartition(event.partition, partition)) {
-              corruptCandidates++;
-              continue;
+            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++;
             }
 
-            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",
-              );
+            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 (Result.isFailure(encoded)) continue;
-              events.set(key, encoded.success);
-              tombstones++;
-            }
-            removed++;
-          }
+      if (corruptCandidates > 0)
+        yield* Effect.logWarning("Subscription retention preserved corrupt candidates", {
+          count: corruptCandidates,
+        });
+      yield* failpoint.hit("subscription:compact:after");
 
-          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 result;
+    },
+  );
 
   return SubscriptionStore.of({
     partition,