@voyantjs/workflows-orchestrator-cloudflare 0.28.3 → 0.30.0

package/src/cloudflare-edge-driver.ts

@@ -0,0 +1,435 @@
+// Mode 1 driver — Cloudflare edge composition.
+//
+// `createApp({ workflows: { driver: createCloudflareEdgeDriver({ ... }) } })`
+// is the entry point for any deployment that runs the orchestrator on
+// Cloudflare Workers + Durable Objects. Composes:
+//
+//   * `voyant_run_DO` (Durable Object namespace)  — primary state
+//   * `WORKFLOW_MANIFESTS` KV namespace            — manifest store
+//
+// Step delivery is configured separately on the run DO via a
+// `StepDispatcher` — see `./dispatchers.ts` for built-in factories
+// (inline / service binding / HTTP).
+//
+// The factory is invoked by `createApp()` after the framework's
+// `ModuleContainer` is built — see architecture doc §6.3 for the
+// `DriverFactory` contract.
+//
+// See architecture doc §8.
+
+import type {
+  EnvironmentName,
+  ListRunsOptions,
+  Run,
+  RunDetail,
+  RunSummary,
+  TriggerOptions,
+} from "@voyantjs/workflows"
+import type {
+  DriverFactory,
+  DriverFactoryDeps,
+  IngestEventArgs,
+  IngestEventResponse,
+  IngestMatch,
+  WorkflowAdmin,
+  WorkflowDriver,
+} from "@voyantjs/workflows/driver"
+import { deriveStableEventId } from "@voyantjs/workflows/events"
+import type { WorkflowManifest } from "@voyantjs/workflows/protocol"
+import { routeEvent } from "@voyantjs/workflows-orchestrator"
+
+import {
+  type CfManifestStore,
+  createKvManifestStore,
+  type KvNamespaceLike,
+} from "./manifest-kv-store.js"
+import type { DurableObjectNamespaceLike } from "./worker.js"
+
+// ---- Public factory options ----
+
+export interface CloudflareEdgeDriverOptions {
+  /** Durable Object namespace holding one DO per run. */
+  orchestratorNamespace: DurableObjectNamespaceLike
+  /** KV namespace storing serialized manifests. */
+  manifestKv: KvNamespaceLike
+  /**
+   * Adapter-specific tenant identifier stamped onto every triggered
+   * run as `tenantMeta.tenantScript`. Opaque to the OSS runtime —
+   * surfaces on `StepDispatcherContext` for custom dispatchers that
+   * need a routing key. Built-in dispatchers (inline, service-binding,
+   * HTTP) ignore it.
+   */
+  tenantScript?: string
+  /** Default environment for `trigger()` calls without an explicit one. */
+  defaultEnvironment?: EnvironmentName
+  /** Tenant metadata stamped onto every triggered run. Defaults to "default" tripled. */
+  tenantMeta?: {
+    tenantId: string
+    projectId: string
+    organizationId: string
+  }
+  /** Injectable clock; defaults to Date.now. */
+  now?: () => number
+  /** id generator for runs; defaults to `run_<random>`. */
+  idGenerator?: () => string
+  /** Optional structured logger; falls back to the framework logger. */
+  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
+}
+
+const DEFAULT_TENANT_META = {
+  tenantId: "default",
+  projectId: "default",
+  organizationId: "default",
+}
+
+// ---- Public factory ----
+
+/**
+ * Build the Cloudflare-edge driver factory. The returned `DriverFactory`
+ * is invoked once by `createApp()` with `DriverFactoryDeps`.
+ *
+ * Usage in a Worker template:
+ *
+ *     createApp({
+ *       workflows: {
+ *         driver: createCloudflareEdgeDriver({
+ *           orchestratorNamespace: env.WORKFLOW_RUN_DO,
+ *           manifestKv:            env.WORKFLOW_MANIFESTS,
+ *         }),
+ *       },
+ *     })
+ */
+export function createCloudflareEdgeDriver(opts: CloudflareEdgeDriverOptions): DriverFactory {
+  return (deps: DriverFactoryDeps): WorkflowDriver => {
+    const manifestStore: CfManifestStore = createKvManifestStore({ kv: opts.manifestKv })
+    const now = opts.now ?? deps.now ?? (() => Date.now())
+    const tenantMeta = {
+      ...DEFAULT_TENANT_META,
+      ...(opts.tenantMeta ?? {}),
+      ...(opts.tenantScript ? { tenantScript: opts.tenantScript } : {}),
+    }
+    const defaultEnv = opts.defaultEnvironment ?? "development"
+    const logger = opts.logger ?? deps.logger
+
+    let shuttingDown = false
+
+    // ---- Helpers ----
+
+    function assertNotShutdown(): void {
+      if (shuttingDown) {
+        throw new Error(
+          "CloudflareEdgeDriver: shutdown() has been called; new operations are refused.",
+        )
+      }
+    }
+
+    async function forwardToRunDO(runId: string, request: Request): Promise<Response> {
+      const id = opts.orchestratorNamespace.idFromName(runId)
+      const stub = opts.orchestratorNamespace.get(id)
+      return stub.fetch(request)
+    }
+
+    function genRunId(seed?: string): string {
+      if (seed !== undefined) return seed
+      if (opts.idGenerator) return opts.idGenerator()
+      const ts = now().toString(36)
+      const rand = Math.floor(Math.random() * 1_000_000)
+        .toString(36)
+        .padStart(4, "0")
+      return `run_${ts}_${rand}`
+    }
+
+    // ---- WorkflowDriver implementation ----
+
+    async function registerManifest(args: {
+      environment: EnvironmentName
+      manifest: WorkflowManifest
+    }): Promise<{ versionId: string }> {
+      assertNotShutdown()
+      return manifestStore.registerManifest({
+        environment: args.environment,
+        versionId: args.manifest.versionId,
+        manifest: args.manifest as unknown as Record<string, unknown>,
+      })
+    }
+
+    async function getManifest(args: {
+      environment: EnvironmentName
+    }): Promise<WorkflowManifest | null> {
+      const envelope = await manifestStore.getCurrent(args.environment)
+      if (!envelope) return null
+      return envelope.manifest as unknown as WorkflowManifest
+    }
+
+    async function trigger<TIn, TOut>(
+      workflow: { id: string } | string,
+      input: TIn,
+      triggerOpts?: TriggerOptions,
+    ): Promise<Run<TOut>> {
+      assertNotShutdown()
+      const workflowId = typeof workflow === "string" ? workflow : workflow.id
+      const env = triggerOpts?.environment ?? defaultEnv
+      const runId =
+        triggerOpts?.idempotencyKey !== undefined
+          ? `idem-${workflowId}-${triggerOpts.idempotencyKey}`
+          : genRunId()
+
+      const payload = {
+        runId,
+        workflowId,
+        workflowVersion: triggerOpts?.lockToVersion ?? "v1",
+        input: input as unknown,
+        tenantMeta,
+        environment: env,
+        tags: triggerOpts?.tags,
+        idempotencyKey: triggerOpts?.idempotencyKey,
+        triggeredBy: { kind: "api" as const },
+      }
+      const resp = await forwardToRunDO(
+        runId,
+        new Request("https://do-internal/trigger", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(payload),
+        }),
+      )
+      if (!resp.ok) {
+        const body = await safeText(resp)
+        throw new Error(
+          `CloudflareEdgeDriver: trigger DO returned ${resp.status}: ${body.slice(0, 256)}`,
+        )
+      }
+      const record = (await resp.json()) as {
+        id: string
+        workflowId: string
+        status: Run["status"]
+        startedAt: number
+      }
+      return {
+        id: record.id,
+        workflowId: record.workflowId,
+        status: record.status,
+        startedAt: record.startedAt,
+      }
+    }
+
+    async function ingestEvent(args: IngestEventArgs): Promise<IngestEventResponse> {
+      assertNotShutdown()
+      const stored = await manifestStore.getCurrent(args.environment)
+      if (!stored) {
+        return {
+          ok: false,
+          reason: "manifest_not_registered",
+          message: `No manifest is registered for environment "${args.environment}".`,
+        }
+      }
+      const manifest = stored.manifest as unknown as WorkflowManifest
+      const eventId = args.envelope.metadata?.eventId ?? (await deriveStableEventId(args.envelope))
+      const routed = routeEvent({
+        manifest,
+        envelope: {
+          name: args.envelope.name,
+          data: args.envelope.data,
+          metadata: args.envelope.metadata,
+          emittedAt: args.envelope.emittedAt,
+        },
+        eventId,
+        idempotencyOverride: args.idempotencyKey,
+      })
+
+      const matches: IngestMatch[] = []
+      let anyTriggered = false
+      let anyFailed = false
+
+      for (const entry of routed) {
+        if (entry.status === "skipped") {
+          matches.push({
+            filterId: entry.filterId,
+            status: "skipped",
+            reason: entry.reason,
+            details: entry.details,
+          })
+          continue
+        }
+        const runId = `idem-${entry.targetWorkflowId}-${entry.idempotencyKey}`
+        const payload = {
+          runId,
+          workflowId: entry.targetWorkflowId,
+          workflowVersion: "v1",
+          input: entry.input,
+          tenantMeta,
+          environment: args.environment,
+          idempotencyKey: entry.idempotencyKey,
+          triggeredBy: {
+            kind: "event" as const,
+            eventId,
+            eventType: args.envelope.name,
+            filterId: entry.filterId,
+          },
+        }
+        try {
+          const resp = await forwardToRunDO(
+            runId,
+            new Request("https://do-internal/trigger", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify(payload),
+            }),
+          )
+          if (resp.ok) {
+            matches.push({
+              filterId: entry.filterId,
+              targetWorkflowId: entry.targetWorkflowId,
+              runId,
+              idempotencyKey: entry.idempotencyKey,
+              status: "queued",
+            })
+            anyTriggered = true
+          } else {
+            const body = await safeText(resp)
+            logger?.("error", "CloudflareEdgeDriver: trigger DO failed", {
+              status: resp.status,
+              body: body.slice(0, 256),
+            })
+            matches.push({
+              filterId: entry.filterId,
+              targetWorkflowId: entry.targetWorkflowId,
+              status: "error",
+              reason: `do_returned_${resp.status}`,
+            })
+            anyFailed = true
+          }
+        } catch (err) {
+          matches.push({
+            filterId: entry.filterId,
+            targetWorkflowId: entry.targetWorkflowId,
+            status: "error",
+            reason: err instanceof Error ? err.message : String(err),
+          })
+          anyFailed = true
+        }
+      }
+
+      if (matches.length > 0 && !anyTriggered && anyFailed) {
+        return {
+          ok: false,
+          reason: "trigger_failed_for_all_matches",
+          message: "every matched filter failed to trigger",
+        }
+      }
+      return { ok: true, eventId, matches }
+    }
+
+    async function shutdown(): Promise<void> {
+      shuttingDown = true
+    }
+
+    // ---- WorkflowAdmin (partial — Mode 1 has no native cross-run query
+    //      layer; getRun + cancelRun are direct DO RPC; listRuns +
+    //      streamRun are explicitly unsupported per architecture
+    //      doc §8.3) ----
+
+    const admin: Partial<WorkflowAdmin> = {
+      async getRun(runId: string): Promise<RunDetail | null> {
+        try {
+          const resp = await forwardToRunDO(
+            runId,
+            new Request("https://do-internal/get", { method: "GET" }),
+          )
+          if (resp.status === 404) return null
+          if (!resp.ok) return null
+          const rec = (await resp.json()) as {
+            id: string
+            workflowId: string
+            workflowVersion: string
+            status: RunSummary["status"]
+            startedAt: number
+            completedAt?: number
+            tags: string[]
+            environment: EnvironmentName
+            input: unknown
+            output?: unknown
+            error?: unknown
+          }
+          return {
+            id: rec.id,
+            workflowId: rec.workflowId,
+            status: rec.status,
+            startedAt: rec.startedAt,
+            completedAt: rec.completedAt,
+            tags: [...rec.tags],
+            environment: rec.environment,
+            version: rec.workflowVersion,
+            input: rec.input,
+            output: rec.output,
+            error: rec.error,
+            durationMs:
+              rec.completedAt !== undefined
+                ? Math.max(0, rec.completedAt - rec.startedAt)
+                : undefined,
+          }
+        } catch {
+          return null
+        }
+      },
+
+      async cancelRun(runId: string, cancelOpts?: { reason?: string; compensate?: boolean }) {
+        // Per architecture doc §21.21, cancel does NOT run compensations
+        // by default; the `compensate` flag is accepted but no-op in v1.
+        void cancelOpts?.compensate
+        await forwardToRunDO(
+          runId,
+          new Request("https://do-internal/cancel", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ reason: cancelOpts?.reason }),
+          }),
+        )
+      },
+
+      async listRuns(_listOpts?: ListRunsOptions) {
+        // Self-host Mode 1 has no native cross-run query layer; voyant-cloud
+        // provides one in its index repo. Surface the limit to consumers
+        // (the dashboard) so they can fall back gracefully.
+        return { runs: [], nextCursor: undefined }
+      },
+
+      streamRun(_runId: string) {
+        // Live journal-event streaming is a follow-up; return an
+        // immediately-exhausted iterable so probes see a clean empty
+        // stream rather than undefined.
+        return {
+          [Symbol.asyncIterator]() {
+            return {
+              next: async () => ({ value: undefined as never, done: true as const }),
+            }
+          },
+        }
+      },
+    }
+
+    return {
+      registerManifest,
+      trigger,
+      ingestEvent,
+      getManifest,
+      shutdown,
+      admin,
+    }
+  }
+}
+
+// ---- Internal helpers ----
+
+// Fallback id derivation lives in `@voyantjs/workflows/events`'s
+// `deriveStableEventId` and is used inline at the call site above —
+// content-derived so external callers without a forwarder still get
+// dedup across retries (architecture doc §15.2).
+
+async function safeText(resp: Response): Promise<string> {
+  try {
+    return await resp.text()
+  } catch {
+    return ""
+  }
+}

package/src/dispatchers.ts

@@ -0,0 +1,162 @@
+// Step dispatchers — abstract "given a run's context, produce a
+// StepHandler that delivers step requests to whatever Worker (or
+// isolate) hosts the workflow code."
+//
+// The OSS runtime ships three universal factories:
+//   * createInlineDispatcher          — same isolate as the orchestrator
+//   * createServiceBindingDispatcher  — sibling Worker via service binding
+//   * createHttpDispatcher            — arbitrary HTTP endpoint
+//
+// Hosted multi-tenant providers (Voyant Cloud, etc.) implement their
+// own dispatchers in their private deployment code — Workers-for-
+// Platforms is one such option, but it doesn't belong in the OSS
+// runtime because it bakes in a CF-specific multi-tenancy story that
+// most self-host users don't need or want.
+//
+// See issue #528 + docs/architecture/workflows-runtime-architecture.md §8.
+
+import { createHttpStepHandler, type StepHandler } from "@voyantjs/workflows-orchestrator"
+
+/**
+ * Context the run DO supplies when asking a dispatcher for a
+ * StepHandler. Most dispatchers ignore it; it carries the run's
+ * adapter-specific tenant identifier (when set) and the workflow id
+ * for logging / per-tenant routing in custom dispatchers.
+ */
+export interface StepDispatcherContext {
+  /**
+   * Adapter-specific tenant identifier from the run's `tenantMeta`.
+   * Opaque to the OSS runtime — interpretation is up to whichever
+   * dispatcher consumes it (e.g. a custom multi-tenant dispatcher
+   * may use it as a routing key).
+   */
+  tenantScript?: string
+  /** Workflow id, useful for label / logging. */
+  workflowId?: string
+}
+
+/**
+ * Pluggable step-dispatch primitive. The run DO calls the dispatcher
+ * once per drive and forwards step requests through the handler it
+ * returns.
+ *
+ * Pick a factory below based on where workflow code lives in your
+ * deployment, or implement the type directly for custom transports.
+ */
+export type StepDispatcher = (ctx: StepDispatcherContext) => StepHandler
+
+// ---- Factory: Service binding ----
+
+/**
+ * Subset of a Cloudflare service-binding interface (`env.SOMETHING`
+ * declared as `services: [{ binding, service }]` in wrangler.jsonc).
+ * `fetch(req)` delivers to the bound Worker.
+ */
+export interface ServiceBindingLike {
+  fetch(request: Request): Promise<Response>
+}
+
+export interface ServiceBindingDispatcherOptions {
+  /** Service binding to a sibling Worker that hosts the workflow code. */
+  binding: ServiceBindingLike
+  /** Optional HMAC signer. */
+  sign?: (body: string) => Promise<string> | string
+  /** Optional structured logger. */
+  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
+  /** URL presented to the bound Worker. Defaults to `https://tenant.voyant.internal`. */
+  baseUrl?: string
+  /** Optional label for logs. Defaults to `"service-binding"`. */
+  label?: string
+}
+
+/**
+ * Service-binding dispatcher. Routes step requests to a sibling Worker
+ * via `services: [{ binding, service }]` in the orchestrator's
+ * wrangler.jsonc. Use this for self-host two-Worker deployments
+ * (orchestrator + workflows are separate Workers in the same account).
+ * No WfP needed; works on the standard Workers paid plan.
+ */
+export function createServiceBindingDispatcher(
+  opts: ServiceBindingDispatcherOptions,
+): StepDispatcher {
+  const baseUrl = opts.baseUrl ?? "https://tenant.voyant.internal"
+  const label = opts.label ?? "service-binding"
+  return (_ctx) =>
+    createHttpStepHandler({
+      sign: opts.sign ? (body) => opts.sign!(body) : undefined,
+      logger: opts.logger,
+      resolveTarget() {
+        return {
+          url: `${baseUrl}/__voyant/workflow-step`,
+          label,
+          fetch(request: Request) {
+            return opts.binding.fetch(request)
+          },
+        }
+      },
+    })
+}
+
+// ---- Factory: Inline ----
+
+/**
+ * Inline dispatcher. Returns the supplied StepHandler directly — used
+ * when workflow code lives in the SAME Worker as the orchestrator
+ * (single-Worker self-host). No HTTP, no DO traversal, just a function
+ * call. Pair with `handleStepRequest` from `@voyantjs/workflows/handler`
+ * for the typical setup.
+ */
+export function createInlineDispatcher(handler: StepHandler): StepDispatcher {
+  return () => handler
+}
+
+// ---- Factory: HTTP ----
+
+export interface HttpDispatcherOptions {
+  /** Absolute URL of the workflow-step endpoint. */
+  url: string
+  /** Optional HMAC signer. */
+  sign?: (body: string) => Promise<string> | string
+  /** Optional structured logger. */
+  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
+  /**
+   * Optional fetch override (e.g. `env.SOMETHING.fetch.bind(env.SOMETHING)`
+   * for typed bindings, or a custom client for testing). Defaults to
+   * `globalThis.fetch`.
+   */
+  fetch?: (request: Request) => Promise<Response>
+  /** Optional label for logs; defaults to the URL host. */
+  label?: string
+}
+
+/**
+ * HTTP dispatcher. Routes step requests to a configurable URL via
+ * `globalThis.fetch` (or a supplied fetch). Use for cross-host setups
+ * (e.g. a CF orchestrator forwarding to a Node-side workflows Worker)
+ * or test fakes.
+ */
+export function createHttpDispatcher(opts: HttpDispatcherOptions): StepDispatcher {
+  const fetchImpl = opts.fetch ?? ((req: Request) => globalThis.fetch(req))
+  let label = opts.label
+  if (!label) {
+    try {
+      label = new URL(opts.url).host
+    } catch {
+      label = opts.url
+    }
+  }
+  return (_ctx) =>
+    createHttpStepHandler({
+      sign: opts.sign ? (body) => opts.sign!(body) : undefined,
+      logger: opts.logger,
+      resolveTarget() {
+        return {
+          url: opts.url,
+          label,
+          fetch(request: Request) {
+            return fetchImpl(request)
+          },
+        }
+      },
+    })
+}

package/src/do-store.ts

@@ -26,6 +26,19 @@ export function createDurableObjectRunStore(storage: DurableObjectStorageLike):
       return record
     },
 
+    async tryInsert(record) {
+      // DO storage is single-threaded per DO instance: concurrent fetches
+      // to `idFromName(runId)` are serialized inside the DO's request
+      // queue, so get-then-put is naturally atomic. This is just the
+      // contract-shape implementation.
+      const existing = await storage.get<RunRecord>(RECORD_KEY)
+      if (existing && existing.id === record.id) {
+        return { record: existing, created: false }
+      }
+      await storage.put<RunRecord>(RECORD_KEY, record)
+      return { record, created: true }
+    },
+
     async list(filter = {}) {
       const r = await storage.get<RunRecord>(RECORD_KEY)
       if (!r) return []

package/src/durable-object.ts

@@ -27,6 +27,8 @@ import {
   type RunRecord,
   type StepHandler,
 } from "@voyantjs/workflows-orchestrator"
+
+import type { StepDispatcher } from "./dispatchers.js"
 import { createDurableObjectRunStore } from "./do-store.js"
 import type {
   CancelPayload,
@@ -38,15 +40,31 @@ import type {
 export interface DurableObjectDeps {
   storage: DurableObjectStorageLike
   /**
-   * Resolve the StepHandler to use for a given tenant script. Called
-   * with the tenantScript (from the trigger payload) so the DO can
-   * route to the correct tenant Worker. In production this closes
-   * over the dispatch namespace; in tests it returns a mock.
+   * Pluggable dispatcher producing a StepHandler for a given run's
+   * context. The DO calls `dispatcher({ tenantScript, workflowId })`
+   * once per drive; the returned handler delivers step requests to
+   * whatever Worker (or isolate) hosts the workflow code.
+   *
+   * Pick a factory from `./dispatchers.ts`:
+   *  - `createWfpDispatcher`           — multi-tenant via dispatch namespace
+   *  - `createServiceBindingDispatcher` — sibling Worker via service binding
+   *  - `createInlineDispatcher`         — same Worker / direct call
+   *  - `createHttpDispatcher`           — arbitrary HTTP endpoint
    */
-  resolveStepHandler: (tenantScript: string) => StepHandler
+  dispatcher: StepDispatcher
   now?: () => number
 }
 
+function resolve(
+  deps: DurableObjectDeps,
+  record: { tenantMeta: { tenantScript?: string }; workflowId: string },
+): StepHandler {
+  return deps.dispatcher({
+    tenantScript: record.tenantMeta.tenantScript,
+    workflowId: record.workflowId,
+  })
+}
+
 export async function handleDurableObjectRequest(
   req: Request,
   deps: DurableObjectDeps,
@@ -56,7 +74,10 @@ export async function handleDurableObjectRequest(
 
   if (req.method === "POST" && url.pathname === "/trigger") {
     const payload = (await req.json()) as TriggerPayload
-    const handler = deps.resolveStepHandler(payload.tenantMeta.tenantScript)
+    const handler = resolve(deps, {
+      tenantMeta: payload.tenantMeta,
+      workflowId: payload.workflowId,
+    })
     const record = await orchestratorTrigger(
       {
         workflowId: payload.workflowId,
@@ -77,7 +98,7 @@ export async function handleDurableObjectRequest(
     const payload = (await req.json()) as ResumePayload
     const existing = await store.get((await getStoredRunId(store)) ?? "")
     if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" })
-    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "")
+    const handler = resolve(deps, existing)
     const out = await orchestratorResume(
       { runId: existing.id, injection: payload.injection },
       { store, handler, now: deps.now },
@@ -94,7 +115,7 @@ export async function handleDurableObjectRequest(
     const payload = (await req.json()) as CancelPayload
     const existing = await store.get((await getStoredRunId(store)) ?? "")
     if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" })
-    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "")
+    const handler = resolve(deps, existing)
     const out = await orchestratorCancel(
       { runId: existing.id, reason: payload.reason },
       { store, handler, now: deps.now },
@@ -158,7 +179,7 @@ export async function handleDurableObjectAlarm(deps: DurableObjectDeps): Promise
   }
 
   record.status = "running"
-  const handler = deps.resolveStepHandler(record.tenantMeta.tenantScript ?? "")
+  const handler = resolve(deps, record)
   await driveUntilPaused(record, { handler, now: deps.now })
   await store.save(record)
   await reconcileAlarm(record, store, deps)