@smthrs/triggers 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/Scheduler.js

@@ -0,0 +1,647 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Scheduler_exports = {};
+__export(Scheduler_exports, {
+  Runner: () => Runner,
+  Scheduler: () => Scheduler,
+  defaultConcurrency: () => defaultConcurrency,
+  defaultFireRetention: () => defaultFireRetention,
+  defaultHost: () => defaultHost,
+  durationBoundaries: () => durationBoundaries,
+  idempotencyKey: () => idempotencyKey,
+  layer: () => layer,
+  layerControlRunner: () => layerControlRunner,
+  layerNoop: () => layerNoop,
+  layerNoopRunner: () => layerNoopRunner,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  makeNoopRunner: () => makeNoopRunner,
+  makeRunner: () => makeRunner,
+  parkedAttempts: () => parkedAttempts
+});
+module.exports = __toCommonJS(Scheduler_exports);
+var Control = __toESM(require("@smthrs/control/Control"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Duration = __toESM(require("effect/Duration"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Fiber = __toESM(require("effect/Fiber"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Metric = __toESM(require("effect/Metric"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Ref = __toESM(require("effect/Ref"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Semaphore = __toESM(require("effect/Semaphore"), 1);
+var ActiveRuns = __toESM(require("./internal/ActiveRuns.js"), 1);
+var DueOccurrences = __toESM(require("./internal/DueOccurrences.js"), 1);
+var import_TriggerError = require("./TriggerError.js");
+var import_TriggerStore = require("./TriggerStore.js");
+class Runner extends Context.Service()("flows/triggers/Scheduler/Runner") {
+}
+const makeRunner = (implementation) => Runner.of(implementation);
+const makeNoopRunner = (overrides = {}) => makeRunner({
+  start: (input) => Effect.succeed(input.idempotencyKey),
+  inspect: () => Effect.succeed("completed"),
+  cancel: () => Effect.void,
+  ...overrides
+});
+const layerNoopRunner = (overrides = {}) => Layer.succeed(Runner)(makeNoopRunner(overrides));
+const runnerError = (message, cause) => new import_TriggerError.TriggerError({
+  code: "runner",
+  message,
+  ...cause === void 0 ? {} : { cause }
+});
+const translateRunnerFailure = (effect, message) => effect.pipe(
+  Effect.mapError((error) => error instanceof import_TriggerError.TriggerError ? error : runnerError(message, error)),
+  Effect.catchDefect((defect) => Effect.fail(runnerError(message, defect)))
+);
+const invalidOption = (field, requirement) => new import_TriggerError.TriggerError({
+  code: "invalid_options",
+  message: `${field} must be ${requirement}`,
+  path: field
+});
+const duration = (input, field) => Option.match(Duration.fromInput(input), {
+  onNone: () => Effect.fail(invalidOption(field, "a valid Effect duration")),
+  onSome: (value) => (
+    // Zero polls a CPU-tight loop and an infinite interval never completes,
+    // and `Duration.fromInput` accepts both.
+    Duration.isFinite(value) && Duration.toMillis(value) > 0 ? Effect.succeed(value) : Effect.fail(invalidOption(field, "a finite positive duration"))
+  )
+});
+const stoppedMessage = (runId, state) => {
+  switch (state) {
+    case "failed":
+      return `Run ${runId} failed`;
+    case "cancelled":
+      return `Run ${runId} was cancelled`;
+    case "missing":
+      return `Run ${runId} is unknown to the runner`;
+  }
+};
+const runIdFromReceipt = (receipt) => {
+  switch (receipt._tag) {
+    case "Accepted":
+    case "AlreadyApplied":
+      return receipt.runId === void 0 ? Effect.fail(runnerError(`Control ${receipt._tag} receipt did not include a run id`)) : Effect.succeed(receipt.runId);
+    case "Terminal":
+      return Effect.succeed(receipt.runId);
+    case "Conflict":
+      return Effect.fail(runnerError(`Control rejected the scheduled run: ${receipt.message}`));
+  }
+};
+const parkedAttempts = 8;
+const runApprovedPlan = (control, plan, key, attempt) => control.run({
+  _tag: "Plan",
+  planId: plan.planId,
+  digest: plan.digest,
+  envelope: plan.envelope,
+  idempotencyKey: key
+}).pipe(
+  Effect.mapError((error) => runnerError("Control could not launch the scheduled run", error)),
+  Effect.flatMap((receipt) => {
+    if (receipt._tag !== "Parked") return runIdFromReceipt(receipt);
+    if (attempt >= parkedAttempts) {
+      return Effect.fail(
+        runnerError(
+          `Control plan ${plan.planId} is still parked awaiting approval after ${attempt} attempts`
+        )
+      );
+    }
+    return Effect.logInfo(`A scheduled plan is parked awaiting approval, attempt ${attempt}`).pipe(
+      Effect.andThen(Effect.sleep(Duration.millis(1e3 * 2 ** (attempt - 1)))),
+      Effect.andThen(Effect.suspend(() => runApprovedPlan(control, plan, key, attempt + 1)))
+    );
+  })
+);
+const settledState = (status) => status === "cancelled" || status === "completed" || status === "failed" ? status : void 0;
+const layerControlRunner = Layer.effect(
+  Runner,
+  Effect.gen(function* () {
+    const control = yield* Control.Control;
+    return makeRunner({
+      start: (input) => translateRunnerFailure(
+        control.plan(input).pipe(
+          Effect.flatMap((plan) => runApprovedPlan(control, plan, input.idempotencyKey, 1))
+        ),
+        "Control could not launch the scheduled run"
+      ),
+      inspect: (runId) => translateRunnerFailure(
+        control.list({ _tag: "runs", filters: { runId }, limit: 1 }).pipe(
+          Effect.map((response) => {
+            const run = response._tag === "runs" ? response.items.find((candidate) => candidate.runId === runId) : void 0;
+            if (run === void 0) return "missing";
+            return settledState(run.status) ?? "active";
+          })
+        ),
+        `Control could not inspect run ${runId}`
+      ),
+      cancel: (runId) => translateRunnerFailure(
+        control.cancel({
+          runId,
+          idempotencyKey: `trigger-cancel:${runId}`
+        }).pipe(
+          Effect.flatMap((receipt) => {
+            switch (receipt._tag) {
+              case "Accepted":
+              case "AlreadyApplied":
+              case "Terminal":
+                return Effect.void;
+              case "Conflict":
+                return Effect.fail(runnerError(`Control refused scheduled cancellation: ${receipt.message}`));
+              case "Parked":
+                return Effect.fail(runnerError(`Control returned a Parked receipt for cancellation of run ${runId}`));
+            }
+          })
+        ),
+        `Control could not cancel run ${runId}`
+      )
+    });
+  })
+);
+const defaultHost = "local";
+const defaultConcurrency = 4;
+const defaultFireRetention = Duration.days(30);
+const pruneEvery = 60 * 60 * 1e3;
+const durationBoundaries = [10, 100, 1e3, 1e4, 6e4, 3e5];
+const firesRecorded = Metric.counter("smithers.triggers.fires");
+const tickDuration = Metric.histogram("smithers.triggers.tick_duration_ms", { boundaries: durationBoundaries });
+const launchDuration = Metric.histogram("smithers.triggers.launch_duration_ms", { boundaries: durationBoundaries });
+const timed = (histogram, effect) => Effect.gen(function* () {
+  const started = yield* Clock.currentTimeMillis;
+  return yield* effect.pipe(
+    Effect.ensuring(
+      Effect.flatMap(Clock.currentTimeMillis, (ended) => Metric.update(histogram, ended - started))
+    )
+  );
+});
+const deadline = (effect, limit, what) => Effect.timeoutOrElse(effect, {
+  duration: limit,
+  orElse: () => Effect.fail(
+    new import_TriggerError.TriggerError({
+      code: "runner_timeout",
+      message: `${what} did not answer within ${Duration.toMillis(limit)} ms`
+    })
+  )
+});
+class Scheduler extends Context.Service()("flows/triggers/Scheduler") {
+}
+const idempotencyKey = (triggerId, occurrence) => `${triggerId}:${new Date(occurrence).toISOString()}`;
+const attempted = (annotations, work, effect) => Effect.catchCause(Effect.as(effect, true), (cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.as(
+  Effect.annotateLogs(Effect.logWarning(`A trigger ${work} failed`, cause), annotations),
+  false
+));
+const isolate = (annotations, work, effect) => Effect.asVoid(attempted(annotations, work, effect));
+const make = (options = {}) => Effect.gen(function* () {
+  const parentScope = yield* Effect.scope;
+  const providedStore = yield* import_TriggerStore.TriggerStore;
+  const store = {
+    ...providedStore,
+    recordResult: (result) => providedStore.recordResult(result).pipe(
+      Effect.tap(() => Metric.update(firesRecorded.pipe(Metric.withAttributes({ outcome: result.outcome })), 1))
+    )
+  };
+  const active = yield* ActiveRuns.make;
+  const observedAt = yield* Ref.make(/* @__PURE__ */ new Map());
+  const semaphore = yield* Semaphore.make(1);
+  const runPollInterval = yield* duration(options.runPollInterval ?? "15 seconds", "runPollInterval");
+  const concurrency = options.concurrency ?? defaultConcurrency;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    return yield* Effect.fail(invalidOption("concurrency", "a positive integer"));
+  }
+  const startTimeout = yield* duration(options.startTimeout ?? "4 minutes", "startTimeout");
+  const inspectTimeout = yield* duration(options.inspectTimeout ?? "30 seconds", "inspectTimeout");
+  const cancelTimeout = yield* duration(options.cancelTimeout ?? "30 seconds", "cancelTimeout");
+  const fireRetention = yield* duration(options.fireRetention ?? defaultFireRetention, "fireRetention");
+  const lastPrunedAt = yield* Ref.make(void 0);
+  const provided = yield* Runner;
+  const runner = {
+    start: (input) => deadline(provided.start(input), startTimeout, `Runner.start for ${input.idempotencyKey}`),
+    inspect: (runId) => deadline(provided.inspect(runId), inspectTimeout, `Runner.inspect for run ${runId}`),
+    cancel: (runId) => deadline(provided.cancel(runId), cancelTimeout, `Runner.cancel for run ${runId}`)
+  };
+  const observe = (triggerId, occurrence) => Ref.update(observedAt, (current) => {
+    const existing = current.get(triggerId);
+    if (existing !== void 0 && existing >= occurrence) return current;
+    return new Map(current).set(triggerId, occurrence);
+  });
+  const inspectStored = (runId) => (0, import_TriggerStore.isReservation)(runId) ? Effect.succeed("active") : runner.inspect(runId);
+  const occurrenceOf = (triggerId, runId) => {
+    const reserved = (0, import_TriggerStore.reservationOccurrence)(runId);
+    if (reserved !== void 0) return Effect.succeed(reserved);
+    return store.activeOccurrence(triggerId, runId).pipe(
+      Effect.map((occurrence) => Option.isSome(occurrence) ? occurrence.value : Number.NEGATIVE_INFINITY)
+    );
+  };
+  const recordSettled = (triggerId, occurrence, runId, state) => state === "completed" ? store.recordResult({ triggerId, occurrence, outcome: "completed", runId }) : store.recordResult({ triggerId, occurrence, outcome: "failed", runId, error: stoppedMessage(runId, state) });
+  const settleRecovered = (triggerId, occurrence, runId, state) => Number.isFinite(occurrence) ? recordSettled(triggerId, occurrence, runId, state) : store.clearActive(triggerId, runId);
+  const storedActive = (triggerId, held) => held !== void 0 && held.activeRunId === void 0 ? Effect.succeed(Option.none()) : store.activeRun(triggerId);
+  const recoverStored = (trigger, runId) => Effect.gen(function* () {
+    const occurrence = yield* occurrenceOf(trigger.id, runId);
+    const state = yield* inspectStored(runId);
+    if (state !== "active") {
+      yield* settleRecovered(trigger.id, occurrence, runId, state);
+      return void 0;
+    }
+    const recovered = { occurrence, runId };
+    yield* active.take(trigger.id, recovered);
+    return recovered;
+  });
+  const resolveActive = (trigger, held) => Effect.gen(function* () {
+    const local = yield* active.get(trigger.id);
+    if (local !== void 0) {
+      if (local.fiber !== void 0) return local;
+      if (!(0, import_TriggerStore.isReservation)(local.runId)) {
+        const state = yield* inspectStored(local.runId);
+        if (state === "active") return local;
+        yield* settleRecovered(trigger.id, local.occurrence, local.runId, state);
+        yield* active.remove(trigger.id, local.occurrence);
+      } else {
+        const stored2 = yield* storedActive(trigger.id, held);
+        if (Option.isNone(stored2)) {
+          yield* active.remove(trigger.id, local.occurrence);
+          return void 0;
+        }
+        if (stored2.value === local.runId) return local;
+        yield* active.remove(trigger.id, local.occurrence);
+        return yield* recoverStored(trigger, stored2.value);
+      }
+    }
+    const stored = yield* storedActive(trigger.id, held);
+    if (Option.isNone(stored)) return void 0;
+    return yield* recoverStored(trigger, stored.value);
+  });
+  const recordFailed = (trigger, occurrence, error, runId) => store.recordResult({
+    triggerId: trigger.id,
+    occurrence,
+    outcome: "failed",
+    error: error.message,
+    runId
+  });
+  const inspectRun = (triggerId, runId) => Effect.gen(function* () {
+    for (let attempt = 0; ; attempt++) {
+      const inspected = yield* runner.inspect(runId).pipe(
+        Effect.map(Option.some),
+        Effect.catchCause(
+          (cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.logWarning("A trigger run inspection failed", cause).pipe(
+            Effect.annotateLogs({ triggerId, runId, attempt: String(attempt + 1) }),
+            Effect.as(Option.none())
+          )
+        )
+      );
+      if (Option.isSome(inspected)) return inspected;
+      if (attempt === 3) {
+        yield* Effect.logWarning("A trigger run monitor detached after inspection retries").pipe(
+          Effect.annotateLogs({ triggerId, runId })
+        );
+        return Option.none();
+      }
+      yield* Effect.sleep(Math.min(Duration.toMillis(runPollInterval) * 2 ** attempt, 6e4));
+    }
+  });
+  const launch = (trigger, occurrence, reservation, preserveBuffered) => Effect.gen(function* () {
+    yield* active.take(trigger.id, { occurrence, runId: reservation });
+    let runId;
+    let launchRecorded = false;
+    let completed = false;
+    const lifecycle = Effect.gen(function* () {
+      runId = yield* timed(
+        launchDuration,
+        runner.start({
+          flowId: trigger.flowId,
+          input: trigger.input,
+          idempotencyKey: idempotencyKey(trigger.id, occurrence)
+        })
+      ).pipe(
+        Effect.withSpan("Scheduler.launch", {
+          attributes: { triggerId: trigger.id, occurrence: new Date(occurrence).toISOString() }
+        })
+      );
+      const startedRunId = runId;
+      yield* active.update(trigger.id, occurrence, (entry) => ({ ...entry, runId: startedRunId }));
+      yield* store.recordResult({
+        triggerId: trigger.id,
+        occurrence,
+        outcome: "launched",
+        runId,
+        reservationId: reservation
+      });
+      launchRecorded = true;
+      let state;
+      while (true) {
+        const inspected = yield* inspectRun(trigger.id, runId);
+        if (Option.isNone(inspected)) return;
+        state = inspected.value;
+        if (state !== "active") break;
+        yield* Effect.sleep(runPollInterval);
+      }
+      yield* recordSettled(trigger.id, occurrence, runId, state);
+      completed = true;
+    }).pipe(
+      Effect.catch(
+        (error) => Effect.gen(function* () {
+          if (launchRecorded) {
+            yield* Effect.logWarning("A trigger run monitor could not persist completion", error).pipe(
+              Effect.annotateLogs({ triggerId: trigger.id, runId })
+            );
+            return;
+          }
+          if (error.code === "stale_owner" && runId !== void 0) {
+            yield* Effect.logWarning("A trigger launch lost its reservation", error).pipe(
+              Effect.annotateLogs({ triggerId: trigger.id, occurrence: String(occurrence) })
+            );
+            const losingRunId = runId;
+            yield* isolate(
+              { triggerId: trigger.id, runId },
+              "losing run reconciliation",
+              Effect.gen(function* () {
+                const held = yield* store.inspect(trigger.id);
+                if (held.activeRunId === losingRunId || held.activeRunId !== void 0 && (0, import_TriggerStore.reservationOccurrence)(held.activeRunId) === occurrence) return;
+                yield* runner.cancel(losingRunId);
+              })
+            ).pipe(Effect.ignore);
+            return;
+          }
+          if (preserveBuffered) {
+            yield* isolate(
+              { triggerId: trigger.id },
+              "buffered launch compensation",
+              store.restorePending({ triggerId: trigger.id, occurrence, reservationId: reservation })
+            ).pipe(Effect.ignore);
+          } else {
+            if (runId !== void 0 || error.code === "runner_timeout") {
+              yield* isolate(
+                { triggerId: trigger.id },
+                "launch compensation",
+                store.restorePending({
+                  triggerId: trigger.id,
+                  occurrence,
+                  reservationId: reservation
+                })
+              ).pipe(Effect.ignore);
+            } else {
+              yield* recordFailed(trigger, occurrence, error, reservation).pipe(Effect.ignore);
+            }
+          }
+          yield* Effect.logWarning("A trigger launch failed", error).pipe(
+            Effect.annotateLogs({ triggerId: trigger.id, occurrence: String(occurrence) })
+          );
+        })
+      ),
+      // Interrupting this fiber detaches the monitor; it never cancels the
+      // run. The run is durable and outlives this process, so a deploy or
+      // any other scope closure must leave it alone: the next incarnation
+      // re-attaches through `resolveActive`. Cancellation is a deliberate
+      // act and belongs to `cancelActive` alone.
+      Effect.ensuring(Effect.suspend(
+        () => launchRecorded && !completed ? active.update(trigger.id, occurrence, (entry) => ({ ...entry, fiber: void 0 })) : active.remove(trigger.id, occurrence)
+      ))
+    );
+    const fiber = yield* Effect.forkIn(
+      Effect.scoped(lifecycle).pipe(
+        Effect.onExit(
+          (exit) => exit._tag === "Failure" && !Cause.hasInterrupts(exit.cause) ? Effect.logWarning(
+            launchRecorded ? "A trigger run monitor failed" : "A trigger launch failed",
+            exit.cause
+          ).pipe(
+            Effect.annotateLogs({
+              triggerId: trigger.id,
+              occurrence: String(occurrence),
+              runId: runId ?? reservation
+            })
+          ) : Effect.void
+        )
+      ),
+      parentScope,
+      { startImmediately: true }
+    );
+    if (fiber.pollUnsafe() === void 0) {
+      yield* active.update(trigger.id, occurrence, (entry) => ({ ...entry, fiber }));
+    }
+  });
+  const cancelActive = (trigger, prior, replacementOccurrence, replacementReservation, queueReplacement) => Effect.gen(function* () {
+    if (!(0, import_TriggerStore.isReservation)(prior.runId)) {
+      yield* runner.cancel(prior.runId).pipe(
+        Effect.catch((error) => {
+          const restore = queueReplacement ? isolate(
+            { triggerId: trigger.id },
+            "supersede compensation",
+            store.restorePending({
+              triggerId: trigger.id,
+              occurrence: replacementOccurrence,
+              reservationId: replacementReservation
+            })
+          ) : Effect.void;
+          return restore.pipe(
+            Effect.andThen(Effect.fail(error))
+          );
+        })
+      );
+    }
+    if (Number.isFinite(prior.occurrence) && !(0, import_TriggerStore.isReservation)(prior.runId)) {
+      yield* store.recordResult({
+        triggerId: trigger.id,
+        occurrence: prior.occurrence,
+        outcome: "superseded",
+        runId: prior.runId
+      });
+    }
+    if (prior.fiber !== void 0) yield* Fiber.interrupt(prior.fiber);
+    yield* active.remove(trigger.id, prior.occurrence);
+  });
+  const dispatchClaimed = (trigger, occurrence, claim, resumeBuffered = false) => Effect.gen(function* () {
+    switch (claim.action) {
+      case "fire":
+        yield* launch(trigger, occurrence, claim.reservationId, resumeBuffered);
+        return;
+      case "skip":
+        yield* store.recordResult({
+          triggerId: trigger.id,
+          occurrence,
+          outcome: "skipped"
+        });
+        return;
+      case "buffer":
+        yield* store.recordResult({
+          triggerId: trigger.id,
+          occurrence,
+          outcome: "buffered"
+        });
+        return;
+      case "supersede": {
+        const superseded = claim.activeRunId;
+        if (superseded !== void 0) {
+          const local = yield* active.get(trigger.id);
+          yield* cancelActive(
+            trigger,
+            local !== void 0 && local.runId === superseded ? { ...local, runId: superseded } : {
+              occurrence: yield* occurrenceOf(trigger.id, superseded),
+              runId: superseded
+            },
+            occurrence,
+            claim.reservationId,
+            !resumeBuffered
+          );
+        }
+        yield* launch(trigger, occurrence, claim.reservationId, resumeBuffered);
+        return;
+      }
+    }
+  });
+  const claimOnce = (trigger, occurrence) => store.claimFire({
+    triggerId: trigger.id,
+    occurrence,
+    expectedRevision: trigger.revision
+  }).pipe(
+    Effect.flatMap((claim) => claim.claimed ? dispatchClaimed(trigger, occurrence, claim) : Effect.void)
+  );
+  const withRevisionRefresh = (trigger, claim) => claim(trigger).pipe(
+    Effect.catch(
+      (error) => error.code !== "revision_mismatch" ? Effect.fail(error) : store.get(trigger.id).pipe(
+        Effect.flatMap(
+          (refreshed) => Option.isNone(refreshed) || refreshed.value.revision === trigger.revision ? Effect.fail(error) : claim(refreshed.value)
+        )
+      )
+    )
+  );
+  const resumePending = (trigger, held) => (
+    // A listed row holding neither a buffered occurrence nor a run has
+    // nothing for `claimPending` to take: only expiring a reservation
+    // re-arms a pending occurrence, and there is no reservation to expire.
+    held !== void 0 && held.pendingAt === void 0 && held.activeRunId === void 0 ? Effect.void : withRevisionRefresh(trigger, (current) => store.claimPending({
+      triggerId: current.id,
+      expectedRevision: current.revision
+    }).pipe(
+      Effect.flatMap((pending) => {
+        if (Option.isNone(pending)) return Effect.void;
+        const occurrence = pending.value.occurrence;
+        const claim = pending.value.claim;
+        if (!claim.claimed) return Effect.void;
+        return dispatchClaimed(
+          current,
+          occurrence,
+          claim,
+          true
+        ).pipe(
+          Effect.onError(
+            () => isolate(
+              { triggerId: current.id },
+              "buffered launch compensation",
+              claim.action === "fire" || claim.action === "supersede" ? store.restorePending({ triggerId: current.id, occurrence, reservationId: claim.reservationId }) : store.setPending({ triggerId: current.id, occurrence })
+            ).pipe(Effect.ignore)
+          )
+        );
+      })
+    ))
+  );
+  const processTrigger = (trigger, held, refreshed = false) => Effect.gen(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const running = yield* resolveActive(trigger, held);
+    if (!trigger.enabled) return;
+    if (running === void 0 || trigger.overlap === "supersede") yield* resumePending(trigger, held);
+    const observed = (yield* Ref.get(observedAt)).get(trigger.id);
+    const due = yield* DueOccurrences.compute(trigger, now, observed);
+    let dispatched;
+    let interrupted = false;
+    let stale = false;
+    for (const occurrence of due.occurrences) {
+      const settledHere = yield* attempted(
+        { triggerId: trigger.id },
+        `dispatch of occurrence ${occurrence}`,
+        claimOnce(trigger, occurrence).pipe(
+          Effect.catch(
+            (error) => error.code === "revision_mismatch" ? Effect.sync(() => {
+              stale = true;
+            }) : Effect.fail(error)
+          )
+        )
+      );
+      if (stale) break;
+      if (settledHere && !interrupted) dispatched = occurrence;
+      if (!settledHere) interrupted = true;
+    }
+    if (stale) {
+      if (dispatched !== void 0) yield* observe(trigger.id, dispatched);
+      if (refreshed) return;
+      const current = yield* store.get(trigger.id);
+      if (Option.isNone(current) || current.value.revision === trigger.revision) return;
+      return yield* processTrigger(current.value, void 0, true);
+    }
+    if (!interrupted) return yield* observe(trigger.id, due.watermark);
+    if (dispatched !== void 0) yield* observe(trigger.id, dispatched);
+  }).pipe(Effect.withSpan("Scheduler.processTrigger", { attributes: { triggerId: trigger.id } }));
+  const host = options.host ?? defaultHost;
+  const runOnce = semaphore.withPermits(1)(
+    Effect.gen(function* () {
+      yield* isolate({ host }, "heartbeat", store.heartbeat(host));
+      const now = yield* Clock.currentTimeMillis;
+      const last = yield* Ref.get(lastPrunedAt);
+      if (last === void 0 || now - last >= pruneEvery) {
+        yield* Ref.set(lastPrunedAt, now);
+        yield* isolate(
+          { host },
+          "fire ledger prune",
+          Effect.asVoid(store.pruneFires({ olderThan: now - Duration.toMillis(fireRetention) }))
+        );
+      }
+      const listing = yield* store.list();
+      yield* Effect.forEach(
+        listing,
+        (row) => isolate(
+          { triggerId: row.triggerId },
+          "tick",
+          Result.isFailure(row.trigger) ? Effect.fail(row.trigger.failure) : processTrigger(row.trigger.success, row)
+        ),
+        { concurrency, discard: true }
+      );
+    }).pipe((tick) => timed(tickDuration, tick), Effect.withSpan("Scheduler.runOnce", { attributes: { host } }))
+  );
+  return Scheduler.of({ runOnce });
+});
+const makeNoop = () => Scheduler.of({ runOnce: Effect.void });
+const layer = (options = {}) => Layer.effect(
+  Scheduler,
+  Effect.gen(function* () {
+    const scheduler = yield* make(options);
+    const pollInterval = yield* duration(options.pollInterval ?? "1 minute", "pollInterval");
+    yield* Effect.forkScoped(
+      Effect.forever(
+        scheduler.runOnce.pipe(
+          Effect.catchCause(
+            (cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause) : Effect.logWarning("A trigger scheduler tick failed", cause)
+          ),
+          Effect.andThen(Effect.sleep(pollInterval))
+        )
+      )
+    );
+    return scheduler;
+  })
+);
+const layerNoop = Layer.succeed(Scheduler)(makeNoop());
+//# sourceMappingURL=Scheduler.js.map