@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.175

package/src/durable/Scheduling.ts

@@ -197,766 +197,754 @@ const resolveInput = Effect.fnUntraced(function* <InputSchema extends Schema.Top
   return { payload, digest };
 });
 
-const makeManagement = (limits: SchedulingLimits) =>
-  Effect.gen(function* () {
-    const nowMillis = yield* currentMillis;
+const makeManagement = Effect.fnUntraced(function* (limits: SchedulingLimits) {
+  const nowMillis = yield* currentMillis;
 
-    yield* Schema.decodeEffect(ScheduleInstant)(nowMillis + limits.recoveryPollMillis).pipe(
-      Effect.mapError(() =>
-        ScheduleValidationError.make({
-          message: "Scheduling recovery deadline exceeds the supported instant range",
-        }),
-      ),
+  yield* Schema.decodeEffect(ScheduleInstant)(nowMillis + limits.recoveryPollMillis).pipe(
+    Effect.mapError(() =>
+      ScheduleValidationError.make({
+        message: "Scheduling recovery deadline exceeds the supported instant range",
+      }),
+    ),
+  );
+  const store = yield* ScheduleStore;
+  const authorizer = yield* ScheduleAuthorizer;
+  const wake = yield* ScheduleWake;
+  const crypto = yield* Crypto.Crypto;
+
+  const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
+    Effect.provideService(effect, Crypto.Crypto, crypto);
+
+  const fingerprint = Effect.fnUntraced(function* (
+    agentId: AgentId,
+    inputDigest: Digest,
+    options: ScheduleCreateOptions,
+  ) {
+    const timing = yield* Schema.encodeEffect(ScheduleTimingRequestSchema)(options.timing).pipe(
+      Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid timing request" })),
     );
-    const store = yield* ScheduleStore;
-    const authorizer = yield* ScheduleAuthorizer;
-    const wake = yield* ScheduleWake;
-    const crypto = yield* Crypto.Crypto;
 
-    const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
-      Effect.provideService(effect, Crypto.Crypto, crypto);
+    const destination = yield* Schema.encodeEffect(ScheduleDestinationSchema)(
+      options.destination,
+    ).pipe(Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid destination" })));
 
-    const fingerprint = Effect.fnUntraced(function* (
-      agentId: AgentId,
-      inputDigest: Digest,
-      options: ScheduleCreateOptions,
-    ) {
-      const timing = yield* Schema.encodeEffect(ScheduleTimingRequestSchema)(options.timing).pipe(
-        Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid timing request" })),
-      );
-
-      const destination = yield* Schema.encodeEffect(ScheduleDestinationSchema)(
-        options.destination,
-      ).pipe(
-        Effect.mapError(() => ScheduleValidationError.make({ message: "Invalid destination" })),
-      );
+    const definitions = yield* Schema.encodeEffect(DefinitionDigests)(options.definitions).pipe(
+      Effect.mapError(() =>
+        ScheduleValidationError.make({ message: "Invalid definition digests" }),
+      ),
+    );
 
-      const definitions = yield* Schema.encodeEffect(DefinitionDigests)(options.definitions).pipe(
-        Effect.mapError(() =>
-          ScheduleValidationError.make({ message: "Invalid definition digests" }),
-        ),
-      );
+    return yield* withCrypto(
+      digestJson({
+        schemaVersion: 1,
+        owner: options.scope.owner,
+        scheduleId: options.scheduleId,
+        registeringPrincipal: options.scope.principal,
+        deliveryPrincipal: options.deliveryPrincipal,
+        ...(options.admissionGroup === undefined ? {} : { admissionGroup: options.admissionGroup }),
+        ...(options.admissionFence === undefined ? {} : { admissionFence: options.admissionFence }),
+        agentId,
+        definitions,
+        destination,
+        timing,
+        inputDigest,
+      }),
+    ).pipe(
+      Effect.mapError(() =>
+        ScheduleValidationError.make({ message: "Unable to digest Schedule registration" }),
+      ),
+    );
+  });
 
-      return yield* withCrypto(
-        digestJson({
-          schemaVersion: 1,
-          owner: options.scope.owner,
-          scheduleId: options.scheduleId,
-          registeringPrincipal: options.scope.principal,
-          deliveryPrincipal: options.deliveryPrincipal,
-          ...(options.admissionGroup === undefined
-            ? {}
-            : { admissionGroup: options.admissionGroup }),
-          ...(options.admissionFence === undefined
-            ? {}
-            : { admissionFence: options.admissionFence }),
-          agentId,
-          definitions,
-          destination,
-          timing,
-          inputDigest,
-        }),
-      ).pipe(
-        Effect.mapError(() =>
-          ScheduleValidationError.make({ message: "Unable to digest Schedule registration" }),
-        ),
-      );
-    });
+  const configuration = (
+    agentId: AgentId,
+    payload: PersistedJson,
+    inputDigest: Digest,
+    options: ScheduleCreateOptions,
+    timing: ScheduleConfiguration["timing"],
+  ): ScheduleConfiguration => ({
+    timing,
+    destination: options.destination,
+    deliveryPrincipal: options.deliveryPrincipal,
+    ...(options.admissionGroup === undefined ? {} : { admissionGroup: options.admissionGroup }),
+    ...(options.admissionFence === undefined ? {} : { admissionFence: options.admissionFence }),
+    agentId,
+    definitions: options.definitions,
+    input: payload,
+    inputDigest,
+  });
 
-    const configuration = (
-      agentId: AgentId,
-      payload: PersistedJson,
-      inputDigest: Digest,
-      options: ScheduleCreateOptions,
-      timing: ScheduleConfiguration["timing"],
-    ): ScheduleConfiguration => ({
-      timing,
-      destination: options.destination,
-      deliveryPrincipal: options.deliveryPrincipal,
-      ...(options.admissionGroup === undefined ? {} : { admissionGroup: options.admissionGroup }),
-      ...(options.admissionFence === undefined ? {} : { admissionFence: options.admissionFence }),
-      agentId,
-      definitions: options.definitions,
-      input: payload,
-      inputDigest,
-    });
+  const create = Effect.fnUntraced(function* <InputSchema extends Schema.Top>(
+    agent: DurableSubmitAgent<InputSchema>,
+    input: InputSchema["Type"],
+    options: ScheduleCreateOptions,
+  ): Effect.fn.Return<
+    ScheduleSnapshot,
+    ScheduleManagementFailure,
+    InputSchema["EncodingServices"]
+  > {
+    const nowMillis = yield* currentMillis;
 
-    const create = Effect.fnUntraced(function* <InputSchema extends Schema.Top>(
-      agent: DurableSubmitAgent<InputSchema>,
-      input: InputSchema["Type"],
-      options: ScheduleCreateOptions,
-    ): Effect.fn.Return<
-      ScheduleSnapshot,
-      ScheduleManagementFailure,
-      InputSchema["EncodingServices"]
-    > {
-      const nowMillis = yield* currentMillis;
+    const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
 
-      const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(
-        Effect.provideService(Crypto.Crypto, crypto),
-      );
+    const creationFingerprint = yield* fingerprint(
+      agent.definition.id,
+      resolvedInput.digest,
+      options,
+    );
 
-      const creationFingerprint = yield* fingerprint(
-        agent.definition.id,
-        resolvedInput.digest,
-        options,
-      );
+    const key = keyOf(options.scope, options.scheduleId);
 
-      const key = keyOf(options.scope, options.scheduleId);
+    yield* authorizer.manage({
+      operation: "create",
+      scope: options.scope,
+      scheduleId: options.scheduleId,
+    });
+    const existing = yield* store.get(key);
 
+    if (existing !== null) {
+      if (existing.creationFingerprint !== creationFingerprint) {
+        return yield* ScheduleConflict.make({ reason: "creation", key });
+      }
       yield* authorizer.manage({
         operation: "create",
         scope: options.scope,
         scheduleId: options.scheduleId,
+        configuration: existing.configuration,
       });
-      const existing = yield* store.get(key);
-
-      if (existing !== null) {
-        if (existing.creationFingerprint !== creationFingerprint) {
-          return yield* ScheduleConflict.make({ reason: "creation", key });
-        }
-        yield* authorizer.manage({
-          operation: "create",
-          scope: options.scope,
-          scheduleId: options.scheduleId,
-          configuration: existing.configuration,
-        });
-
-        return asSnapshot(existing, nowMillis);
-      }
 
-      const timing = yield* Effect.fromResult(
-        normalizeScheduleTiming(options.timing, nowMillis, limits.minIntervalMillis),
-      );
+      return asSnapshot(existing, nowMillis);
+    }
 
-      const nextAtMillis = yield* Effect.fromResult(scheduleInitialCursor(timing, nowMillis));
+    const timing = yield* Effect.fromResult(
+      normalizeScheduleTiming(options.timing, nowMillis, limits.minIntervalMillis),
+    );
 
-      if (nextAtMillis === null) {
-        return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
-      }
+    const nextAtMillis = yield* Effect.fromResult(scheduleInitialCursor(timing, nowMillis));
 
-      const nextConfiguration = configuration(
-        agent.definition.id,
-        resolvedInput.payload,
-        resolvedInput.digest,
-        options,
-        timing,
-      );
+    if (nextAtMillis === null) {
+      return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
+    }
 
-      yield* authorizer.manage({
-        operation: "create",
-        scope: options.scope,
-        scheduleId: options.scheduleId,
-        configuration: nextConfiguration,
-      });
+    const nextConfiguration = configuration(
+      agent.definition.id,
+      resolvedInput.payload,
+      resolvedInput.digest,
+      options,
+      timing,
+    );
 
-      const record: ScheduleRecord = {
-        schemaVersion: 1,
-        owner: options.scope.owner,
-        scheduleId: options.scheduleId,
-        creationFingerprint,
-        createdBy: options.scope.principal,
-        createdAtMillis: nowMillis,
-        updatedAtMillis: nowMillis,
-        configurationRevision: 1,
-        version: 1,
-        configuration: nextConfiguration,
-        state: "active",
-        nextAtMillis,
-        pending: null,
-        lastReceipt: null,
-        lastRefusal: null,
-        lastSkippedRange: null,
-      };
+    yield* authorizer.manage({
+      operation: "create",
+      scope: options.scope,
+      scheduleId: options.scheduleId,
+      configuration: nextConfiguration,
+    });
 
-      const inserted = yield* store.insert(record, limits.maxSchedulesPerOwner);
+    const record: ScheduleRecord = {
+      schemaVersion: 1,
+      owner: options.scope.owner,
+      scheduleId: options.scheduleId,
+      creationFingerprint,
+      createdBy: options.scope.principal,
+      createdAtMillis: nowMillis,
+      updatedAtMillis: nowMillis,
+      configurationRevision: 1,
+      version: 1,
+      configuration: nextConfiguration,
+      state: "active",
+      nextAtMillis,
+      pending: null,
+      lastReceipt: null,
+      lastRefusal: null,
+      lastSkippedRange: null,
+    };
+
+    const inserted = yield* store.insert(record, limits.maxSchedulesPerOwner);
+
+    yield* wake.notify;
+
+    return asSnapshot(inserted, nowMillis);
+  });
 
-      yield* wake.notify;
+  const update = Effect.fnUntraced(function* <InputSchema extends Schema.Top>(
+    agent: DurableSubmitAgent<InputSchema>,
+    input: InputSchema["Type"],
+    options: ScheduleUpdateOptions,
+  ): Effect.fn.Return<
+    ScheduleSnapshot,
+    ScheduleManagementFailure,
+    InputSchema["EncodingServices"]
+  > {
+    const nowMillis = yield* currentMillis;
+    const key = keyOf(options.scope, options.scheduleId);
 
-      return asSnapshot(inserted, nowMillis);
+    yield* authorizer.manage({
+      operation: "update",
+      scope: options.scope,
+      scheduleId: options.scheduleId,
     });
+    yield* validateRequestedFields(options);
+    const existing = yield* store.get(key);
 
-    const update = Effect.fnUntraced(function* <InputSchema extends Schema.Top>(
-      agent: DurableSubmitAgent<InputSchema>,
-      input: InputSchema["Type"],
-      options: ScheduleUpdateOptions,
-    ): Effect.fn.Return<
-      ScheduleSnapshot,
-      ScheduleManagementFailure,
-      InputSchema["EncodingServices"]
-    > {
-      const nowMillis = yield* currentMillis;
-      const key = keyOf(options.scope, options.scheduleId);
-
-      yield* authorizer.manage({
-        operation: "update",
-        scope: options.scope,
-        scheduleId: options.scheduleId,
-      });
-      yield* validateRequestedFields(options);
-      const existing = yield* store.get(key);
+    if (existing === null) return yield* notFound(key);
+    if (existing.configurationRevision !== options.expectedRevision) {
+      return yield* ScheduleConflict.make({ reason: "revision", key });
+    }
 
-      if (existing === null) return yield* notFound(key);
-      if (existing.configurationRevision !== options.expectedRevision) {
-        return yield* ScheduleConflict.make({ reason: "revision", key });
-      }
+    const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
 
-      const resolvedInput = yield* resolveInput(agent, input, limits.maxInputBytes).pipe(
-        Effect.provideService(Crypto.Crypto, crypto),
-      );
+    const timingRequest =
+      options.timing._tag === "Interval" &&
+      options.timing.anchorMillis === undefined &&
+      existing.configuration.timing._tag === "Interval" &&
+      existing.configuration.timing.everyMillis === options.timing.everyMillis
+        ? { ...options.timing, anchorMillis: existing.configuration.timing.anchorMillis }
+        : options.timing;
 
-      const timingRequest =
-        options.timing._tag === "Interval" &&
-        options.timing.anchorMillis === undefined &&
-        existing.configuration.timing._tag === "Interval" &&
-        existing.configuration.timing.everyMillis === options.timing.everyMillis
-          ? { ...options.timing, anchorMillis: existing.configuration.timing.anchorMillis }
-          : options.timing;
+    const timing = yield* Effect.fromResult(
+      normalizeScheduleTiming(timingRequest, nowMillis, limits.minIntervalMillis),
+    );
 
-      const timing = yield* Effect.fromResult(
-        normalizeScheduleTiming(timingRequest, nowMillis, limits.minIntervalMillis),
-      );
+    const nextAtMillis =
+      timing._tag === "At"
+        ? timing.atMillis
+        : yield* Effect.fromResult(scheduleNextAfter(timing, nowMillis));
 
-      const nextAtMillis =
-        timing._tag === "At"
-          ? timing.atMillis
-          : yield* Effect.fromResult(scheduleNextAfter(timing, nowMillis));
+    if (nextAtMillis === null) {
+      return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
+    }
 
-      if (nextAtMillis === null) {
-        return yield* ScheduleValidationError.make({ message: "Timing has no next occurrence" });
-      }
+    const nextConfiguration = configuration(
+      agent.definition.id,
+      resolvedInput.payload,
+      resolvedInput.digest,
+      options,
+      timing,
+    );
 
-      const nextConfiguration = configuration(
-        agent.definition.id,
-        resolvedInput.payload,
-        resolvedInput.digest,
-        options,
-        timing,
-      );
+    yield* authorizer.manage({
+      operation: "update",
+      scope: options.scope,
+      scheduleId: options.scheduleId,
+      configuration: nextConfiguration,
+    });
 
-      yield* authorizer.manage({
-        operation: "update",
-        scope: options.scope,
-        scheduleId: options.scheduleId,
+    const changed = yield* store.change(
+      key,
+      {
+        _tag: "Update",
+        expectedRevision: options.expectedRevision,
         configuration: nextConfiguration,
-      });
-
-      const changed = yield* store.change(
-        key,
-        {
-          _tag: "Update",
-          expectedRevision: options.expectedRevision,
-          configuration: nextConfiguration,
-          nextAtMillis,
-          nowMillis,
-        },
-        limits.maxSchedulesPerOwner,
-      );
+        nextAtMillis,
+        nowMillis,
+      },
+      limits.maxSchedulesPerOwner,
+    );
 
-      yield* wake.notify;
+    yield* wake.notify;
 
-      return asSnapshot(changed, nowMillis);
-    });
+    return asSnapshot(changed, nowMillis);
+  });
 
-    const get = Effect.fnUntraced(function* (scope: ScheduleScope, scheduleId: ScheduleId) {
-      yield* authorizer.manage({ operation: "get", scope, scheduleId });
-      const key = keyOf(scope, scheduleId);
-      const record = yield* store.get(key);
+  const get = Effect.fnUntraced(function* (scope: ScheduleScope, scheduleId: ScheduleId) {
+    yield* authorizer.manage({ operation: "get", scope, scheduleId });
+    const key = keyOf(scope, scheduleId);
+    const record = yield* store.get(key);
 
-      if (record === null) return yield* notFound(key);
+    if (record === null) return yield* notFound(key);
 
-      return asSnapshot(record, yield* currentMillis);
-    });
+    return asSnapshot(record, yield* currentMillis);
+  });
 
-    const list = Effect.fnUntraced(function* (
-      scope: ScheduleScope,
-      options: ScheduleListOptions = {},
-    ) {
-      yield* authorizer.manage({ operation: "list", scope });
-      const limit = options.limit ?? 50;
+  const list = Effect.fnUntraced(function* (
+    scope: ScheduleScope,
+    options: ScheduleListOptions = {},
+  ) {
+    yield* authorizer.manage({ operation: "list", scope });
+    const limit = options.limit ?? 50;
 
-      if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-        return yield* ScheduleValidationError.make({
-          message: "Schedule page limit must be an integer from 1 through 100",
-        });
-      }
-
-      const page = yield* store.list({
-        owner: scope.owner,
-        ...(options.after === undefined ? {} : { after: options.after }),
-        limit,
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+      return yield* ScheduleValidationError.make({
+        message: "Schedule page limit must be an integer from 1 through 100",
       });
+    }
 
-      const nowMillis = yield* currentMillis;
-
-      return { items: page.items.map((record) => asSnapshot(record, nowMillis)), next: page.next };
+    const page = yield* store.list({
+      owner: scope.owner,
+      ...(options.after === undefined ? {} : { after: options.after }),
+      limit,
     });
 
-    const control = Effect.fnUntraced(function* (
-      operation: "pause" | "resume" | "cancel",
-      scope: ScheduleScope,
-      scheduleId: ScheduleId,
-      expectedRevision: number,
-    ): Effect.fn.Return<ScheduleSnapshot, ScheduleManagementFailure> {
-      yield* authorizer.manage({ operation, scope, scheduleId });
-      const key = keyOf(scope, scheduleId);
-
-      const attempt = (): Effect.Effect<ScheduleRecord, ScheduleManagementFailure> =>
-        Effect.suspend(() =>
-          Effect.gen(function* () {
-            const record = yield* store.get(key);
-
-            if (record === null) return yield* notFound(key);
-            if (record.configurationRevision !== expectedRevision) {
-              return yield* ScheduleConflict.make({ reason: "revision", key });
-            }
-            if (operation === "resume" && record.state === "active") return record;
-            const nowMillis = yield* currentMillis;
-
-            const nextAtMillis =
-              operation === "resume"
-                ? yield* Effect.fromResult(
-                    scheduleResumeCursor(
-                      record.configuration.timing,
-                      record.nextAtMillis,
-                      nowMillis,
-                    ),
-                  )
-                : operation === "cancel"
-                  ? null
-                  : record.nextAtMillis;
-
-            const skippedRange =
-              operation === "resume" &&
-              record.configuration.timing._tag !== "At" &&
-              record.nextAtMillis !== null &&
-              nextAtMillis !== null &&
-              nextAtMillis > record.nextAtMillis
-                ? { fromMillis: record.nextAtMillis, toMillis: nextAtMillis }
-                : null;
-
-            return yield* store
-              .change(
-                key,
-                {
-                  _tag: "Control",
-                  expectedRevision,
-                  expectedVersion: record.version,
-                  action: operation,
-                  nextAtMillis,
-                  nowMillis,
-                  skippedRange,
-                },
-                limits.maxSchedulesPerOwner,
-              )
-              .pipe(
-                Effect.catchTag("ScheduleConflict", (error) =>
-                  error.reason === "revision" ? attempt() : Effect.fail(error),
-                ),
-              );
-          }),
-        );
+    const nowMillis = yield* currentMillis;
 
-      const changed = yield* attempt();
+    return { items: page.items.map((record) => asSnapshot(record, nowMillis)), next: page.next };
+  });
 
-      yield* wake.notify;
+  const control = Effect.fnUntraced(function* (
+    operation: "pause" | "resume" | "cancel",
+    scope: ScheduleScope,
+    scheduleId: ScheduleId,
+    expectedRevision: number,
+  ): Effect.fn.Return<ScheduleSnapshot, ScheduleManagementFailure> {
+    yield* authorizer.manage({ operation, scope, scheduleId });
+    const key = keyOf(scope, scheduleId);
+
+    const attempt = (): Effect.Effect<ScheduleRecord, ScheduleManagementFailure> =>
+      Effect.suspend(() =>
+        Effect.gen(function* () {
+          const record = yield* store.get(key);
+
+          if (record === null) return yield* notFound(key);
+          if (record.configurationRevision !== expectedRevision) {
+            return yield* ScheduleConflict.make({ reason: "revision", key });
+          }
+          if (operation === "resume" && record.state === "active") return record;
+          const nowMillis = yield* currentMillis;
+
+          const nextAtMillis =
+            operation === "resume"
+              ? yield* Effect.fromResult(
+                  scheduleResumeCursor(record.configuration.timing, record.nextAtMillis, nowMillis),
+                )
+              : operation === "cancel"
+                ? null
+                : record.nextAtMillis;
+
+          const skippedRange =
+            operation === "resume" &&
+            record.configuration.timing._tag !== "At" &&
+            record.nextAtMillis !== null &&
+            nextAtMillis !== null &&
+            nextAtMillis > record.nextAtMillis
+              ? { fromMillis: record.nextAtMillis, toMillis: nextAtMillis }
+              : null;
+
+          return yield* store
+            .change(
+              key,
+              {
+                _tag: "Control",
+                expectedRevision,
+                expectedVersion: record.version,
+                action: operation,
+                nextAtMillis,
+                nowMillis,
+                skippedRange,
+              },
+              limits.maxSchedulesPerOwner,
+            )
+            .pipe(
+              Effect.catchTag("ScheduleConflict", (error) =>
+                error.reason === "revision" ? attempt() : Effect.fail(error),
+              ),
+            );
+        }),
+      );
 
-      return asSnapshot(changed, yield* currentMillis);
-    });
+    const changed = yield* attempt();
 
-    const recover = Effect.fn("Scheduling.recover")(function* (
-      scope: ScheduleScope,
-      scheduleId: ScheduleId,
-      expectedRevision: number,
-      expectedGeneration: number,
-    ) {
-      yield* authorizer.manage({ operation: "recover", scope, scheduleId });
-      const key = keyOf(scope, scheduleId);
-      const record = yield* store.get(key);
-
-      if (record === null) return yield* notFound(key);
-      if (record.configurationRevision !== expectedRevision)
-        return yield* ScheduleConflict.make({ reason: "revision", key });
-      const time = yield* currentMillis;
-
-      if (record.pending === null) return asSnapshot(record, time);
-
-      const recovered = yield* store.change(key, {
-        _tag: "Recover",
-        expectedGeneration,
-        expectedRevision,
-        occurrenceId: record.pending.envelope.occurrenceId,
-        nowMillis: time,
-      });
+    yield* wake.notify;
 
-      yield* wake.notify;
+    return asSnapshot(changed, yield* currentMillis);
+  });
 
-      return asSnapshot(recovered, time);
+  const recover = Effect.fn("Scheduling.recover")(function* (
+    scope: ScheduleScope,
+    scheduleId: ScheduleId,
+    expectedRevision: number,
+    expectedGeneration: number,
+  ) {
+    yield* authorizer.manage({ operation: "recover", scope, scheduleId });
+    const key = keyOf(scope, scheduleId);
+    const record = yield* store.get(key);
+
+    if (record === null) return yield* notFound(key);
+    if (record.configurationRevision !== expectedRevision)
+      return yield* ScheduleConflict.make({ reason: "revision", key });
+    const time = yield* currentMillis;
+
+    if (record.pending === null) return asSnapshot(record, time);
+
+    const recovered = yield* store.change(key, {
+      _tag: "Recover",
+      expectedGeneration,
+      expectedRevision,
+      occurrenceId: record.pending.envelope.occurrenceId,
+      nowMillis: time,
     });
 
-    return Scheduling.of({
-      recover,
-      create,
-      update,
-      get,
-      list,
-      pause: (scope, id, revision) => control("pause", scope, id, revision),
-      resume: (scope, id, revision) => control("resume", scope, id, revision),
-      cancel: (scope, id, revision) => control("cancel", scope, id, revision),
-    });
+    yield* wake.notify;
+
+    return asSnapshot(recovered, time);
   });
 
-const makeDriver = (limits: SchedulingLimits) =>
-  Effect.gen(function* () {
-    const store = yield* ScheduleStore;
-    const authorizer = yield* ScheduleAuthorizer;
-    const admission = yield* ScheduledInputAdmission;
-    const failpoint = yield* ScheduleFailpoint;
-    const crypto = yield* Crypto.Crypto;
-    const admissionSemaphore = yield* Semaphore.make(limits.admissionConcurrency);
-
-    const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
-      Effect.provideService(effect, Crypto.Crypto, crypto);
-
-    const retry = Effect.fnUntraced(function* (
-      key: ScheduleKey,
-      record: ScheduleRecord,
-      reason: ScheduleRetryReason,
-      nowMillis: number,
-    ) {
-      if (record.pending === null) return record;
-      const current = record.pending.retry;
+  return Scheduling.of({
+    recover,
+    create,
+    update,
+    get,
+    list,
+    pause: (scope, id, revision) => control("pause", scope, id, revision),
+    resume: (scope, id, revision) => control("resume", scope, id, revision),
+    cancel: (scope, id, revision) => control("cancel", scope, id, revision),
+  });
+});
 
-      const delay = Math.min(
-        limits.retryBaseMillis * 2 ** Math.min(current.attempts, 52),
-        limits.retryMaxMillis,
-      );
+const makeDriver = Effect.fnUntraced(function* (limits: SchedulingLimits) {
+  const store = yield* ScheduleStore;
+  const authorizer = yield* ScheduleAuthorizer;
+  const admission = yield* ScheduledInputAdmission;
+  const failpoint = yield* ScheduleFailpoint;
+  const crypto = yield* Crypto.Crypto;
+  const admissionSemaphore = yield* Semaphore.make(limits.admissionConcurrency);
+
+  const withCrypto = <A, E>(effect: Effect.Effect<A, E, Crypto.Crypto>) =>
+    Effect.provideService(effect, Crypto.Crypto, crypto);
+
+  const retry = Effect.fnUntraced(function* (
+    key: ScheduleKey,
+    record: ScheduleRecord,
+    reason: ScheduleRetryReason,
+    nowMillis: number,
+  ) {
+    if (record.pending === null) return record;
+    const current = record.pending.retry;
+
+    const delay = Math.min(
+      limits.retryBaseMillis * 2 ** Math.min(current.attempts, 52),
+      limits.retryMaxMillis,
+    );
 
-      return yield* store.change(key, {
-        _tag: "Retry",
-        occurrenceId: record.pending.envelope.occurrenceId,
-        retry: {
-          generation: current.generation,
-          attempts: current.attempts + 1,
-          automaticAttempts: current.automaticAttempts + 1,
-          parked: current.automaticAttempts + 1 >= (limits.maxAutomaticAttempts ?? 8),
-          nextAttemptAtMillis: Math.min(nowMillis + delay, 8_640_000_000_000_000),
-          lastAttemptAtMillis: nowMillis,
-          lastFailure: reason,
-        },
-        nowMillis,
-      });
+    return yield* store.change(key, {
+      _tag: "Retry",
+      occurrenceId: record.pending.envelope.occurrenceId,
+      retry: {
+        generation: current.generation,
+        attempts: current.attempts + 1,
+        automaticAttempts: current.automaticAttempts + 1,
+        parked: current.automaticAttempts + 1 >= (limits.maxAutomaticAttempts ?? 8),
+        nextAttemptAtMillis: Math.min(nowMillis + delay, 8_640_000_000_000_000),
+        lastAttemptAtMillis: nowMillis,
+        lastFailure: reason,
+      },
+      nowMillis,
     });
+  });
 
-    const verifyPending = Effect.fnUntraced(function* (key: ScheduleKey, record: ScheduleRecord) {
-      const pending = record.pending;
+  const verifyPending = Effect.fnUntraced(function* (key: ScheduleKey, record: ScheduleRecord) {
+    const pending = record.pending;
 
-      if (pending === null) return;
-      const envelope = pending.envelope;
+    if (pending === null) return;
+    const envelope = pending.envelope;
 
-      const occurrenceId = yield* withCrypto(
-        digestJson({
-          schemaVersion: 1,
-          owner: envelope.owner,
-          scheduleId: envelope.scheduleId,
-          configurationRevision: envelope.configurationRevision,
-          intendedAtMillis: envelope.intendedAtMillis,
-        }),
-      ).pipe(Effect.mapError(() => corrupt("process")));
-
-      const usesCurrentConfiguration =
-        envelope.configurationRevision === record.configurationRevision;
+    const occurrenceId = yield* withCrypto(
+      digestJson({
+        schemaVersion: 1,
+        owner: envelope.owner,
+        scheduleId: envelope.scheduleId,
+        configurationRevision: envelope.configurationRevision,
+        intendedAtMillis: envelope.intendedAtMillis,
+      }),
+    ).pipe(Effect.mapError(() => corrupt("process")));
 
-      const expectedThreadId = usesCurrentConfiguration
-        ? record.configuration.destination._tag === "ExistingThread"
-          ? record.configuration.destination.threadId
-          : Schema.decodeSync(ThreadId)(`schedule-thread:${envelope.occurrenceId}`)
-        : null;
+    const usesCurrentConfiguration =
+      envelope.configurationRevision === record.configurationRevision;
 
-      const expectedAdmissionKey = Schema.decodeSync(IdempotencyKey)(
-        `schedule-occurrence:${envelope.occurrenceId}`,
-      );
+    const expectedThreadId = usesCurrentConfiguration
+      ? record.configuration.destination._tag === "ExistingThread"
+        ? record.configuration.destination.threadId
+        : Schema.decodeSync(ThreadId)(`schedule-thread:${envelope.occurrenceId}`)
+      : null;
 
-      const digest = yield* withCrypto(digestJson(envelope.input)).pipe(
-        Effect.mapError(() => corrupt("process")),
-      );
+    const expectedAdmissionKey = Schema.decodeSync(IdempotencyKey)(
+      `schedule-occurrence:${envelope.occurrenceId}`,
+    );
 
-      if (
-        envelope.schemaVersion !== 1 ||
-        envelope.owner.tenantId !== key.owner.tenantId ||
-        envelope.owner.ownerId !== key.owner.ownerId ||
-        envelope.scheduleId !== key.scheduleId ||
-        envelope.configurationRevision > record.configurationRevision ||
-        envelope.occurrenceId !== occurrenceId ||
-        (usesCurrentConfiguration &&
-          (envelope.deliveryPrincipal !== record.configuration.deliveryPrincipal ||
-            envelope.agentId !== record.configuration.agentId ||
-            !equivalentDefinitions(envelope.definitions, record.configuration.definitions) ||
-            !equivalentInput(envelope.input, record.configuration.input) ||
-            envelope.inputDigest !== record.configuration.inputDigest)) ||
-        envelope.inputDigest !== digest ||
-        (expectedThreadId !== null && envelope.threadId !== expectedThreadId) ||
-        envelope.admissionKey !== expectedAdmissionKey
-      ) {
-        return yield* corrupt("process");
-      }
-    });
+    const digest = yield* withCrypto(digestJson(envelope.input)).pipe(
+      Effect.mapError(() => corrupt("process")),
+    );
 
-    const deliverPending = Effect.fnUntraced(function* (
-      key: ScheduleKey,
-      record: ScheduleRecord,
-      nowMillis: number,
+    if (
+      envelope.schemaVersion !== 1 ||
+      envelope.owner.tenantId !== key.owner.tenantId ||
+      envelope.owner.ownerId !== key.owner.ownerId ||
+      envelope.scheduleId !== key.scheduleId ||
+      envelope.configurationRevision > record.configurationRevision ||
+      envelope.occurrenceId !== occurrenceId ||
+      (usesCurrentConfiguration &&
+        (envelope.deliveryPrincipal !== record.configuration.deliveryPrincipal ||
+          envelope.agentId !== record.configuration.agentId ||
+          !equivalentDefinitions(envelope.definitions, record.configuration.definitions) ||
+          !equivalentInput(envelope.input, record.configuration.input) ||
+          envelope.inputDigest !== record.configuration.inputDigest)) ||
+      envelope.inputDigest !== digest ||
+      (expectedThreadId !== null && envelope.threadId !== expectedThreadId) ||
+      envelope.admissionKey !== expectedAdmissionKey
     ) {
-      if (
-        record.pending === null ||
-        record.pending.retry.parked === true ||
-        record.pending.retry.nextAttemptAtMillis > nowMillis
-      ) {
-        return record;
-      }
-      yield* verifyPending(key, record);
-      const envelope = record.pending.envelope;
+      return yield* corrupt("process");
+    }
+  });
 
-      const outcome = yield* admissionSemaphore.withPermit(
-        admitPreparedInput(admission.submit(envelope), limits.admissionTimeoutMillis).pipe(
-          Effect.tap((outcome) =>
-            outcome._tag === "Receipt" ? failpoint.hit("schedule:admission:after") : Effect.void,
-          ),
+  const deliverPending = Effect.fnUntraced(function* (
+    key: ScheduleKey,
+    record: ScheduleRecord,
+    nowMillis: number,
+  ) {
+    if (
+      record.pending === null ||
+      record.pending.retry.parked === true ||
+      record.pending.retry.nextAttemptAtMillis > nowMillis
+    ) {
+      return record;
+    }
+    yield* verifyPending(key, record);
+    const envelope = record.pending.envelope;
+
+    const outcome = yield* admissionSemaphore.withPermit(
+      admitPreparedInput(admission.submit(envelope), limits.admissionTimeoutMillis).pipe(
+        Effect.tap((outcome) =>
+          outcome._tag === "Receipt" ? failpoint.hit("schedule:admission:after") : Effect.void,
         ),
-      );
-
-      const completedAtMillis = yield* currentMillis;
+      ),
+    );
 
-      if (outcome._tag === "Receipt") {
-        if (outcome.receipt.threadId !== envelope.threadId) {
-          return yield* corrupt("admission");
-        }
+    const completedAtMillis = yield* currentMillis;
 
-        return yield* store
-          .change(key, {
-            _tag: "Complete",
-            occurrenceId: envelope.occurrenceId,
-            receipt: outcome.receipt,
-            nowMillis: completedAtMillis,
-          })
-          .pipe(
-            Effect.catchTag("ScheduleStorageError", (error) =>
-              error.reason === "unavailable"
-                ? retry(key, record, "storage", completedAtMillis)
-                : Effect.fail(error),
-            ),
-          );
+    if (outcome._tag === "Receipt") {
+      if (outcome.receipt.threadId !== envelope.threadId) {
+        return yield* corrupt("admission");
       }
-      if (outcome._tag === "Refused") {
-        const refusal: ScheduleRefusal = {
-          atMillis: completedAtMillis,
-          intendedAtMillis: envelope.intendedAtMillis,
+
+      return yield* store
+        .change(key, {
+          _tag: "Complete",
           occurrenceId: envelope.occurrenceId,
-          phase: "admission",
-          code: outcome.error.code,
-        };
-
-        return yield* store
-          .change(key, {
-            _tag: "Refuse",
-            occurrenceId: envelope.occurrenceId,
-            refusal,
-            nowMillis: completedAtMillis,
-          })
-          .pipe(
-            Effect.catchTag("ScheduleStorageError", (error) =>
-              error.reason === "unavailable"
-                ? retry(key, record, "storage", completedAtMillis)
-                : Effect.fail(error),
-            ),
-          );
-      }
+          receipt: outcome.receipt,
+          nowMillis: completedAtMillis,
+        })
+        .pipe(
+          Effect.catchTag("ScheduleStorageError", (error) =>
+            error.reason === "unavailable"
+              ? retry(key, record, "storage", completedAtMillis)
+              : Effect.fail(error),
+          ),
+        );
+    }
+    if (outcome._tag === "Refused") {
+      const refusal: ScheduleRefusal = {
+        atMillis: completedAtMillis,
+        intendedAtMillis: envelope.intendedAtMillis,
+        occurrenceId: envelope.occurrenceId,
+        phase: "admission",
+        code: outcome.error.code,
+      };
 
-      return yield* retry(key, record, outcome.reason, completedAtMillis);
-    });
+      return yield* store
+        .change(key, {
+          _tag: "Refuse",
+          occurrenceId: envelope.occurrenceId,
+          refusal,
+          nowMillis: completedAtMillis,
+        })
+        .pipe(
+          Effect.catchTag("ScheduleStorageError", (error) =>
+            error.reason === "unavailable"
+              ? retry(key, record, "storage", completedAtMillis)
+              : Effect.fail(error),
+          ),
+        );
+    }
 
-    const processRecord = Effect.fnUntraced(function* (
-      key: ScheduleKey,
-      initial: ScheduleRecord,
-      nowMillis: number,
-    ): Effect.fn.Return<ScheduleRecord, ScheduleProcessFailure> {
-      if (initial.pending !== null) return yield* deliverPending(key, initial, nowMillis);
-      if (
-        initial.state !== "active" ||
-        initial.nextAtMillis === null ||
-        initial.nextAtMillis > nowMillis
-      ) {
-        return initial;
-      }
+    return yield* retry(key, record, outcome.reason, completedAtMillis);
+  });
 
-      const currentInputDigest = yield* withCrypto(digestJson(initial.configuration.input)).pipe(
-        Effect.mapError(() =>
-          ScheduleStorageError.make({ operation: "prepare", reason: "unavailable" }),
-        ),
-      );
+  const processRecord = Effect.fnUntraced(function* (
+    key: ScheduleKey,
+    initial: ScheduleRecord,
+    nowMillis: number,
+  ): Effect.fn.Return<ScheduleRecord, ScheduleProcessFailure> {
+    if (initial.pending !== null) return yield* deliverPending(key, initial, nowMillis);
+    if (
+      initial.state !== "active" ||
+      initial.nextAtMillis === null ||
+      initial.nextAtMillis > nowMillis
+    ) {
+      return initial;
+    }
 
-      if (currentInputDigest !== initial.configuration.inputDigest) {
-        return yield* corrupt("prepare");
-      }
+    const currentInputDigest = yield* withCrypto(digestJson(initial.configuration.input)).pipe(
+      Effect.mapError(() =>
+        ScheduleStorageError.make({ operation: "prepare", reason: "unavailable" }),
+      ),
+    );
 
-      const due = yield* Effect.fromResult(
-        scheduleDueOccurrence(initial.configuration.timing, initial.nextAtMillis, nowMillis),
-      );
+    if (currentInputDigest !== initial.configuration.inputDigest) {
+      return yield* corrupt("prepare");
+    }
 
-      if (due === null) return initial;
+    const due = yield* Effect.fromResult(
+      scheduleDueOccurrence(initial.configuration.timing, initial.nextAtMillis, nowMillis),
+    );
 
-      const occurrenceId = yield* withCrypto(
-        digestJson({
-          schemaVersion: 1,
-          owner: initial.owner,
-          scheduleId: initial.scheduleId,
-          configurationRevision: initial.configurationRevision,
-          intendedAtMillis: due.intendedAtMillis,
-        }),
-      ).pipe(Effect.mapError(() => corrupt("prepare")));
+    if (due === null) return initial;
 
-      const occurrence = {
-        key,
+    const occurrenceId = yield* withCrypto(
+      digestJson({
+        schemaVersion: 1,
+        owner: initial.owner,
+        scheduleId: initial.scheduleId,
         configurationRevision: initial.configurationRevision,
-        configuration: initial.configuration,
         intendedAtMillis: due.intendedAtMillis,
-        occurrenceId,
-      };
+      }),
+    ).pipe(Effect.mapError(() => corrupt("prepare")));
 
-      const authorization = yield* authorizer.prepare(occurrence).pipe(Effect.result);
-
-      if (Result.isFailure(authorization)) {
-        if (authorization.failure._tag === "ScheduleStorageError") {
-          return yield* authorization.failure;
-        }
-
-        return yield* store.change(key, {
-          _tag: "DenyPreparation",
-          expectedRevision: initial.configurationRevision,
-          expectedCursor: initial.nextAtMillis,
-          refusal: {
-            atMillis: nowMillis,
-            intendedAtMillis: due.intendedAtMillis,
-            occurrenceId,
-            phase: "preparation",
-            code: authorization.failure.code,
-          },
-          nowMillis,
-        });
-      }
+    const occurrence = {
+      key,
+      configurationRevision: initial.configurationRevision,
+      configuration: initial.configuration,
+      intendedAtMillis: due.intendedAtMillis,
+      occurrenceId,
+    };
 
-      const threadId =
-        initial.configuration.destination._tag === "ExistingThread"
-          ? initial.configuration.destination.threadId
-          : Schema.decodeSync(ThreadId)(`schedule-thread:${occurrenceId}`);
+    const authorization = yield* authorizer.prepare(occurrence).pipe(Effect.result);
 
-      const admissionKey = Schema.decodeSync(IdempotencyKey)(`schedule-occurrence:${occurrenceId}`);
+    if (Result.isFailure(authorization)) {
+      if (authorization.failure._tag === "ScheduleStorageError") {
+        return yield* authorization.failure;
+      }
 
-      const prepared = yield* store.change(key, {
-        _tag: "Prepare",
+      return yield* store.change(key, {
+        _tag: "DenyPreparation",
         expectedRevision: initial.configurationRevision,
         expectedCursor: initial.nextAtMillis,
-        envelope: {
-          schemaVersion: 1,
-          owner: initial.owner,
-          scheduleId: initial.scheduleId,
-          configurationRevision: initial.configurationRevision,
+        refusal: {
+          atMillis: nowMillis,
           intendedAtMillis: due.intendedAtMillis,
-          preparedAtMillis: nowMillis,
           occurrenceId,
-          threadId,
-          deliveryPrincipal: initial.configuration.deliveryPrincipal,
-          ...(initial.configuration.admissionGroup === undefined
-            ? {}
-            : { admissionGroup: initial.configuration.admissionGroup }),
-          ...(initial.configuration.admissionFence === undefined
-            ? {}
-            : { admissionFence: initial.configuration.admissionFence }),
-          agentId: initial.configuration.agentId,
-          definitions: initial.configuration.definitions,
-          input: initial.configuration.input,
-          inputDigest: initial.configuration.inputDigest,
-          admissionKey,
-          authorization: authorization.success,
+          phase: "preparation",
+          code: authorization.failure.code,
         },
-        nextAtMillis: due.nextAtMillis,
-        skippedRange: due.skippedRange,
         nowMillis,
       });
+    }
+
+    const threadId =
+      initial.configuration.destination._tag === "ExistingThread"
+        ? initial.configuration.destination.threadId
+        : Schema.decodeSync(ThreadId)(`schedule-thread:${occurrenceId}`);
 
-      return yield* deliverPending(key, prepared, nowMillis);
+    const admissionKey = Schema.decodeSync(IdempotencyKey)(`schedule-occurrence:${occurrenceId}`);
+
+    const prepared = yield* store.change(key, {
+      _tag: "Prepare",
+      expectedRevision: initial.configurationRevision,
+      expectedCursor: initial.nextAtMillis,
+      envelope: {
+        schemaVersion: 1,
+        owner: initial.owner,
+        scheduleId: initial.scheduleId,
+        configurationRevision: initial.configurationRevision,
+        intendedAtMillis: due.intendedAtMillis,
+        preparedAtMillis: nowMillis,
+        occurrenceId,
+        threadId,
+        deliveryPrincipal: initial.configuration.deliveryPrincipal,
+        ...(initial.configuration.admissionGroup === undefined
+          ? {}
+          : { admissionGroup: initial.configuration.admissionGroup }),
+        ...(initial.configuration.admissionFence === undefined
+          ? {}
+          : { admissionFence: initial.configuration.admissionFence }),
+        agentId: initial.configuration.agentId,
+        definitions: initial.configuration.definitions,
+        input: initial.configuration.input,
+        inputDigest: initial.configuration.inputDigest,
+        admissionKey,
+        authorization: authorization.success,
+      },
+      nextAtMillis: due.nextAtMillis,
+      skippedRange: due.skippedRange,
+      nowMillis,
     });
 
-    const process = Effect.fnUntraced(function* (key: ScheduleKey) {
-      const nowMillis = yield* currentMillis;
-      const record = yield* store.get(key);
+    return yield* deliverPending(key, prepared, nowMillis);
+  });
+
+  const process = Effect.fnUntraced(function* (key: ScheduleKey) {
+    const nowMillis = yield* currentMillis;
+    const record = yield* store.get(key);
 
-      if (record === null) return yield* notFound(key);
+    if (record === null) return yield* notFound(key);
 
-      const processed = yield* processRecord(key, record, nowMillis).pipe(
-        Effect.catchTag("ScheduleConflict", () =>
-          store
-            .get(key)
-            .pipe(
-              Effect.flatMap((current) =>
-                current === null
-                  ? Effect.fail(notFound(key))
-                  : processRecord(key, current, nowMillis),
-              ),
+    const processed = yield* processRecord(key, record, nowMillis).pipe(
+      Effect.catchTag("ScheduleConflict", () =>
+        store
+          .get(key)
+          .pipe(
+            Effect.flatMap((current) =>
+              current === null
+                ? Effect.fail(notFound(key))
+                : processRecord(key, current, nowMillis),
             ),
-        ),
-      );
+          ),
+      ),
+    );
 
-      return processed;
-    });
+    return processed;
+  });
 
-    const runDue = Effect.fnUntraced(function* (owner?: ScheduleOwner) {
-      const nowMillis = yield* currentMillis;
-      let after: ScheduleDueCursor | undefined;
-      let processed = 0;
-      let failed = 0;
-
-      while (true) {
-        const due = yield* store.due(nowMillis, limits.dueBatchSize, owner, after);
-
-        if (due.length === 0) break;
-        yield* Effect.forEach(
-          due,
-          (key) =>
-            process(key).pipe(
-              Effect.matchCauseEffect({
-                onSuccess: () =>
-                  Effect.sync(() => {
-                    processed += 1;
-                  }),
-                onFailure: (cause) =>
-                  Cause.hasInterrupts(cause)
-                    ? Effect.interrupt
-                    : Effect.gen(function* () {
-                        failed += 1;
-                        yield* Effect.logWarning("Schedule processing failed").pipe(
-                          Effect.annotateLogs({
-                            failureTag: Option.match(Cause.findErrorOption(cause), {
-                              onNone: () => "Defect",
-                              onSome: (error) => error._tag,
-                            }),
+  const runDue = Effect.fnUntraced(function* (owner?: ScheduleOwner) {
+    const nowMillis = yield* currentMillis;
+    let after: ScheduleDueCursor | undefined;
+    let processed = 0;
+    let failed = 0;
+
+    while (true) {
+      const due = yield* store.due(nowMillis, limits.dueBatchSize, owner, after);
+
+      if (due.length === 0) break;
+      yield* Effect.forEach(
+        due,
+        (key) =>
+          process(key).pipe(
+            Effect.matchCauseEffect({
+              onSuccess: () =>
+                Effect.sync(() => {
+                  processed += 1;
+                }),
+              onFailure: (cause) =>
+                Cause.hasInterrupts(cause)
+                  ? Effect.interrupt
+                  : Effect.gen(function* () {
+                      failed += 1;
+                      yield* Effect.logWarning("Schedule processing failed").pipe(
+                        Effect.annotateLogs({
+                          failureTag: Option.match(Cause.findErrorOption(cause), {
+                            onNone: () => "Defect",
+                            onSome: (error) => error._tag,
                           }),
-                        );
-                      }),
-              }),
-            ),
-          { concurrency: limits.admissionConcurrency },
-        );
-        after = due.at(-1);
-        if (due.length < limits.dueBatchSize) break;
-      }
-
-      return { processed, failed };
-    });
+                        }),
+                      );
+                    }),
+            }),
+          ),
+        { concurrency: limits.admissionConcurrency },
+      );
+      after = due.at(-1);
+      if (due.length < limits.dueBatchSize) break;
+    }
 
-    return ScheduleDriver.of({ process, runDue });
+    return { processed, failed };
   });
 
+  return ScheduleDriver.of({ process, runDue });
+});
+
 const corrupt = (operation: string): ScheduleStorageError =>
   ScheduleStorageError.make({ operation, reason: "corrupt" });