@effect-agent/storage-cloudflare 0.1.0-beta.42 → 0.1.0-beta.44

package/src/do-subscription-store.ts

@@ -29,12 +29,15 @@ const CURRENT_SUBSCRIPTION_STORE_VERSION = 2;
 const StoredJson = Schema.String.check(Schema.isMaxLength(1_900_000));
 const CountRow = Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) });
 const SequenceRow = Schema.Struct({ sequence: Schema.Natural });
+
 const ScanRow = Schema.Struct({
   event_scan_cursor: Schema.String,
   delivery_scan_cursor: Schema.String,
   recovery_scan_cursor: Schema.Natural,
 });
+
 const JsonRow = Schema.Struct({ record_json: StoredJson });
+
 const RegistrationRow = Schema.Struct({
   owner_id: Schema.String,
   subscription_id: Schema.String,
@@ -47,6 +50,7 @@ const RegistrationRow = Schema.Struct({
   recovery_at_millis: Schema.NullOr(Schema.Number),
   record_json: StoredJson,
 });
+
 const EventRow = Schema.Struct({
   event_id: Schema.String,
   source_name: Schema.String,
@@ -59,6 +63,7 @@ const EventRow = Schema.Struct({
   next_attempt_at_millis: Schema.Number,
   record_json: StoredJson,
 });
+
 const DeliveryRow = Schema.Struct({
   owner_id: Schema.String,
   subscription_id: Schema.String,
@@ -68,6 +73,7 @@ const DeliveryRow = Schema.Struct({
   next_attempt_at_millis: Schema.Number,
   record_json: StoredJson,
 });
+
 const StoreStateRow = Schema.Struct({
   storage_version: Schema.Int,
   alarm_generation: Schema.Natural,
@@ -77,6 +83,7 @@ export interface DoSubscriptionAlarmReplacement {
   readonly deadlineAtMillis: number | null;
   readonly generation: number;
 }
+
 export type DoSubscriptionReplaceAlarm = (
   replacement: DoSubscriptionAlarmReplacement,
 ) => Effect.Effect<void, SubscriptionError>;
@@ -103,6 +110,7 @@ export class DoSubscriptionAlarmControl extends Context.Service<
 
 const error = (reason: SubscriptionError["reason"], code: string) =>
   SubscriptionError.make({ reason, code });
+
 const unavailable = (operation: string) => error("storage", operation);
 const corrupt = (operation: string) => error("corrupt", operation);
 const bytes = (value: unknown) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
@@ -135,14 +143,17 @@ const sameDeliveryIdentity = (left: SubscriptionDelivery, right: SubscriptionDel
 
 const initializeDoSubscriptionStore = Effect.fn("DoSubscriptionStore.initialize")(function* () {
   const sql = yield* SqlClientService.SqlClient;
+
   const names = yield* sql<Record<string, unknown>>`
     SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'effect_agent_subscription_%'
   `.pipe(Effect.mapError(() => unavailable("inspect subscription storage")));
+
   const decodedNames = yield* decodeRows(
     Schema.Struct({ name: Schema.String }),
     names,
     "inspect subscription storage",
   );
+
   const expected = new Set([
     "effect_agent_subscription_store_state",
     "effect_agent_subscription_sequences",
@@ -150,9 +161,11 @@ const initializeDoSubscriptionStore = Effect.fn("DoSubscriptionStore.initialize"
     "effect_agent_subscription_events",
     "effect_agent_subscription_deliveries",
   ]);
+
   const hasState = decodedNames.some(
     ({ name }) => name === "effect_agent_subscription_store_state",
   );
+
   if (!hasState && decodedNames.length > 0) return yield* corrupt("partial subscription storage");
   if (!hasState) {
     yield* sql
@@ -201,16 +214,20 @@ const initializeDoSubscriptionStore = Effect.fn("DoSubscriptionStore.initialize"
         }),
       )
       .pipe(Effect.mapError(() => unavailable("initialize subscription storage")));
+
     return;
   }
   if (decodedNames.length !== expected.size || decodedNames.some(({ name }) => !expected.has(name)))
     return yield* corrupt("subscription storage tables");
+
   const rows = yield* sql<
     Record<string, unknown>
   >`SELECT storage_version, alarm_generation FROM effect_agent_subscription_store_state WHERE singleton=1`.pipe(
     Effect.mapError(() => unavailable("read subscription storage version")),
   );
+
   const state = yield* decodeRows(StoreStateRow, rows, "read subscription storage version");
+
   if (state.length !== 1 || state[0].storage_version !== CURRENT_SUBSCRIPTION_STORE_VERSION)
     return yield* corrupt(
       state.length === 1
@@ -226,6 +243,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
   const sql = yield* SqlClientService.SqlClient;
   const failpoint = yield* SubscriptionFailpoint;
   const transactions = yield* DoSubscriptionTransaction;
+
   yield* initializeDoSubscriptionStore();
   yield* sql`
     INSERT INTO effect_agent_subscription_sequences (
@@ -237,6 +255,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     effect: Effect.Effect<ReadonlyArray<A>, SqlError>,
     code: string,
   ) => effect.pipe(Effect.mapError(() => unavailable(code)));
+
   const readIndexedDeadline = Effect.fn("DoSubscriptionStore.readIndexedDeadline")(function* () {
     const scanRows = yield* query(
       sql<Record<string, unknown>>`
@@ -245,7 +264,9 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "read scan cursor deadline",
     );
+
     const scans = yield* decodeRows(ScanRow, scanRows, "read scan cursor deadline");
+
     if (scans.length !== 1) return yield* corrupt("scan cursor deadline");
     if (
       scans[0].event_scan_cursor !== "" ||
@@ -253,6 +274,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       scans[0].recovery_scan_cursor !== 0
     )
       return 0;
+
     const rows = yield* query(
       sql<Record<string, unknown>>`
       SELECT MIN(deadline) AS deadline FROM (
@@ -266,14 +288,18 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "read subscription deadline",
     );
+
     const decoded = yield* decodeRows(
       Schema.Struct({ deadline: Schema.NullOr(Schema.Number) }),
       rows,
       "read subscription deadline",
     );
+
     if (decoded.length !== 1) return yield* corrupt("subscription deadline");
+
     return decoded[0].deadline;
   });
+
   const replaceAlarm = Effect.fn("DoSubscriptionStore.replaceAlarm")(function* (
     replace: DoSubscriptionReplaceAlarm,
     deadlineAtMillis: number | null,
@@ -285,33 +311,43 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "advance subscription alarm generation",
     );
+
     const state = yield* decodeRows(StoreStateRow, rows, "advance subscription alarm generation");
+
     if (state.length !== 1 || state[0].storage_version !== CURRENT_SUBSCRIPTION_STORE_VERSION)
       return yield* corrupt("subscription alarm state");
     yield* failpoint.hit("subscription:alarm:before");
     yield* replace({ deadlineAtMillis, generation: state[0].alarm_generation });
     yield* failpoint.hit("subscription:alarm:after");
   });
+
   const transact = <A>(effect: Effect.Effect<A, SubscriptionError | SubscriptionFailpointError>) =>
     transactions.run((replace) =>
       Effect.gen(function* () {
         const value = yield* effect;
+
         yield* replaceAlarm(replace, yield* readIndexedDeadline());
+
         return value;
       }),
     );
+
   const requirePartition = (candidate: SourcePartition, code: string) =>
     sameSourcePartition(candidate, partition)
       ? Effect.void
       : Effect.fail(error("validation", code));
+
   const requireKey = Effect.fn("SqliteSubscriptionStore.requireKey")(function* (
     input: SubscriptionKey,
     code: string,
   ) {
     const key = yield* validate(SubscriptionKey, input, code);
+
     yield* requirePartition(key.partition, code);
+
     return key;
   });
+
   const readRegistration = Effect.fn("SqliteSubscriptionStore.readRegistration")(function* (
     key: SubscriptionKey,
     code: string,
@@ -325,11 +361,15 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       code,
     );
+
     const decodedRows = yield* decodeRows(RegistrationRow, rows, code);
+
     if (decodedRows.length > 1) return yield* corrupt(code);
     const row = decodedRows[0];
+
     if (row === undefined) return null;
     const record = yield* decode(SubscriptionRecord, row.record_json, code);
+
     if (
       !sameSourcePartition(record.key.partition, partition) ||
       record.key.ownerId !== row.owner_id ||
@@ -343,8 +383,10 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       (record.recovery?.nextAttemptAtMillis ?? null) !== row.recovery_at_millis
     )
       return yield* corrupt(`${code}-projection`);
+
     return record;
   });
+
   const readEvent = Effect.fn("SqliteSubscriptionStore.readEvent")(function* (
     eventId: string,
     code: string,
@@ -357,11 +399,15 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       code,
     );
+
     const decodedRows = yield* decodeRows(EventRow, rows, code);
+
     if (decodedRows.length > 1) return yield* corrupt(code);
     const row = decodedRows[0];
+
     if (row === undefined) return null;
     const event = yield* decode(AcceptedEvent, row.record_json, code);
+
     if (
       !sameSourcePartition(event.partition, partition) ||
       event.eventId !== row.event_id ||
@@ -375,8 +421,10 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       event.nextAttemptAtMillis !== row.next_attempt_at_millis
     )
       return yield* corrupt(`${code}-projection`);
+
     return event;
   });
+
   const readDelivery = Effect.fn("SqliteSubscriptionStore.readDelivery")(function* (
     key: SubscriptionDeliveryKey,
     code: string,
@@ -391,11 +439,15 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       code,
     );
+
     const decodedRows = yield* decodeRows(DeliveryRow, rows, code);
+
     if (decodedRows.length > 1) return yield* corrupt(code);
     const row = decodedRows[0];
+
     if (row === undefined) return null;
     const delivery = yield* decode(SubscriptionDelivery, row.record_json, code);
+
     if (
       !sameSourcePartition(delivery.key.subscription.partition, partition) ||
       delivery.key.subscription.ownerId !== row.owner_id ||
@@ -406,17 +458,22 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       delivery.retry.nextAttemptAtMillis !== row.next_attempt_at_millis
     )
       return yield* corrupt(`${code}-projection`);
+
     return delivery;
   });
+
   const count = Effect.fn("SqliteSubscriptionStore.count")(function* (
     statement: Effect.Effect<ReadonlyArray<Record<string, unknown>>, SqlError>,
     code: string,
   ) {
     const rows = yield* query(statement, code);
     const decoded = yield* decodeRows(CountRow, rows, code);
+
     if (decoded.length !== 1) return yield* corrupt(code);
+
     return decoded[0].count;
   });
+
   const nextSequence = Effect.fn("SqliteSubscriptionStore.nextSequence")(function* () {
     const rows = yield* query(
       sql<Record<string, unknown>>`
@@ -426,14 +483,19 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "advance subscription sequence",
     );
+
     const decoded = yield* decodeRows(SequenceRow, rows, "advance subscription sequence");
+
     if (decoded.length !== 1) return yield* corrupt("subscription sequence");
+
     return decoded[0].sequence;
   });
+
   const writeRegistration = Effect.fn("SqliteSubscriptionStore.writeRegistration")(function* (
     record: SubscriptionRecord,
   ) {
     const json = yield* encode(SubscriptionRecord, record, "encode subscription");
+
     yield* query(
       sql<Record<string, unknown>>`
       UPDATE effect_agent_subscriptions SET state=${record.state}, expires_at_millis=${record.configuration.expiresAtMillis},
@@ -444,10 +506,12 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       "write subscription",
     );
   });
+
   const writeEvent = Effect.fn("SqliteSubscriptionStore.writeEvent")(function* (
     event: AcceptedEvent,
   ) {
     const json = yield* encode(AcceptedEvent, event, "encode event");
+
     yield* query(
       sql<Record<string, unknown>>`
       UPDATE effect_agent_subscription_events SET cursor=${event.cursor}, routing_complete=${event.routingComplete ? 1 : 0},
@@ -457,10 +521,12 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       "write event",
     );
   });
+
   const writeDelivery = Effect.fn("SqliteSubscriptionStore.writeDelivery")(function* (
     delivery: SubscriptionDelivery,
   ) {
     const json = yield* encode(SubscriptionDelivery, delivery, "encode delivery");
+
     yield* query(
       sql<Record<string, unknown>>`
       UPDATE effect_agent_subscription_deliveries SET state=${delivery.state},
@@ -478,13 +544,17 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
   )(function* (input, inputLimits) {
     const record = yield* validate(SubscriptionRecord, input, "register-record");
     const limits = yield* validate(SubscriptionLimits, inputLimits, "register-limits");
+
     yield* requirePartition(record.key.partition, "register-partition");
+
     const result = yield* transact(
       Effect.gen(function* () {
         const existing = yield* readRegistration(record.key, "register-existing");
+
         if (existing !== null) {
           if (existing.creationFingerprint !== record.creationFingerprint)
             return yield* error("conflict", "registration-identity");
+
           return { value: existing, changed: false } as const;
         }
         if (bytes(record.configuration.context) > limits.maxContextBytes)
@@ -516,6 +586,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           return yield* error("capacity", "owner-registrations");
         const assigned = { ...record, ordinal: yield* nextSequence() };
         const json = yield* encode(SubscriptionRecord, assigned, "encode registration");
+
         yield* failpoint.hit("subscription:register:before");
         yield* query(
           sql<Record<string, unknown>>`
@@ -527,10 +598,13 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       `,
           "insert registration",
         );
+
         return { value: assigned, changed: true } as const;
       }),
     );
+
     if (result.changed) yield* failpoint.hit("subscription:register:after");
+
     return result.value;
   });
 
@@ -549,6 +623,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
         "list subscriptions",
       );
+
       const decoded = yield* decodeRows(
         Schema.Struct({
           owner_id: Schema.String,
@@ -558,6 +633,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
         rows,
         "list subscriptions",
       );
+
       return yield* Effect.forEach(
         decoded,
         Effect.fn("SqliteSubscriptionStore.listRecord")(function* (row) {
@@ -565,8 +641,10 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
             { partition, ownerId: row.owner_id, subscriptionId: row.subscription_id },
             "list subscription",
           );
+
           if (record === null || record.ordinal !== row.ordinal)
             return yield* corrupt("list subscription projection");
+
           return record;
         }),
       );
@@ -577,18 +655,24 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.cancel",
   )(function* (input) {
     const key = yield* requireKey(input, "cancel-key");
+
     const result = yield* transact(
       Effect.gen(function* () {
         const current = yield* readRegistration(key, "cancel subscription");
+
         if (current === null) return yield* error("not-found", "subscription");
         if (current.state === "cancelled") return { value: current, changed: false } as const;
         const updated = { ...current, state: "cancelled" as const, recovery: null };
+
         yield* failpoint.hit("subscription:cancel:before");
         yield* writeRegistration(updated);
+
         return { value: updated, changed: true } as const;
       }),
     );
+
     if (result.changed) yield* failpoint.hit("subscription:cancel:after");
+
     return result.value;
   });
 
@@ -597,13 +681,17 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
   )(function* (input, inputLimits) {
     const event = yield* validate(AcceptedEvent, input, "accept-event");
     const limits = yield* validate(SubscriptionLimits, inputLimits, "accept-limits");
+
     yield* requirePartition(event.partition, "accept-partition");
+
     const result = yield* transact(
       Effect.gen(function* () {
         const existing = yield* readEvent(event.eventId, "accept event");
+
         if (existing !== null) {
           if (!sameAcceptedEventIdentity(existing, event))
             return yield* error("conflict", "event-identity");
+
           return { value: existing, changed: false } as const;
         }
         if (bytes(event.payload) > limits.maxPayloadBytes)
@@ -617,6 +705,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           )) >= limits.maxEvents
         )
           return yield* error("capacity", "events");
+
         const accepted: AcceptedEvent = {
           ...event,
           cutoff: yield* nextSequence(),
@@ -624,7 +713,9 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           routingComplete: false,
           routingFailure: null,
         };
+
         const json = yield* encode(AcceptedEvent, accepted, "encode accepted event");
+
         yield* failpoint.hit("subscription:accept:before");
         yield* query(
           sql<Record<string, unknown>>`
@@ -635,10 +726,13 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       `,
           "insert event",
         );
+
         return { value: accepted, changed: true } as const;
       }),
     );
+
     if (result.changed) yield* failpoint.hit("subscription:accept:after");
+
     return result.value;
   });
 
@@ -656,6 +750,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "pending events",
     );
+
     return yield* decodeRows(
       Schema.Struct({ event_id: Schema.String }),
       rows,
@@ -667,10 +762,13 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.candidates",
   )(function* (input, limit) {
     const supplied = yield* validate(AcceptedEvent, input, "candidates-event");
+
     yield* requirePartition(supplied.partition, "candidates-partition");
     const stored = yield* readEvent(supplied.eventId, "candidates event");
+
     if (stored === null) return yield* error("not-found", "event");
     if (!sameAcceptedEventIdentity(stored, supplied)) return yield* error("conflict", "event");
+
     const rows = yield* query(
       sql<Record<string, unknown>>`
       SELECT owner_id, subscription_id, ordinal FROM effect_agent_subscriptions WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
@@ -679,6 +777,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "subscription candidates",
     );
+
     const decoded = yield* decodeRows(
       Schema.Struct({
         owner_id: Schema.String,
@@ -688,6 +787,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       rows,
       "subscription candidates",
     );
+
     return yield* Effect.forEach(
       decoded,
       Effect.fn("SqliteSubscriptionStore.candidateRecord")(function* (row) {
@@ -695,8 +795,10 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           { partition, ownerId: row.owner_id, subscriptionId: row.subscription_id },
           "subscription candidate",
         );
+
         if (record === null || record.ordinal !== row.ordinal)
           return yield* corrupt("subscription candidate projection");
+
         return record;
       }),
     );
@@ -706,6 +808,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     delivery: SubscriptionDelivery,
   ) {
     const json = yield* encode(SubscriptionDelivery, delivery, "encode selected delivery");
+
     yield* query(
       sql<Record<string, unknown>>`
       INSERT INTO effect_agent_subscription_deliveries (tenant_id, source_address, owner_id, subscription_id, event_id,
@@ -721,18 +824,23 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.select",
   )(function* (inputEvent, inputDeliveries, cursor, complete, nowMillis, inputLimits) {
     const supplied = yield* validate(AcceptedEvent, inputEvent, "select-event");
+
     const deliveries = yield* validate(
       Schema.Array(SubscriptionDelivery),
       inputDeliveries,
       "select-deliveries",
     );
+
     const limits = yield* validate(SubscriptionLimits, inputLimits, "select-limits");
+
     yield* requirePartition(supplied.partition, "select-partition");
     for (const candidate of deliveries)
       yield* requirePartition(candidate.key.subscription.partition, "select-delivery-partition");
+
     const changed = yield* transact(
       Effect.gen(function* () {
         const accepted = yield* readEvent(supplied.eventId, "select event");
+
         if (accepted === null) return yield* error("not-found", "event");
         if (!sameAcceptedEventIdentity(accepted, supplied) || accepted.cursor !== supplied.cursor)
           return yield* error("conflict", "event-cursor");
@@ -742,8 +850,10 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
         yield* failpoint.hit("subscription:select:before");
         const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
         const additions: Array<{ delivery: SubscriptionDelivery; record: SubscriptionRecord }> = [];
+
         for (const delivery of deliveries) {
           const record = yield* readRegistration(delivery.key.subscription, "select registration");
+
           if (record === null) return yield* error("not-found", "subscription");
           if (
             !subscriptionDeliveryCanSelect(delivery, record, accepted) ||
@@ -755,6 +865,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           )
             return yield* error("conflict", "selection");
           const existing = yield* readDelivery(delivery.key, "select existing delivery");
+
           if (existing !== null) {
             if (!sameDeliveryIdentity(existing, delivery))
               return yield* error("conflict", "delivery-identity");
@@ -763,12 +874,14 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, false)) continue;
           additions.push({ delivery, record });
         }
+
         const total = yield* count(
           sql<
             Record<string, unknown>
           >`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}`,
           "count deliveries",
         );
+
         if (total + additions.length > limits.maxDeliveries)
           return yield* error("capacity", "deliveries");
         for (const ownerId of new Set(additions.map(({ record }) => record.key.ownerId))) {
@@ -778,6 +891,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
             >`SELECT COUNT(*) AS count FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address} AND owner_id=${ownerId}`,
             "count owner deliveries",
           );
+
           if (
             existing + additions.filter(({ record }) => record.key.ownerId === ownerId).length >
             limits.maxDeliveriesPerOwner
@@ -790,9 +904,11 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
             yield* writeRegistration({ ...addition.record, state: "consumed", recovery: null });
         }
         yield* writeEvent({ ...accepted, cursor, routingComplete: complete, routingFailure: null });
+
         return true;
       }),
     );
+
     if (changed) yield* failpoint.hit("subscription:select:after");
   });
 
@@ -802,12 +918,15 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     const supplied = 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");
+
     yield* requirePartition(supplied.partition, "catch-up-partition");
     yield* requirePartition(delivery.key.subscription.partition, "catch-up-delivery-partition");
+
     const changed = yield* transact(
       Effect.gen(function* () {
         const accepted = yield* readEvent(supplied.eventId, "catch-up event");
         const record = yield* readRegistration(delivery.key.subscription, "catch-up subscription");
+
         if (accepted === null || record === null)
           return yield* error("not-found", accepted === null ? "event" : "subscription");
         if (
@@ -820,13 +939,16 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
         )
           return yield* error("conflict", "catch-up-identity");
         const existing = yield* readDelivery(delivery.key, "catch-up existing delivery");
+
         if (existing !== null) {
           if (!sameDeliveryIdentity(existing, delivery))
             return yield* error("conflict", "delivery-identity");
+
           return false;
         }
         yield* failpoint.hit("subscription:catch-up:before");
         const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
+
         if (!subscriptionCanSelect(record, accepted, effectiveNowMillis, true))
           return yield* error("conflict", "catch-up-eligibility");
         if (
@@ -849,9 +971,11 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
           return yield* error("capacity", "owner-deliveries");
         yield* insertDelivery(delivery);
         yield* writeRegistration({ ...record, state: "consumed", recovery: null });
+
         return true;
       }),
     );
+
     if (changed) yield* failpoint.hit("subscription:catch-up:after");
   });
 
@@ -862,9 +986,11 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
       code === undefined
         ? "routing-failed"
         : yield* validate(SubscriptionName, code, "routing-failure");
+
     yield* transact(
       Effect.gen(function* () {
         const accepted = yield* readEvent(eventId, "defer event");
+
         if (accepted === null) return yield* error("not-found", "event");
         yield* failpoint.hit("subscription:defer-event:before");
         yield* writeEvent({ ...accepted, nextAttemptAtMillis, routingFailure });
@@ -877,7 +1003,9 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.delivery",
   )(function* (input) {
     const key = yield* validate(SubscriptionDeliveryKey, input, "delivery-key");
+
     yield* requirePartition(key.subscription.partition, "delivery-partition");
+
     return yield* readDelivery(key, "get delivery");
   });
 
@@ -892,11 +1020,13 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "pending deliveries",
     );
+
     const rowSchema = Schema.Struct({
       owner_id: Schema.String,
       subscription_id: Schema.String,
       event_id: Schema.String,
     });
+
     return yield* decodeRows(rowSchema, rows, "pending delivery keys").pipe(
       Effect.map((items) =>
         items.map((item) => ({
@@ -911,6 +1041,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.listDeliveries",
   )(function* (input, after, limit) {
     const key = yield* requireKey(input, "list-deliveries-key");
+
     const rows = yield* query(
       sql<Record<string, unknown>>`
       SELECT record_json FROM effect_agent_subscription_deliveries WHERE tenant_id=${partition.tenantId} AND source_address=${partition.address}
@@ -918,7 +1049,9 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "list deliveries",
     );
+
     const decoded = yield* decodeRows(JsonRow, rows, "list deliveries");
+
     return yield* Effect.forEach(decoded, (row) =>
       decode(SubscriptionDelivery, row.record_json, "list delivery"),
     );
@@ -930,32 +1063,41 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     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.partition, "change-delivery-partition");
+
     const result = yield* transact(
       Effect.gen(function* () {
         const existing = yield* readDelivery(key, "change delivery");
         const record = yield* readRegistration(key.subscription, "change delivery subscription");
+
         if (existing === null || record === null)
           return yield* error("not-found", existing === null ? "delivery" : "subscription");
         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 transition = applySubscriptionDeliveryChange(
           existing,
           record,
           deliveryId,
           effectiveChange,
         );
+
         if (Result.isFailure(transition)) return yield* transition.failure;
         if (transition.success === existing) return { value: existing, changed: false } as const;
         yield* writeDelivery(transition.success);
+
         return { value: transition.success, changed: true } as const;
       }),
     );
+
     if (result.changed)
       yield* failpoint.hit(`subscription:delivery-${change._tag.toLowerCase()}:after`);
+
     return result.value;
   });
 
@@ -971,11 +1113,13 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "recovering subscriptions",
     );
+
     const rowSchema = Schema.Struct({
       owner_id: Schema.String,
       subscription_id: Schema.String,
       ordinal: Schema.Natural,
     });
+
     return yield* decodeRows(rowSchema, rows, "recovering subscription keys").pipe(
       Effect.map((items) =>
         items.map((item) => ({
@@ -990,9 +1134,11 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.deferRecovery",
   )(function* (input, recovery) {
     const key = yield* requireKey(input, "defer-recovery-key");
+
     yield* transact(
       Effect.gen(function* () {
         const record = yield* readRegistration(key, "defer recovery");
+
         if (record === null) return yield* error("not-found", "subscription");
         yield* failpoint.hit("subscription:defer-recovery:before");
         yield* writeRegistration({
@@ -1013,8 +1159,11 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     `,
       "read subscription scan cursors",
     );
+
     const decoded = yield* decodeRows(ScanRow, rows, "read subscription scan cursors");
+
     if (decoded.length !== 1) return yield* corrupt("subscription scan cursors");
+
     return {
       events: decoded[0].event_scan_cursor,
       deliveries: decoded[0].delivery_scan_cursor,
@@ -1026,6 +1175,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     "SqliteSubscriptionStore.advanceScanCursors",
   )(function* (input) {
     const cursors = yield* validate(SubscriptionScanCursors, input, "scan-cursors");
+
     yield* transact(
       Effect.gen(function* () {
         yield* failpoint.hit("subscription:advance-scan-cursors:before");
@@ -1071,7 +1221,9 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
 
   const nextDeadline = Effect.gen(function* () {
     const cursors = yield* readScanCursors;
+
     if (cursors.events !== "" || cursors.deliveries !== "" || cursors.recovery !== 0) return 0;
+
     return yield* indexedDeadline;
   });
 
@@ -1079,6 +1231,7 @@ const makeSubscriptionStore = Effect.fn("SqliteSubscriptionStore.make")(function
     yield* transactions.run((replace) => replaceAlarm(replace, deadlineAtMillis));
     yield* failpoint.hit("subscription:prearm:after");
   });
+
   const reconcile = Effect.gen(function* () {
     yield* transactions.run((replace) =>
       Effect.gen(function* () {