@effect-app/infra 4.0.0-beta.257 → 4.0.0-beta.258

package/test/dist/workflow-engine-sqlite.test.d.ts.map

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

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

@@ -0,0 +1,354 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Workflow engine conformance tests.
+ *
+ * The `runSuite` body is engine-agnostic: it runs against
+ * `WorkflowEngine.layerMemory` (fast, always) and — when `COSMOS_TEST_URL`
+ * is set — against the Cosmos adapter (`layerCosmos`) pointed at a Cosmos
+ * emulator. Both must satisfy the same observable contract: idempotent
+ * execution, activity replay (no double side effects), suspend → durable-
+ * deferred completion → resume with a correctly decoded result, interrupt
+ * propagation, and first-writer-wins deferred completion.
+ *
+ * A second describe block (Cosmos emulator only) exercises adapter
+ * internals — the recovery poller (driving execs whose lease has lapsed)
+ * and the clock poller (firing past-due clocks) — by seeding rows
+ * directly against the Cosmos container.
+ */
+import { assert, describe, it } from "@effect/vitest"
+import { Context, Duration, Effect, Exit, Layer, Option, Redacted, Schema } from "effect"
+import { Activity, DurableDeferred, Workflow, WorkflowEngine } from "effect/unstable/workflow"
+import { CosmosClient, CosmosClientLayer } from "../src/cosmos-client.js"
+import { layerCosmos } from "../src/WorkflowEngineCosmos.js"
+
+// --- Shared mutable counter for activity-side-effect assertions --------
+
+class CounterRef extends Context.Service<CounterRef, { count: number }>()("CounterRef") {
+  static readonly layer = Layer.effect(CounterRef, Effect.sync(() => ({ count: 0 })))
+}
+
+// --- Workflow definitions ----------------------------------------------
+
+const IncrementWorkflow = Workflow.make({
+  name: "WorkflowEngineCosmos/IncrementWorkflow",
+  payload: { value: Schema.Number },
+  success: Schema.Number,
+  idempotencyKey: ({ value }) => String(value)
+})
+
+const IncrementHandler = IncrementWorkflow.toLayer(({ value }) => Effect.succeed(value + 1))
+
+// 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",
+  payload: { id: Schema.String },
+  success: Schema.Number,
+  idempotencyKey: ({ id }) => id
+})
+
+const CounterHandler = CounterWorkflow.toLayer(Effect.fn(function*() {
+  const counter = yield* CounterRef
+  return yield* Activity.make({
+    name: "Bump",
+    success: Schema.Number,
+    execute: Effect.sync(() => {
+      counter.count++
+      return counter.count
+    })
+  })
+}))
+
+// Suspends on a deferred, then composes the persisted activity result
+// 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",
+  payload: { id: Schema.String },
+  success: Schema.String,
+  idempotencyKey: ({ id }) => id
+})
+
+const SuspendHandler = SuspendWorkflow.toLayer(Effect.fn(function*({ id }) {
+  const n = yield* Activity.make({
+    name: "step",
+    success: Schema.Number,
+    execute: Effect.succeed(1)
+  })
+  const v = yield* DurableDeferred.await(Trigger)
+  return `${id}:${n}:${v}`
+}))
+
+// Plain durable-deferred await — used to assert first-writer-wins on done().
+const AwaitOnly = Workflow.make({
+  name: "WorkflowEngineCosmos/AwaitOnly",
+  payload: { id: Schema.String },
+  success: Schema.String,
+  idempotencyKey: ({ id }) => id
+})
+
+const AwaitOnlyHandler = AwaitOnly.toLayer(Effect.fn(function*() {
+  return yield* DurableDeferred.await(Trigger)
+}))
+
+const Handlers = Layer.mergeAll(IncrementHandler, SuspendHandler, CounterHandler, AwaitOnlyHandler)
+
+// Helper that polls until the workflow completes (or `maxIterations` elapse).
+const waitForComplete = (
+  workflow: { readonly poll: (id: string) => Effect.Effect<Option.Option<Workflow.Result<any, any>>, never, any> },
+  executionId: string,
+  step = Duration.millis(10),
+  maxIterations = 200
+) =>
+  Effect.gen(function*() {
+    for (let i = 0; i < maxIterations; i++) {
+      const polled = yield* workflow.poll(executionId)
+      if (Option.isSome(polled) && polled.value._tag === "Complete") {
+        return polled.value
+      }
+      yield* Effect.sleep(step)
+    }
+    return undefined
+  })
+
+const runSuite = (engineLayer: Layer.Layer<WorkflowEngine.WorkflowEngine>) => {
+  const TestLayer = Handlers.pipe(
+    Layer.provideMerge(CounterRef.layer),
+    Layer.provideMerge(engineLayer)
+  )
+
+  it.live("executes a workflow and polls the result", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* IncrementWorkflow.execute({ value: 41 }, { discard: true })
+        const result = yield* IncrementWorkflow.execute({ value: 41 })
+        const polled = yield* IncrementWorkflow.poll(executionId)
+
+        assert.strictEqual(result, 42)
+        assert(
+          Option.isSome(polled)
+            && polled.value._tag === "Complete"
+            && Exit.isSuccess(polled.value.exit)
+        )
+        assert.strictEqual(polled.value.exit.value, 42)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("re-executing the same id is idempotent", () =>
+    Effect
+      .gen(function*() {
+        const a = yield* IncrementWorkflow.execute({ value: 7 })
+        const b = yield* IncrementWorkflow.execute({ value: 7 })
+        assert.strictEqual(a, b)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("activity side effects run once across re-executions", () =>
+    Effect
+      .gen(function*() {
+        const counter = yield* CounterRef
+        yield* CounterWorkflow.execute({ id: "once" })
+        yield* CounterWorkflow.execute({ id: "once" })
+        yield* CounterWorkflow.execute({ id: "once" })
+        assert.strictEqual(counter.count, 1)
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("suspends on a durable deferred, then resumes with the decoded result", () =>
+    Effect
+      .gen(function*() {
+        // The execution suspends on `Trigger`; completing the deferred resumes
+        // it (the workflow body replays, the `step` activity is served from its
+        // persisted result), and the final value round-trips through the engine.
+        const executionId = yield* SuspendWorkflow.execute({ id: "abc" }, { discard: true })
+
+        const token = yield* DurableDeferred.tokenFromPayload(Trigger, {
+          workflow: SuspendWorkflow,
+          payload: { id: "abc" }
+        })
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("ok") })
+
+        const done = yield* waitForComplete(SuspendWorkflow, executionId)
+        assert(done && Exit.isSuccess(done.exit))
+        assert.strictEqual(done.exit.value, "abc:1:ok")
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("deferredDone is idempotent (first-writer-wins)", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* AwaitOnly.execute({ id: "dup" }, { discard: true })
+        const token = yield* DurableDeferred.tokenFromPayload(Trigger, {
+          workflow: AwaitOnly,
+          payload: { id: "dup" }
+        })
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("first") })
+        // Second completion must lose; the workflow body sees "first".
+        yield* DurableDeferred.done(Trigger, { token, exit: Exit.succeed("second") })
+
+        const done = yield* waitForComplete(AwaitOnly, executionId)
+        assert(done && Exit.isSuccess(done.exit))
+        assert.strictEqual(done.exit.value, "first")
+      })
+      .pipe(Effect.provide(TestLayer)))
+
+  it.live("interrupt eventually completes a suspended execution", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* AwaitOnly.execute({ id: "int" }, { discard: true })
+        // Give the workflow time to suspend on the deferred.
+        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")
+        }
+      })
+      .pipe(Effect.provide(TestLayer)))
+}
+
+describe("WorkflowEngine (in-memory)", () => {
+  runSuite(WorkflowEngine.layerMemory)
+})
+
+// --- Cosmos-emulator-only adapter tests --------------------------------
+//
+// Opt-in. Run with e.g.
+//   COSMOS_TEST_URL="https://localhost:8081" COSMOS_TEST_DB="workflow-test" \
+//   NODE_TLS_REJECT_UNAUTHORIZED=0 pnpm vitest run workflow-engine-cosmos
+const cosmosUrl = process.env["COSMOS_TEST_URL"]
+const cosmosDb = process.env["COSMOS_TEST_DB"] ?? "workflow-test"
+
+describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — conformance", () => {
+  runSuite(
+    layerCosmos({
+      url: Redacted.make(cosmosUrl ?? ""),
+      dbName: cosmosDb,
+      prefix: `test-${Date.now()}-`,
+      // Tight cadences so the suite doesn't wait on the background pollers.
+      recoveryInterval: Duration.seconds(2),
+      clockPollInterval: Duration.seconds(1)
+    })
+  )
+})
+
+describe.skipIf(!cosmosUrl)("WorkflowEngine (Cosmos) — adapter internals", () => {
+  // Each test gets its own container prefix so seeded docs don't leak.
+  const prefixFor = (label: string) => `test-${Date.now()}-${label}-`
+
+  const adapterLayer = (prefix: string) =>
+    Layer
+      .mergeAll(
+        IncrementHandler,
+        AwaitOnlyHandler,
+        CounterRef.layer,
+        CosmosClientLayer(cosmosUrl ?? "", cosmosDb)
+      )
+      .pipe(
+        Layer.provideMerge(
+          layerCosmos({
+            url: Redacted.make(cosmosUrl ?? ""),
+            dbName: cosmosDb,
+            prefix,
+            recoveryInterval: Duration.millis(500),
+            clockPollInterval: Duration.millis(500)
+          })
+        )
+      )
+
+  it.live("recovery poller drives execs with stale leases", () => {
+    const prefix = prefixFor("recovery")
+    const containerId = `${prefix}workflow-engine`
+    return Effect
+      .gen(function*() {
+        const { db } = yield* CosmosClient
+        const container = db.container(containerId)
+        // Pre-seed a running exec whose lease has already expired and whose
+        // payload is the schema-encoded form of `{ value: 99 }`.
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "exec",
+            _partitionKey: "recover-1",
+            type: "exec",
+            workflowName: IncrementWorkflow.name,
+            payload: JSON.stringify({ value: 99 }),
+            status: "running",
+            suspended: false,
+            interrupted: false,
+            worker: "ghost",
+            leaseExpiresAt: new Date(Date.now() - 60_000).toISOString(),
+            etag: "seed"
+          })
+        )
+
+        // Wait for the recovery poller (500ms cadence) to drive it.
+        yield* Effect.sleep(Duration.seconds(2))
+
+        const polled = yield* IncrementWorkflow.poll("recover-1")
+        assert(
+          Option.isSome(polled)
+            && polled.value._tag === "Complete"
+            && Exit.isSuccess(polled.value.exit)
+        )
+        assert.strictEqual(polled.value.exit.value, 100)
+      })
+      .pipe(Effect.provide(adapterLayer(prefix)))
+  })
+
+  it.live("clock poller fires past-due clocks", () => {
+    const prefix = prefixFor("clocks")
+    const containerId = `${prefix}workflow-engine`
+    return Effect
+      .gen(function*() {
+        const { db } = yield* CosmosClient
+        const container = db.container(containerId)
+        // Seed an exec + a clock that fired in the past. No in-process timer
+        // exists (we never called scheduleClock), so only the poller can
+        // resolve the deferred.
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "exec",
+            _partitionKey: "exec-clock",
+            type: "exec",
+            workflowName: AwaitOnly.name,
+            payload: JSON.stringify({ id: "wake" }),
+            status: "running",
+            suspended: false,
+            interrupted: false,
+            etag: "seed"
+          })
+        )
+        yield* Effect.promise(() =>
+          container.items.upsert({
+            id: "clock::wake",
+            _partitionKey: "exec-clock",
+            type: "clock",
+            workflowName: AwaitOnly.name,
+            deferredName: Trigger.name,
+            fireAt: new Date(Date.now() - 60_000).toISOString()
+          })
+        )
+
+        yield* Effect.sleep(Duration.seconds(2))
+
+        // 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 }>()
+        )
+        assert(deferred.resource !== undefined)
+        // And the clock doc has been deleted.
+        const clockGone = yield* Effect.promise(() => container.item("clock::wake", "exec-clock").read())
+        assert.strictEqual(clockGone.statusCode, 404)
+      })
+      .pipe(Effect.provide(adapterLayer(prefix)))
+  })
+})

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

@@ -0,0 +1,299 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { SqliteClient } from "@effect/sql-sqlite-node"
+import { assert, describe, it } from "@effect/vitest"
+import * as Context from "effect-app/Context"
+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 Duration from "effect/Duration"
+import * as Exit from "effect/Exit"
+import * as Schema from "effect/Schema"
+import { SqlClient } from "effect/unstable/sql"
+import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow"
+import { layerSqlite } from "../src/WorkflowEngineSqlite.js"
+
+// --- Shared mutable counter service -----------------------------------
+
+class CounterRef extends Context.Service<CounterRef, { count: number }>()("CounterRef") {
+  static readonly layer = Layer.effect(CounterRef, Effect.sync(() => ({ count: 0 })))
+}
+
+// --- Workflow definitions --------------------------------------------
+
+const Increment = Workflow.make({
+  name: "Sqlite/Increment",
+  payload: { value: Schema.Number },
+  success: Schema.Number,
+  idempotencyKey: ({ value }) => `inc-${value}`
+})
+
+const IncrementHandler = Increment.toLayer(Effect.fn(function*({ value }) {
+  const counter = yield* CounterRef
+  yield* Activity.make({
+    name: "Bump",
+    success: Schema.Number,
+    execute: Effect.sync(() => {
+      counter.count++
+      return counter.count
+    })
+  })
+  return value + 1
+}))
+
+const TickHandler = Increment.toLayer(({ value }) => Effect.succeed(value + 1))
+
+const EmailReceived = DurableDeferred.make("EmailReceived", { success: Schema.String })
+
+const AwaitEmail = Workflow.make({
+  name: "Sqlite/AwaitEmail",
+  payload: { id: Schema.String },
+  success: Schema.String,
+  idempotencyKey: ({ id }) => `email-${id}`
+})
+
+const AwaitEmailHandler = AwaitEmail.toLayer(Effect.fn(function*() {
+  return yield* DurableDeferred.await(EmailReceived)
+}))
+
+// Reproduces the adapter's opaque activity-result codec so tests can seed
+// schema-encoded values into the activity table directly.
+const ActivityResultCodec = S.fromJsonString(
+  S.toCodecJson(Workflow.Result({ success: S.Union([S.Any, S.Void]), error: S.Union([S.Any, S.Void]) }))
+)
+
+// --- Layer wiring ----------------------------------------------------
+
+type TestOpts = {
+  readonly recoveryInterval?: Duration.Duration
+  readonly clockPollInterval?: Duration.Duration
+}
+
+const makeBase = (opts?: TestOpts) => {
+  const Sqlite = SqliteClient.layer({ filename: ":memory:" })
+  const Engine = layerSqlite({
+    recoveryInterval: opts?.recoveryInterval ?? Duration.millis(100),
+    clockPollInterval: opts?.clockPollInterval ?? Duration.millis(100)
+  })
+    .pipe(Layer.provide(Sqlite))
+  return { Sqlite, Engine }
+}
+
+const incrementLayer = (opts?: TestOpts) => {
+  const { Sqlite, Engine } = makeBase(opts)
+  return IncrementHandler.pipe(
+    Layer.provideMerge(CounterRef.layer),
+    Layer.provideMerge(Engine),
+    Layer.provideMerge(Sqlite)
+  )
+}
+
+const tickLayer = (opts?: TestOpts) => {
+  const { Sqlite, Engine } = makeBase(opts)
+  return TickHandler.pipe(Layer.provideMerge(Engine), Layer.provideMerge(Sqlite))
+}
+
+const awaitEmailLayer = (opts?: TestOpts) => {
+  const { Sqlite, Engine } = makeBase(opts)
+  return AwaitEmailHandler.pipe(Layer.provideMerge(Engine), Layer.provideMerge(Sqlite))
+}
+
+// --- Tests ------------------------------------------------------------
+
+describe("WorkflowEngine (SQLite)", () => {
+  it.live("executes a workflow and persists completion", () =>
+    Effect
+      .gen(function*() {
+        const executionId = yield* Increment.execute({ value: 10 }, { discard: true })
+        const result = yield* Increment.execute({ value: 10 })
+        const polled = yield* Increment.poll(executionId)
+
+        assert.strictEqual(result, 11)
+        assert(
+          Option.isSome(polled)
+            && polled.value._tag === "Complete"
+            && Exit.isSuccess(polled.value.exit)
+        )
+        assert.strictEqual(polled.value.exit.value, 11)
+      })
+      .pipe(Effect.provide(incrementLayer())))
+
+  it.live("re-executing the same id is idempotent (activity runs once)", () =>
+    Effect
+      .gen(function*() {
+        const counter = yield* CounterRef
+        yield* Increment.execute({ value: 1 })
+        yield* Increment.execute({ value: 1 })
+        yield* Increment.execute({ value: 1 })
+        assert.strictEqual(counter.count, 1)
+      })
+      .pipe(Effect.provide(incrementLayer())))
+
+  it.live("persists activity results across replay", () =>
+    Effect
+      .gen(function*() {
+        const sql = yield* SqlClient.SqlClient
+        yield* Increment.execute({ value: 2 })
+        const rows = yield* sql
+          .unsafe(
+            `SELECT execution_id, name, attempt, result FROM workflow_activity`
+          )
+          .pipe(Effect.orDie)
+        assert.strictEqual(rows.length, 1)
+        assert.strictEqual((rows[0] as any).name, "Bump")
+        // Stored value is schema-encoded JSON, not a raw runtime object.
+        const decoded = S.decodeSync(ActivityResultCodec)((rows[0] as any).result)
+        assert.strictEqual(decoded._tag, "Complete")
+      })
+      .pipe(Effect.provide(incrementLayer())))
+
+  it.live("durable deferred completion resumes a suspended workflow", () =>
+    Effect
+      .gen(function*() {
+        const completion = Effect.gen(function*() {
+          yield* Effect.sleep(Duration.millis(50))
+          const token = yield* DurableDeferred.tokenFromPayload(EmailReceived, {
+            workflow: AwaitEmail,
+            payload: { id: "x" }
+          })
+          yield* DurableDeferred.done(EmailReceived, { token, exit: Exit.succeed("delivered") })
+        })
+        const [result] = yield* Effect.all(
+          [AwaitEmail.execute({ id: "x" }), completion],
+          { concurrency: "unbounded" }
+        )
+        assert.strictEqual(result, "delivered")
+      })
+      .pipe(Effect.provide(awaitEmailLayer())))
+
+  it.live("interrupt marks the execution row", () =>
+    Effect
+      .gen(function*() {
+        const sql = yield* SqlClient.SqlClient
+        const executionId = yield* AwaitEmail.executionId({ id: "i" })
+        // Start the workflow as discard (does not block) so it suspends in the
+        // background; then mark it interrupted.
+        yield* AwaitEmail.execute({ id: "i" }, { discard: true })
+        yield* Effect.sleep(Duration.millis(50))
+        yield* AwaitEmail.interrupt(executionId)
+        yield* Effect.sleep(Duration.millis(50))
+        const rows = yield* sql
+          .unsafe(
+            `SELECT interrupted FROM workflow_exec WHERE execution_id = ?`,
+            [executionId] as any
+          )
+          .pipe(Effect.orDie)
+        assert.strictEqual((rows[0] as any).interrupted, 1)
+      })
+      .pipe(Effect.provide(awaitEmailLayer())))
+
+  it.live("clock poller fires past-due clocks", () =>
+    Effect
+      .gen(function*() {
+        const sql = yield* SqlClient.SqlClient
+        yield* sql
+          .unsafe(
+            `INSERT INTO workflow_exec (execution_id, workflow_name, payload, status, suspended, interrupted, etag)
+         VALUES ('exec-clock', 'Sqlite/AwaitEmail', '{"id":"x"}', 'running', 0, 0, 'e1')`
+          )
+          .pipe(Effect.orDie)
+        yield* sql
+          .unsafe(
+            `INSERT INTO workflow_clock (execution_id, name, workflow_name, deferred_name, fire_at)
+         VALUES ('exec-clock', 'wake', 'Sqlite/AwaitEmail', 'EmailReceived', ?)`,
+            [Date.now() - 1000] as any
+          )
+          .pipe(Effect.orDie)
+
+        yield* Effect.sleep(Duration.millis(400))
+
+        const deferred = yield* sql
+          .unsafe(
+            `SELECT exit FROM workflow_deferred WHERE execution_id = 'exec-clock' AND name = 'EmailReceived'`
+          )
+          .pipe(Effect.orDie)
+        const clockGone = yield* sql
+          .unsafe(
+            `SELECT execution_id FROM workflow_clock WHERE execution_id = 'exec-clock' AND name = 'wake'`
+          )
+          .pipe(Effect.orDie)
+        assert.strictEqual(deferred.length, 1)
+        assert.strictEqual(clockGone.length, 0)
+      })
+      .pipe(Effect.provide(awaitEmailLayer())))
+
+  it.live("recovery poller drives execs with stale leases", () =>
+    Effect
+      .gen(function*() {
+        const sql = yield* SqlClient.SqlClient
+        yield* sql
+          .unsafe(
+            `INSERT INTO workflow_exec (execution_id, workflow_name, payload, status, suspended, interrupted, lease_expires_at, etag)
+         VALUES ('recover-1', 'Sqlite/Increment', '{"value":99}', 'running', 0, 0, 0, 'e0')`
+          )
+          .pipe(Effect.orDie)
+
+        yield* Effect.sleep(Duration.millis(500))
+
+        const rows = yield* sql
+          .unsafe(
+            `SELECT status, completed_result FROM workflow_exec WHERE execution_id = 'recover-1'`
+          )
+          .pipe(Effect.orDie)
+        assert.strictEqual((rows[0] as any).status, "complete")
+        const completedResult = JSON.parse((rows[0] as any).completed_result) as { _tag: string }
+        assert.strictEqual(completedResult._tag, "Complete")
+      })
+      .pipe(Effect.provide(tickLayer())))
+
+  it.live("activity dedup: a pre-existing persisted result wins over a fresh run", () =>
+    Effect
+      .gen(function*() {
+        const sql = yield* SqlClient.SqlClient
+        const counter = yield* CounterRef
+        const executionId = yield* Increment.executionId({ value: 7 })
+        yield* sql
+          .unsafe(
+            `INSERT INTO workflow_exec (execution_id, workflow_name, payload, status, suspended, interrupted, etag)
+         VALUES (?, 'Sqlite/Increment', '{"value":7}', 'running', 0, 0, 'e0')`,
+            [executionId] as any
+          )
+          .pipe(Effect.orDie)
+        const seeded = S.encodeSync(ActivityResultCodec)(
+          new Workflow.Complete({ exit: Exit.succeed(999) })
+        )
+        yield* sql
+          .unsafe(
+            `INSERT INTO workflow_activity (execution_id, name, attempt, result)
+         VALUES (?, 'Bump', 1, ?)`,
+            [executionId, seeded] as any
+          )
+          .pipe(Effect.orDie)
+
+        const result = yield* Increment.execute({ value: 7 })
+        assert.strictEqual(result, 8)
+        // Bump's user effect must NOT have run — counter stays at 0.
+        assert.strictEqual(counter.count, 0)
+      })
+      .pipe(Effect.provide(incrementLayer())))
+
+  it.live("deferredDone is idempotent (first-writer-wins)", () =>
+    Effect
+      .gen(function*() {
+        const completion = Effect.gen(function*() {
+          yield* Effect.sleep(Duration.millis(50))
+          const token = yield* DurableDeferred.tokenFromPayload(EmailReceived, {
+            workflow: AwaitEmail,
+            payload: { id: "dup" }
+          })
+          yield* DurableDeferred.done(EmailReceived, { token, exit: Exit.succeed("first") })
+          yield* DurableDeferred.done(EmailReceived, { token, exit: Exit.succeed("second") })
+        })
+        const [result] = yield* Effect.all(
+          [AwaitEmail.execute({ id: "dup" }), completion],
+          { concurrency: "unbounded" }
+        )
+        assert.strictEqual(result, "first")
+      })
+      .pipe(Effect.provide(awaitEmailLayer())))
+})