@effect-app/infra 4.0.0-beta.263 → 4.0.0-beta.265

package/src/WorkflowEngineCosmos.ts

@@ -34,6 +34,7 @@ import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
 import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
+import * as Cause from "effect/Cause"
 import * as Duration from "effect/Duration"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
@@ -109,12 +110,24 @@ interface ClockDoc {
   readonly fireAt: string
 }
 
+// Cosmos forbids '/', '\', '#', '?' in a resource id; workflow/deferred/clock
+// names routinely contain '/', so every doc id is URI-encoded (mirrors
+// `cosmosId` in ClusterCosmos). Partition keys (executionId) are exempt.
+const cosmosId = (id: string) => encodeURIComponent(id)
 const execId = "exec" as const
-const activityKey = (name: string, attempt: number) => `activity::${name}::${attempt}`
-const deferredKey = (name: string) => `deferred::${name}`
-const clockKey = (name: string) => `clock::${name}`
+const activityKey = (name: string, attempt: number) => cosmosId(`activity::${name}::${attempt}`)
+const deferredKey = (name: string) => cosmosId(`deferred::${name}`)
+const clockKey = (name: string) => cosmosId(`clock::${name}`)
 
-const isOptimisticStatus = (code: number) => code === 409 || code === 412 || code === 404
+// Single-item Cosmos writes (`replace`) *throw* on 409/412/404 rather than
+// returning the status code (only `read` and batch ops surface codes), so OCC
+// conflicts must be matched on the thrown error — mirrors ClusterCosmos.
+const isCosmosStatus = (u: unknown, code: number): boolean =>
+  Cause.isUnknownError(u)
+    ? isCosmosStatus(u.cause, code)
+    : typeof u === "object" && u !== null && "code" in u && u.code === code
+
+const isOptimisticError = (u: unknown) => isCosmosStatus(u, 409) || isCosmosStatus(u, 412) || isCosmosStatus(u, 404)
 
 // --- Storage codecs ----------------------------------------------------------
 // Values flowing through the engine's activity / deferred boundary are already
@@ -122,7 +135,7 @@ const isOptimisticStatus = (code: number) => code === 409 || code === 412 || cod
 // opaque (mirrors the cluster engine's `AnyOrVoid` usage).
 const AnyOrVoid = S.Union([S.Any, S.Void])
 const ActivityResultCodec = S.fromJsonString(S.toCodecJson(Workflow.Result({ success: AnyOrVoid, error: AnyOrVoid })))
-const DeferredExitCodec = S.fromJsonString(S.toCodecJson(S.Exit(AnyOrVoid, AnyOrVoid, S.Defect)))
+const DeferredExitCodec = S.fromJsonString(S.toCodecJson(S.Exit(AnyOrVoid, AnyOrVoid, S.Defect())))
 
 const encodeActivityResult = (r: Workflow.Result<unknown, unknown>) =>
   Effect.orDie(S.encodeEffect(ActivityResultCodec)(r))
@@ -183,10 +196,10 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
   const makePayloadCodec = (workflow: Workflow.Any) => S.fromJsonString(S.toCodecJson(workflow.payloadSchema))
   const payloadCodecCache = new Map<string, ReturnType<typeof makePayloadCodec>>()
   const payloadCodecFor = (workflow: Workflow.Any) => {
-    let c = payloadCodecCache.get(workflow.name)
+    let c = payloadCodecCache.get(workflow._tag)
     if (!c) {
       c = makePayloadCodec(workflow)
-      payloadCodecCache.set(workflow.name, c)
+      payloadCodecCache.set(workflow._tag, c)
     }
     return c
   }
@@ -195,10 +208,10 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
     S.fromJsonString(S.toCodecJson(Workflow.Result({ success: workflow.successSchema, error: workflow.errorSchema })))
   const resultCodecCache = new Map<string, ReturnType<typeof makeResultCodec>>()
   const resultCodecFor = (workflow: Workflow.Any) => {
-    let c = resultCodecCache.get(workflow.name)
+    let c = resultCodecCache.get(workflow._tag)
     if (!c) {
       c = makeResultCodec(workflow)
-      resultCodecCache.set(workflow.name, c)
+      resultCodecCache.set(workflow._tag, c)
     }
     return c
   }
@@ -228,22 +241,24 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
   const replaceExec = (doc: ExecDoc) =>
     Effect
       .gen(function*() {
-        const resp = yield* Effect.promise(() =>
+        const resp = yield* Effect.tryPromise(() =>
           container.item(execId, doc._partitionKey).replace<ExecDoc>(doc, {
             accessCondition: { type: "IfMatch", condition: doc._etag ?? "" }
           })
         )
         yield* annotateCosmosResponse({ requestCharge: resp.requestCharge, statusCode: resp.statusCode })
-        if (isOptimisticStatus(resp.statusCode)) {
-          return yield* new OptimisticConcurrencyException({
-            type: "workflow.exec",
-            id: doc._partitionKey,
-            code: resp.statusCode
-          })
-        }
         return { ...doc, _etag: resp.etag }
       })
-      .pipe(annotate("replaceExec", doc._partitionKey))
+      .pipe(
+        Effect.catch((u) =>
+          isOptimisticError(u)
+            ? Effect.fail(
+              new OptimisticConcurrencyException({ type: "workflow.exec", id: doc._partitionKey, code: 412 })
+            )
+            : Effect.die(u)
+        ),
+        annotate("replaceExec", doc._partitionKey)
+      )
 
   // Atomic create-or-noop using a single-op batch — returns true if created.
   const createIfMissing = <T extends { readonly id: string; readonly _partitionKey: string }>(
@@ -390,7 +405,10 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
           ...current.value,
           status: isComplete ? "complete" : current.value.status,
           suspended: result._tag === "Suspended",
-          interrupted: instance.interrupted,
+          // Never downgrade a persisted interrupt: a concurrent `interrupt` may
+          // have set the flag while this driver was suspending. Losing it would
+          // leave a re-drive unable to collapse the suspension.
+          interrupted: instance.interrupted || current.value.interrupted,
           completedResult,
           // Release lease on completion so the doc isn't seen as orphaned.
           worker: isComplete ? undefined : current.value.worker,
@@ -449,38 +467,59 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
       )
     })
 
+  // Persist `interrupted: true`, retrying on OCC. A suspending driver's
+  // onComplete (or a heartbeat renewal) can win the etag race; silently
+  // dropping the flag would leave the subsequent re-drive reading
+  // `interrupted: false` and re-suspending forever. Retry until the flag is
+  // durably set (or the exec is already complete/gone). Unlike SQLite — whose
+  // synchronous writes never interleave here — Cosmos round-trips open a real
+  // race window, so the write must converge rather than swallow the conflict.
+  const markInterrupted = (executionId: string): Effect.Effect<void> =>
+    Effect.gen(function*() {
+      while (true) {
+        const current = yield* readExec(executionId)
+        if (Option.isNone(current) || current.value.status === "complete" || current.value.interrupted) {
+          return
+        }
+        const persisted = yield* replaceExec({ ...current.value, interrupted: true }).pipe(
+          Effect.as(true),
+          Effect.catchTag("OptimisticConcurrencyException", () => Effect.succeed(false))
+        )
+        if (persisted) return
+      }
+    })
+
   // --- Encoded engine ----------------------------------------------------
 
   const encoded: Encoded = {
     register: Effect.fnUntraced(function*(workflow, execute) {
-      workflows.set(workflow.name, {
+      workflows.set(workflow._tag, {
         workflow,
         execute,
         scope: yield* Effect.scope
       })
     }),
     execute: Effect.fnUntraced(function*(workflow, options) {
-      const entry = workflows.get(workflow.name)
+      const entry = workflows.get(workflow._tag)
       if (!entry) {
-        return yield* Effect.orDie(Effect.fail(`Workflow ${workflow.name} is not registered`))
+        return yield* Effect.orDie(Effect.fail(`Workflow ${workflow._tag} is not registered`))
       }
 
       const initial: ExecDoc = {
         id: execId,
         _partitionKey: options.executionId,
         type: "exec",
-        workflowName: workflow.name,
+        workflowName: workflow._tag,
         payload: yield* encodePayload(workflow, options.payload),
         parent: options.parent?.executionId,
         status: "running",
         suspended: false,
         interrupted: false
       }
-      const created = yield* createIfMissing(initial).pipe(annotate("execute.claim", options.executionId))
-
-      if (created || !locals.has(options.executionId)) {
-        yield* drive(options.executionId, options.payload, options.parent?.executionId, entry)
-      }
+      yield* createIfMissing(initial).pipe(annotate("execute.claim", options.executionId))
+      // Drive unconditionally; `drive`'s own guard short-circuits a still-running
+      // or completed fiber and re-drives a suspended one (matches Sqlite).
+      yield* drive(options.executionId, options.payload, options.parent?.executionId, entry)
 
       if (options.discard) return undefined as any
 
@@ -515,22 +554,13 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
     interrupt: Effect.fnUntraced(function*(_workflow, executionId) {
       const local = locals.get(executionId)
       if (local) local.instance.interrupted = true
-      const current = yield* readExec(executionId)
-      if (Option.isNone(current) || current.value.status === "complete") return
-      yield* replaceExec({ ...current.value, interrupted: true }).pipe(
-        Effect.catchTag("OptimisticConcurrencyException", () => Effect.void)
-      )
+      yield* markInterrupted(executionId)
       yield* driveById(executionId)
     }),
     interruptUnsafe: Effect.fnUntraced(function*(_workflow, executionId) {
       const local = locals.get(executionId)
       if (local) local.instance.interrupted = true
-      const current = yield* readExec(executionId)
-      if (Option.isSome(current) && current.value.status !== "complete") {
-        yield* replaceExec({ ...current.value, interrupted: true }).pipe(
-          Effect.catchTag("OptimisticConcurrencyException", () => Effect.void)
-        )
-      }
+      yield* markInterrupted(executionId)
       if (local?.fiber) yield* Fiber.interrupt(local.fiber)
     }),
     resume: (_workflow, executionId) => driveById(executionId),
@@ -602,7 +632,7 @@ const makeCosmosWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
         id: clockKey(options.clock.name),
         _partitionKey: options.executionId,
         type: "clock",
-        workflowName: workflow.name,
+        workflowName: workflow._tag,
         deferredName: options.clock.deferred.name,
         fireAt
       }

package/src/WorkflowEngineSqlite.ts

@@ -117,7 +117,7 @@ const parseExec = (row: ExecRow): ExecState => ({
 // opaque (mirrors the cluster engine's `AnyOrVoid` usage).
 const AnyOrVoid = S.Union([S.Any, S.Void])
 const ActivityResultCodec = S.fromJsonString(S.toCodecJson(Workflow.Result({ success: AnyOrVoid, error: AnyOrVoid })))
-const DeferredExitCodec = S.fromJsonString(S.toCodecJson(S.Exit(AnyOrVoid, AnyOrVoid, S.Defect)))
+const DeferredExitCodec = S.fromJsonString(S.toCodecJson(S.Exit(AnyOrVoid, AnyOrVoid, S.Defect())))
 
 const encodeActivityResult = (r: Workflow.Result<unknown, unknown>) =>
   Effect.orDie(S.encodeEffect(ActivityResultCodec)(r))
@@ -229,10 +229,10 @@ const makeSqliteWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
   const makePayloadCodec = (workflow: Workflow.Any) => S.fromJsonString(S.toCodecJson(workflow.payloadSchema))
   const payloadCodecCache = new Map<string, ReturnType<typeof makePayloadCodec>>()
   const payloadCodecFor = (workflow: Workflow.Any) => {
-    let c = payloadCodecCache.get(workflow.name)
+    let c = payloadCodecCache.get(workflow._tag)
     if (!c) {
       c = makePayloadCodec(workflow)
-      payloadCodecCache.set(workflow.name, c)
+      payloadCodecCache.set(workflow._tag, c)
     }
     return c
   }
@@ -241,10 +241,10 @@ const makeSqliteWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
     S.fromJsonString(S.toCodecJson(Workflow.Result({ success: workflow.successSchema, error: workflow.errorSchema })))
   const resultCodecCache = new Map<string, ReturnType<typeof makeResultCodec>>()
   const resultCodecFor = (workflow: Workflow.Any) => {
-    let c = resultCodecCache.get(workflow.name)
+    let c = resultCodecCache.get(workflow._tag)
     if (!c) {
       c = makeResultCodec(workflow)
-      resultCodecCache.set(workflow.name, c)
+      resultCodecCache.set(workflow._tag, c)
     }
     return c
   }
@@ -602,20 +602,20 @@ const makeSqliteWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
 
   const encoded: Encoded = {
     register: Effect.fnUntraced(function*(workflow, execute) {
-      workflows.set(workflow.name, {
+      workflows.set(workflow._tag, {
         workflow,
         execute,
         scope: yield* Effect.scope
       })
     }),
     execute: Effect.fnUntraced(function*(workflow, options) {
-      const entry = workflows.get(workflow.name)
+      const entry = workflows.get(workflow._tag)
       if (!entry) {
-        return yield* Effect.orDie(Effect.fail(`Workflow ${workflow.name} is not registered`))
+        return yield* Effect.orDie(Effect.fail(`Workflow ${workflow._tag} is not registered`))
       }
       const initial: ExecState = {
         executionId: options.executionId,
-        workflowName: workflow.name,
+        workflowName: workflow._tag,
         payload: yield* encodePayload(workflow, options.payload),
         parent: options.parent?.executionId,
         status: "running",
@@ -730,7 +730,7 @@ const makeSqliteWorkflowEngine = Effect.fnUntraced(function*(cfg: WorkflowEngine
         yield* insertClock(
           options.executionId,
           options.clock.name,
-          workflow.name,
+          workflow._tag,
           options.clock.deferred.name,
           fireAt
         )

package/test/cluster-cosmos.test.ts

@@ -11,6 +11,7 @@ const cosmosUrl = process.env["COSMOS_TEST_URL"]
 const cosmosDb = process.env["COSMOS_TEST_DB"] ?? "cluster-test"
 const testRunId = `${Date.now()}-${process.pid}-${Math.random().toString(16).slice(2)}`
 const runnerPortBase = 10000 + Date.now() % 40000
+const liveSnowflake = Layer.effect(Snowflake.Generator, TestClock.withLive(Snowflake.makeGenerator))
 
 const layerFor = () =>
   layerCosmos({
@@ -19,7 +20,7 @@ const layerFor = () =>
     prefix: "test-cluster-"
   })
     .pipe(
-      Layer.provideMerge(Snowflake.layerGenerator),
+      Layer.provideMerge(liveSnowflake),
       Layer.provide(ShardingConfig.layerDefaults)
     )
 
@@ -182,6 +183,28 @@ describe.skipIf(!cosmosUrl)("ClusterCosmos RunnerStorage", () => {
       })
       .pipe(Effect.provide(layerFor())))
 
+  it.effect("allocates distinct machine ids for distinct runners", () =>
+    Effect
+      .gen(function*() {
+        const storage = yield* RunnerStorage.RunnerStorage
+        const address1 = testRunnerAddress(6)
+        const address2 = testRunnerAddress(7)
+        const runner1 = Runner.make({ address: address1, groups: ["default"], weight: 1 })
+        const runner2 = Runner.make({ address: address2, groups: ["default"], weight: 1 })
+
+        const id1 = yield* storage.register(runner1, true)
+        const id2 = yield* storage.register(runner2, true)
+        // Distinct runners must get distinct machine ids (would otherwise risk
+        // colliding Snowflake ids).
+        assert(id1 !== id2)
+        // Re-registration is stable per address.
+        assert.deepStrictEqual(yield* storage.register(runner1, true), id1)
+
+        yield* storage.unregister(address1)
+        yield* storage.unregister(address2)
+      })
+      .pipe(Effect.provide(layerFor())))
+
   it.effect("preserves shard lock ownership when two runners acquire concurrently", () =>
     Effect
       .gen(function*() {
@@ -342,8 +365,7 @@ const CosmosRpcEntityLayer = CosmosRpcEntity.toLayer(
 const CosmosDeferred = DurableDeferred.make("ClusterCosmos/Deferred", { success: Schema.String })
 
 const CosmosDeferredWorkflow = Workflow
-  .make({
-    name: "ClusterCosmos/DeferredWorkflow",
+  .make("ClusterCosmos/DeferredWorkflow", {
     payload: { id: Schema.String },
     success: Schema.String,
     idempotencyKey: ({ id }) => id

package/test/cluster-sqlite.test.ts

@@ -67,8 +67,7 @@ class StepLog extends Context.Service<StepLog, { readonly steps: Array<string> }
 const SqliteDeferred = DurableDeferred.make("ClusterSqlite/Deferred", { success: Schema.String })
 
 const SqliteDeferredWorkflow = Workflow
-  .make({
-    name: "ClusterSqlite/DeferredWorkflow",
+  .make("ClusterSqlite/DeferredWorkflow", {
     payload: { id: Schema.String },
     success: Schema.String,
     idempotencyKey: ({ id }) => id
@@ -85,8 +84,7 @@ const SequentialStep2 = DurableDeferred.make("ClusterSqlite/SequentialStep2", {
 const SequentialStep3 = DurableDeferred.make("ClusterSqlite/SequentialStep3", { success: Schema.String })
 
 const SequentialDeferredWorkflow = Workflow
-  .make({
-    name: "ClusterSqlite/SequentialDeferredWorkflow",
+  .make("ClusterSqlite/SequentialDeferredWorkflow", {
     payload: { id: Schema.String },
     success: Schema.String,
     idempotencyKey: ({ id }) => id

package/test/dist/cluster-azure-sql.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-azure-sql.test.d.ts","sourceRoot":"","sources":["../cluster-azure-sql.test.ts"],"names":[],"mappings":""}

package/test/dist/cluster-storage-parity-sqlite.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster-storage-parity-sqlite.test.d.ts","sourceRoot":"","sources":["../cluster-storage-parity-sqlite.test.ts"],"names":[],"mappings":""}

package/test/workflow-engine-cosmos.test.ts

@@ -29,8 +29,7 @@ class CounterRef extends Context.Service<CounterRef, { count: number }>()("Count
 
 // --- Workflow definitions ----------------------------------------------
 
-const IncrementWorkflow = Workflow.make({
-  name: "WorkflowEngineCosmos/IncrementWorkflow",
+const IncrementWorkflow = Workflow.make("WorkflowEngineCosmos/IncrementWorkflow", {
   payload: { value: Schema.Number },
   success: Schema.Number,
   idempotencyKey: ({ value }) => String(value)
@@ -40,8 +39,7 @@ const IncrementHandler = IncrementWorkflow.toLayer(({ value }) => Effect.succeed
 
 // Counts activity body invocations across re-executes so the test can
 // prove side-effects don't repeat when a persisted result is available.
-const CounterWorkflow = Workflow.make({
-  name: "WorkflowEngineCosmos/CounterWorkflow",
+const CounterWorkflow = Workflow.make("WorkflowEngineCosmos/CounterWorkflow", {
   payload: { id: Schema.String },
   success: Schema.Number,
   idempotencyKey: ({ id }) => id
@@ -63,8 +61,7 @@ const CounterHandler = CounterWorkflow.toLayer(Effect.fn(function*() {
 // with the resumed deferred value. Exercises Result/Exit round-trip.
 const Trigger = DurableDeferred.make("WorkflowEngineCosmos/Trigger", { success: Schema.String })
 
-const SuspendWorkflow = Workflow.make({
-  name: "WorkflowEngineCosmos/SuspendWorkflow",
+const SuspendWorkflow = Workflow.make("WorkflowEngineCosmos/SuspendWorkflow", {
   payload: { id: Schema.String },
   success: Schema.String,
   idempotencyKey: ({ id }) => id
@@ -81,8 +78,7 @@ const SuspendHandler = SuspendWorkflow.toLayer(Effect.fn(function*({ id }) {
 }))
 
 // Plain durable-deferred await — used to assert first-writer-wins on done().
-const AwaitOnly = Workflow.make({
-  name: "WorkflowEngineCosmos/AwaitOnly",
+const AwaitOnly = Workflow.make("WorkflowEngineCosmos/AwaitOnly", {
   payload: { id: Schema.String },
   success: Schema.String,
   idempotencyKey: ({ id }) => id
@@ -201,16 +197,11 @@ const runSuite = (engineLayer: Layer.Layer<WorkflowEngine.WorkflowEngine>) => {
         yield* Effect.sleep(Duration.millis(50))
         yield* AwaitOnly.interrupt(executionId)
 
-        // The execution should stop reporting as "running" — a subsequent poll
-        // returns either Complete (engine collapses the interrupt into a
-        // completion) or None (engine surfaces it as not-yet-complete and the
-        // wrapper sleep loop eventually ends). Both are acceptable as long as
-        // the workflow no longer makes forward progress.
-        yield* Effect.sleep(Duration.millis(150))
-        const polled = yield* AwaitOnly.poll(executionId)
-        if (Option.isSome(polled)) {
-          assert.strictEqual(polled.value._tag, "Complete")
-        }
+        // Interrupt collapses the suspended execution into a completion. A
+        // durable engine re-drives across several storage round-trips, so poll
+        // until it reports Complete rather than asserting a fixed delay.
+        const done = yield* waitForComplete(AwaitOnly, executionId)
+        assert(done !== undefined && done._tag === "Complete")
       })
       .pipe(Effect.provide(TestLayer)))
 }
@@ -278,7 +269,7 @@ describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", ()
             id: "exec",
             _partitionKey: "recover-1",
             type: "exec",
-            workflowName: IncrementWorkflow.name,
+            workflowName: IncrementWorkflow._tag,
             payload: JSON.stringify({ value: 99 }),
             status: "running",
             suspended: false,
@@ -318,7 +309,7 @@ describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", ()
             id: "exec",
             _partitionKey: "exec-clock",
             type: "exec",
-            workflowName: AwaitOnly.name,
+            workflowName: AwaitOnly._tag,
             payload: JSON.stringify({ id: "wake" }),
             status: "running",
             suspended: false,
@@ -331,7 +322,7 @@ describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", ()
             id: "clock::wake",
             _partitionKey: "exec-clock",
             type: "clock",
-            workflowName: AwaitOnly.name,
+            workflowName: AwaitOnly._tag,
             deferredName: Trigger.name,
             fireAt: new Date(Date.now() - 60_000).toISOString()
           })
@@ -342,7 +333,7 @@ describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", ()
         // The clock fire is a deferred-complete; assert the deferred row
         // now exists for this execution.
         const deferred = yield* Effect.promise(() =>
-          container.item(`deferred::${Trigger.name}`, "exec-clock").read<{ exit: string }>()
+          container.item(encodeURIComponent(`deferred::${Trigger.name}`), "exec-clock").read<{ exit: string }>()
         )
         assert(deferred.resource !== undefined)
         // And the clock doc has been deleted.

package/test/workflow-engine-sqlite.test.ts

@@ -21,8 +21,7 @@ class CounterRef extends Context.Service<CounterRef, { count: number }>()("Count
 
 // --- Workflow definitions --------------------------------------------
 
-const Increment = Workflow.make({
-  name: "Sqlite/Increment",
+const Increment = Workflow.make("Sqlite/Increment", {
   payload: { value: Schema.Number },
   success: Schema.Number,
   idempotencyKey: ({ value }) => `inc-${value}`
@@ -45,8 +44,7 @@ const TickHandler = Increment.toLayer(({ value }) => Effect.succeed(value + 1))
 
 const EmailReceived = DurableDeferred.make("EmailReceived", { success: Schema.String })
 
-const AwaitEmail = Workflow.make({
-  name: "Sqlite/AwaitEmail",
+const AwaitEmail = Workflow.make("Sqlite/AwaitEmail", {
   payload: { id: Schema.String },
   success: Schema.String,
   idempotencyKey: ({ id }) => `email-${id}`