@yieldstar/runtime-conformance 0.0.0-stage → 0.6.1

package/dist/index.js

@@ -0,0 +1,3852 @@
+// src/index.ts
+import {
+  DEFAULT_LEASE_DURATION as DEFAULT_LEASE_DURATION3,
+  defineStore as defineStore2
+} from "@yieldstar/core";
+import { describe as describe3, expect as expect3, test as test3 } from "vitest";
+
+// src/effect.ts
+import {
+  DEFAULT_LEASE_DURATION,
+  EffectClientInvariantError,
+  redeliveryDelay,
+  registerErrorClass
+} from "@yieldstar/core";
+import { describe, expect, test } from "vitest";
+var START = 1e6;
+var LEASE = DEFAULT_LEASE_DURATION;
+var REDELIVER_AFTER = LEASE + redeliveryDelay(1);
+var OPERATION = "charge-v1";
+
+class CardDeclinedError extends Error {
+  code = "CARD_DECLINED";
+  declineCode;
+  constructor(declineCode) {
+    super(`Card declined: ${declineCode}`);
+    this.name = "ConformanceCardDeclinedError";
+    this.declineCode = declineCode;
+  }
+}
+registerErrorClass("ConformanceCardDeclinedError", CardDeclinedError);
+function registerEffectClientConformance({
+  name,
+  create
+}) {
+  async function setup() {
+    const clock = { now: START };
+    const harness = await create({ clock: () => clock.now });
+    const peer = await harness.createPeer?.() ?? harness.runtime;
+    return {
+      runtime: harness.runtime,
+      peer,
+      harness,
+      clock,
+      advance(ms) {
+        clock.now += ms;
+      }
+    };
+  }
+  function it(title, fn) {
+    test(title, async (testContext) => {
+      const ctx = await setup();
+      try {
+        await fn(ctx, testContext);
+      } finally {
+        await ctx.harness.dispose?.();
+      }
+    });
+  }
+  function itAfterRestart(title, fn) {
+    test(title, async (testContext) => {
+      const ctx = await setup();
+      try {
+        if (!ctx.harness.restart) {
+          testContext.skip();
+          return;
+        }
+        await fn({ ...ctx, restart: async () => ctx.harness.restart() });
+      } finally {
+        await ctx.harness.dispose?.();
+      }
+    });
+  }
+  function claim(runtime) {
+    return runtime.executions.claimDue({ limit: 100, duration: LEASE });
+  }
+  async function claimOne(runtime, executionId) {
+    const leases = await claim(runtime);
+    expect(leases.map((lease) => lease.executionId)).toEqual([executionId]);
+    return leases[0];
+  }
+  async function claimedIds(runtime) {
+    return (await claim(runtime)).map((lease) => lease.executionId).sort();
+  }
+  async function admitSuspended(runtime, executionId) {
+    const admitted = await runtime.executions.admit({
+      executionId,
+      workflowId: "charge-order",
+      params: { executionId },
+      context: new Map
+    });
+    expect(admitted).toEqual({ status: "accepted", executionId });
+    const lease = await claimOne(runtime, executionId);
+    await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+    return executionId;
+  }
+  async function reclaim(ctx, executionId) {
+    const stale = await claimOne(ctx.runtime, executionId);
+    ctx.advance(REDELIVER_AFTER);
+    const current = await claimOne(ctx.peer, executionId);
+    expect(current.token).toBeGreaterThan(stale.token);
+    return { stale, current };
+  }
+  function begin(runtime, effectId, options = {}) {
+    return runtime.effects.begin({
+      effectId,
+      operation: options.operation ?? OPERATION,
+      input: "input" in options ? options.input : { amount: 4999, currency: "usd" },
+      executionId: options.executionId ?? "order-42",
+      stepKey: options.stepKey ?? "charge"
+    });
+  }
+  function settle(runtime, effectId, result, operation = OPERATION) {
+    return runtime.effects.settle({ effectId, operation, result });
+  }
+  function watch(runtime, effectId, executionId, stepKey = "charge") {
+    return runtime.effects.watch({ effectId, executionId, stepKey });
+  }
+  function recordStep(runtime, lease, options = {}) {
+    return runtime.heap.writeStep({
+      lease,
+      stepKey: options.stepKey ?? "charge",
+      stepAttempt: options.attempt ?? 1,
+      done: options.done ?? true,
+      stepResponseJson: JSON.stringify({ paymentId: "pay_1" })
+    });
+  }
+  async function expectInvariant(promise) {
+    const error = await promise.then(() => {
+      throw new Error("expected an EffectClientInvariantError");
+    }, (err) => err);
+    expect(error).toBeInstanceOf(EffectClientInvariantError);
+    expect(error.code).toBe("EFFECT_RUNTIME_INVARIANT");
+  }
+  describe(`${name} effect client conformance`, () => {
+    describe("begin", () => {
+      it("creates one pending effect and returns its current state to repeated matching calls", async ({
+        runtime,
+        peer
+      }) => {
+        expect(await runtime.effects.getEffect("pay:42")).toBeUndefined();
+        expect(await begin(runtime, "pay:42")).toEqual({ status: "new" });
+        expect(await runtime.effects.getEffect("pay:42")).toEqual({
+          effectId: "pay:42",
+          operation: OPERATION,
+          input: { amount: 4999, currency: "usd" },
+          status: "pending",
+          conflicts: []
+        });
+        expect(await begin(runtime, "pay:42")).toEqual({ status: "pending" });
+        expect(await begin(peer, "pay:42")).toEqual({ status: "pending" });
+        expect(await begin(runtime, "pay:42", { executionId: "support", stepKey: "check" })).toEqual({ status: "pending" });
+        await settle(runtime, "pay:42", { paymentId: "pay_1" });
+        expect(await begin(peer, "pay:42")).toEqual({
+          status: "settled",
+          result: { paymentId: "pay_1" }
+        });
+      });
+      it("creates one effect for concurrent begins with one effect ID", async ({
+        runtime,
+        peer
+      }) => {
+        const results = await Promise.all([
+          begin(runtime, "pay:race"),
+          begin(peer, "pay:race"),
+          begin(runtime, "pay:race")
+        ]);
+        expect(results.map((result) => result.status).sort()).toEqual([
+          "new",
+          "pending",
+          "pending"
+        ]);
+        expect(await runtime.effects.getEffect("pay:race")).toMatchObject({
+          status: "pending"
+        });
+      });
+      it("matches input whose keys are in a different order", async ({ runtime }) => {
+        await begin(runtime, "pay:keys", { input: { a: 1, b: { c: 2, d: 3 } } });
+        expect(await begin(runtime, "pay:keys", { input: { b: { d: 3, c: 2 }, a: 1 } })).toEqual({ status: "pending" });
+      });
+      it("rejects a changed operation or input without changing the effect", async ({
+        runtime,
+        peer
+      }) => {
+        const mismatch = {
+          status: "rejected",
+          code: "EFFECT_REQUEST_MISMATCH"
+        };
+        await begin(runtime, "pay:changed");
+        const before = await runtime.effects.getEffect("pay:changed");
+        expect(await begin(runtime, "pay:changed", { operation: "charge-v2" })).toEqual(mismatch);
+        expect(await begin(peer, "pay:changed", { input: { amount: 5999, currency: "usd" } })).toEqual(mismatch);
+        expect(await begin(runtime, "pay:changed", {
+          input: { amount: 4999, currency: "usd", note: undefined }
+        })).toEqual(mismatch);
+        expect(await runtime.effects.getEffect("pay:changed")).toEqual(before);
+        await settle(runtime, "pay:changed", { paymentId: "pay_1" });
+        const settled = await runtime.effects.getEffect("pay:changed");
+        expect(await begin(runtime, "pay:changed", { operation: "charge-v2" })).toEqual(mismatch);
+        expect(await runtime.effects.getEffect("pay:changed")).toEqual(settled);
+      });
+      test.each([
+        ["an empty effect ID", { effectId: "" }],
+        ["an empty operation", { operation: "" }],
+        ["array input", { input: [] }],
+        ["a Date in the input", { input: { at: new Date(0) } }],
+        ["a non-finite number in the input", { input: { amount: Number.NaN } }],
+        ["an empty execution ID", { executionId: "" }],
+        ["an empty step key", { stepKey: "" }]
+      ])("throws EffectClientInvariantError for %s and creates nothing", async (_label, override) => {
+        const ctx = await setup();
+        try {
+          const request = {
+            effectId: "pay:invalid",
+            operation: OPERATION,
+            input: { amount: 4999 },
+            executionId: "order-42",
+            stepKey: "charge",
+            ...override
+          };
+          await expectInvariant(ctx.runtime.effects.begin(request));
+          expect(await ctx.runtime.effects.getEffect("pay:invalid")).toBeUndefined();
+        } finally {
+          await ctx.harness.dispose?.();
+        }
+      });
+    });
+    describe("settle", () => {
+      it("settles a pending effect and returns its result", async ({ runtime }) => {
+        await begin(runtime, "pay:settle");
+        expect(await settle(runtime, "pay:settle", { paymentId: "pay_1" })).toEqual({
+          status: "settled",
+          result: { paymentId: "pay_1" }
+        });
+        expect(await runtime.effects.getEffect("pay:settle")).toEqual({
+          effectId: "pay:settle",
+          operation: OPERATION,
+          input: { amount: 4999, currency: "usd" },
+          status: "settled",
+          result: { paymentId: "pay_1" },
+          conflicts: []
+        });
+      });
+      it("keeps one settled result when equal results settle concurrently", async ({
+        runtime,
+        peer
+      }) => {
+        await begin(runtime, "pay:equal");
+        const results = await Promise.all([
+          settle(runtime, "pay:equal", { paymentId: "pay_1", fee: 30 }),
+          settle(peer, "pay:equal", { fee: 30, paymentId: "pay_1" }),
+          settle(runtime, "pay:equal", { paymentId: "pay_1", fee: 30 })
+        ]);
+        for (const result of results) {
+          expect(result).toEqual({
+            status: "settled",
+            result: { paymentId: "pay_1", fee: 30 }
+          });
+        }
+        expect(await runtime.effects.getEffect("pay:equal")).toMatchObject({
+          status: "settled",
+          result: { paymentId: "pay_1", fee: 30 },
+          conflicts: []
+        });
+      });
+      it("keeps the first result and one conflict report when a different result settles", async ({
+        runtime,
+        peer,
+        clock,
+        advance
+      }) => {
+        await begin(runtime, "pay:conflict");
+        await settle(runtime, "pay:conflict", { paymentId: "pay_1" });
+        advance(10);
+        const reportedAt = clock.now;
+        const conflict = {
+          status: "conflict",
+          result: { paymentId: "pay_1" },
+          conflictingResult: { paymentId: "pay_2" }
+        };
+        expect(await settle(peer, "pay:conflict", { paymentId: "pay_2" })).toEqual(conflict);
+        advance(10);
+        expect(await settle(runtime, "pay:conflict", { paymentId: "pay_2" })).toEqual(conflict);
+        expect(await settle(runtime, "pay:conflict", { paymentId: "pay_1" })).toEqual({
+          status: "settled",
+          result: { paymentId: "pay_1" }
+        });
+        expect(await begin(runtime, "pay:conflict")).toEqual({
+          status: "settled",
+          result: { paymentId: "pay_1" }
+        });
+        expect(await runtime.effects.getEffect("pay:conflict")).toMatchObject({
+          status: "settled",
+          result: { paymentId: "pay_1" },
+          conflicts: [
+            {
+              result: { paymentId: "pay_1" },
+              conflictingResult: { paymentId: "pay_2" },
+              reportedAt
+            }
+          ]
+        });
+      });
+      it("settles once when different results settle concurrently", async ({
+        runtime,
+        peer
+      }) => {
+        await begin(runtime, "pay:race");
+        const results = await Promise.all([
+          settle(runtime, "pay:race", "first"),
+          settle(peer, "pay:race", "second")
+        ]);
+        const settled = results.filter((result) => result.status === "settled");
+        const conflicts = results.filter((result) => result.status === "conflict");
+        expect(settled).toHaveLength(1);
+        expect(conflicts).toHaveLength(1);
+        const winner = settled[0].result;
+        const loser = winner === "first" ? "second" : "first";
+        expect(conflicts[0]).toEqual({
+          status: "conflict",
+          result: winner,
+          conflictingResult: loser
+        });
+        const record = await runtime.effects.getEffect("pay:race");
+        expect(record?.result).toBe(winner);
+        expect(record?.conflicts).toEqual([
+          { result: winner, conflictingResult: loser, reportedAt: START }
+        ]);
+      });
+      it("stores undefined, errors and error-shaped objects without changing their type", async ({
+        runtime
+      }) => {
+        await begin(runtime, "delete:1");
+        expect(await settle(runtime, "delete:1", undefined)).toEqual({
+          status: "settled",
+          result: undefined
+        });
+        const deleted = await runtime.effects.getEffect("delete:1");
+        expect(deleted?.status).toBe("settled");
+        expect("result" in deleted).toBe(true);
+        expect(deleted?.result).toBeUndefined();
+        expect(await begin(runtime, "delete:1")).toEqual({
+          status: "settled",
+          result: undefined
+        });
+        const result = {
+          declined: new CardDeclinedError("insufficient_funds"),
+          report: { name: "Error", message: "not an error" },
+          tagged: { $type: "undefined" },
+          missing: undefined
+        };
+        await begin(runtime, "pay:values", {
+          input: { amount: 4999, note: undefined, shaped: { name: "E", message: "m" } }
+        });
+        await settle(runtime, "pay:values", result);
+        const begun = await begin(runtime, "pay:values", {
+          input: { amount: 4999, note: undefined, shaped: { name: "E", message: "m" } }
+        });
+        const record = await runtime.effects.getEffect("pay:values");
+        for (const stored of [
+          begun.result,
+          record.result
+        ]) {
+          expect(stored.declined).toBeInstanceOf(CardDeclinedError);
+          expect(stored.declined.message).toBe("Card declined: insufficient_funds");
+          expect(stored.declined.code).toBe("CARD_DECLINED");
+          expect(stored.declined.declineCode).toBe("insufficient_funds");
+          expect(stored.report).not.toBeInstanceOf(Error);
+          expect(stored.report).toEqual({ name: "Error", message: "not an error" });
+          expect(stored.tagged).toEqual({ $type: "undefined" });
+          expect(Object.keys(stored)).toContain("missing");
+        }
+        expect(record.input.shaped).not.toBeInstanceOf(Error);
+        expect(Object.keys(record.input)).toContain("note");
+      });
+      it("throws EffectClientInvariantError for an unknown effect, a changed operation or an invalid result", async ({
+        runtime
+      }) => {
+        await expectInvariant(settle(runtime, "pay:unknown", "result"));
+        expect(await runtime.effects.getEffect("pay:unknown")).toBeUndefined();
+        await begin(runtime, "pay:invariant");
+        await expectInvariant(settle(runtime, "pay:invariant", "result", "charge-v2"));
+        await expectInvariant(settle(runtime, "pay:invariant", { at: new Date(0) }));
+        expect(await runtime.effects.getEffect("pay:invariant")).toMatchObject({
+          status: "pending"
+        });
+      });
+    });
+    describe("watch and wakes", () => {
+      it("wakes every watching execution when the settlement commits", async ({
+        runtime,
+        peer
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await admitSuspended(runtime, "support");
+        await begin(runtime, "pay:watched");
+        await watch(runtime, "pay:watched", "order-42");
+        await watch(peer, "pay:watched", "support", "check");
+        expect(await claim(runtime)).toEqual([]);
+        await settle(peer, "pay:watched", { paymentId: "pay_1" });
+        expect(await claimedIds(runtime)).toEqual(["order-42", "support"]);
+      });
+      it("registers nothing when a watch fails before it commits, and a repeat succeeds as a first call", async ({ runtime, harness }, testContext) => {
+        if (!harness.failEffectWatches) {
+          testContext.skip();
+          return;
+        }
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:failed");
+        await begin(runtime, "pay:retried");
+        const restore = await harness.failEffectWatches();
+        try {
+          await expect(watch(runtime, "pay:failed", "order-42")).rejects.toThrow();
+          await expect(watch(runtime, "pay:retried", "order-42")).rejects.toThrow();
+        } finally {
+          await restore();
+        }
+        await settle(runtime, "pay:failed", "done");
+        expect(await claim(runtime)).toEqual([]);
+        await watch(runtime, "pay:retried", "order-42");
+        expect(await claim(runtime)).toEqual([]);
+        await settle(runtime, "pay:retried", "done");
+        expect(await claimedIds(runtime)).toEqual(["order-42"]);
+      });
+      it("keeps one registration when a watch is repeated after a lost response", async ({
+        runtime,
+        peer
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:repeated");
+        await watch(runtime, "pay:repeated", "order-42");
+        await watch(peer, "pay:repeated", "order-42");
+        await watch(runtime, "pay:repeated", "order-42");
+        await runtime.executions.requestWake({
+          executionId: "order-42",
+          wakeAt: START
+        });
+        const lease = await claimOne(runtime, "order-42");
+        await recordStep(runtime, lease);
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        await settle(runtime, "pay:repeated", "done");
+        expect(await claim(runtime)).toEqual([]);
+      });
+      it("wakes the execution at once when the effect is already settled, on every watch", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:settled");
+        await settle(runtime, "pay:settled", "done");
+        await watch(runtime, "pay:settled", "order-42");
+        const lease = await claimOne(runtime, "order-42");
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        expect(await claim(runtime)).toEqual([]);
+        await watch(runtime, "pay:settled", "order-42");
+        expect(await claimedIds(runtime)).toEqual(["order-42"]);
+      });
+      it("wakes the watching execution when settlement races with watch", async ({
+        runtime,
+        peer
+      }) => {
+        for (let i = 0;i < 10; i++) {
+          const executionId = `racer-${i}`;
+          const effectId = `pay:race-${i}`;
+          await admitSuspended(runtime, executionId);
+          await begin(runtime, effectId);
+          const watching = watch(i % 2 ? runtime : peer, effectId, executionId);
+          const settling = settle(i % 2 ? peer : runtime, effectId, "done");
+          await Promise.all(i % 4 < 2 ? [watching, settling] : [settling, watching]);
+          expect(await claimedIds(runtime)).toEqual([executionId]);
+        }
+      });
+      it("deletes a waiter in the write that records its step's result, so a later settlement does not wake", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:recorded");
+        await begin(runtime, "pay:other");
+        await watch(runtime, "pay:recorded", "order-42", "charge");
+        await watch(runtime, "pay:other", "order-42", "refund");
+        await runtime.executions.requestWake({ executionId: "order-42", wakeAt: START });
+        const unfinished = await claimOne(runtime, "order-42");
+        await recordStep(runtime, unfinished, { attempt: 1, done: false });
+        await runtime.executions.acknowledge({
+          lease: unfinished,
+          outcome: { status: "suspended" }
+        });
+        await runtime.executions.requestWake({ executionId: "order-42", wakeAt: START });
+        const lease = await claimOne(runtime, "order-42");
+        await recordStep(runtime, lease, { attempt: 2 });
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        await settle(runtime, "pay:recorded", "done");
+        expect(await claim(runtime)).toEqual([]);
+        await settle(runtime, "pay:other", "done");
+        expect(await claimedIds(runtime)).toEqual(["order-42"]);
+      });
+      it("keeps the waiter when a stale holder's step result is rejected", async (ctx) => {
+        const { runtime } = ctx;
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:stale");
+        await watch(runtime, "pay:stale", "order-42");
+        await runtime.executions.requestWake({ executionId: "order-42", wakeAt: START });
+        const { stale, current } = await reclaim(ctx, "order-42");
+        expect(await recordStep(runtime, stale)).toEqual({ status: "lost" });
+        await ctx.peer.executions.acknowledge({
+          lease: current,
+          outcome: { status: "suspended" }
+        });
+        await settle(runtime, "pay:stale", "done");
+        expect(await claimedIds(runtime)).toEqual(["order-42"]);
+      });
+      it("settles without waking a terminal execution", async ({ runtime }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:terminal");
+        await watch(runtime, "pay:terminal", "order-42");
+        await runtime.executions.requestWake({ executionId: "order-42", wakeAt: START });
+        const lease = await claimOne(runtime, "order-42");
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: null }
+        });
+        expect(await settle(runtime, "pay:terminal", "done")).toEqual({
+          status: "settled",
+          result: "done"
+        });
+        expect(await claim(runtime)).toEqual([]);
+        expect(await runtime.executions.get("order-42")).toMatchObject({
+          status: "completed"
+        });
+      });
+      it("throws EffectClientInvariantError when watching an unknown effect", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await expectInvariant(watch(runtime, "pay:unknown", "order-42"));
+        await begin(runtime, "pay:unknown");
+        await settle(runtime, "pay:unknown", "done");
+        expect(await claim(runtime)).toEqual([]);
+      });
+    });
+    describe("getEffect", () => {
+      it("returns the first result and the conflict report after a conflicting settlement", async ({
+        runtime,
+        peer
+      }) => {
+        await begin(runtime, "pay:report");
+        await settle(runtime, "pay:report", { paymentId: "pay_1" });
+        await settle(runtime, "pay:report", { paymentId: "pay_2" });
+        await settle(runtime, "pay:report", { paymentId: "pay_3" });
+        expect(await peer.effects.getEffect("pay:report")).toEqual({
+          effectId: "pay:report",
+          operation: OPERATION,
+          input: { amount: 4999, currency: "usd" },
+          status: "settled",
+          result: { paymentId: "pay_1" },
+          conflicts: [
+            {
+              result: { paymentId: "pay_1" },
+              conflictingResult: { paymentId: "pay_2" },
+              reportedAt: START
+            },
+            {
+              result: { paymentId: "pay_1" },
+              conflictingResult: { paymentId: "pay_3" },
+              reportedAt: START
+            }
+          ]
+        });
+      });
+      it("returns a copy that callers cannot use to change the record", async ({
+        runtime
+      }) => {
+        const input = { amount: 4999, nested: { currency: "usd" } };
+        await begin(runtime, "pay:copy", { input });
+        input.nested.currency = "eur";
+        const record = await runtime.effects.getEffect("pay:copy");
+        record.input.nested.currency = "gbp";
+        expect((await runtime.effects.getEffect("pay:copy")).input).toEqual({
+          amount: 4999,
+          nested: { currency: "usd" }
+        });
+      });
+    });
+    describe("durability", () => {
+      itAfterRestart("resumes delivery of stored wakes after a restart", async ({
+        runtime,
+        restart
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:wake");
+        await watch(runtime, "pay:wake", "order-42");
+        await settle(runtime, "pay:wake", "done");
+        const restarted = await restart();
+        expect(await claimedIds(restarted)).toEqual(["order-42"]);
+      });
+      itAfterRestart("keeps effects, conflict reports and waiters across a restart", async ({
+        runtime,
+        restart
+      }) => {
+        await admitSuspended(runtime, "order-42");
+        await begin(runtime, "pay:pending");
+        await watch(runtime, "pay:pending", "order-42");
+        await begin(runtime, "pay:conflict");
+        await settle(runtime, "pay:conflict", "first");
+        await settle(runtime, "pay:conflict", "second");
+        const conflicted = await runtime.effects.getEffect("pay:conflict");
+        const restarted = await restart();
+        expect(await restarted.effects.getEffect("pay:conflict")).toEqual(conflicted);
+        expect(await begin(restarted, "pay:pending")).toEqual({ status: "pending" });
+        expect(await claim(restarted)).toEqual([]);
+        await settle(restarted, "pay:pending", "done");
+        expect(await claimedIds(restarted)).toEqual(["order-42"]);
+      });
+    });
+  });
+}
+// src/execution.ts
+import {
+  DEFAULT_LEASE_DURATION as DEFAULT_LEASE_DURATION2,
+  defineStore,
+  durableValueCodec,
+  redeliveryDelay as redeliveryDelay2,
+  registerErrorClass as registerErrorClass2
+} from "@yieldstar/core";
+import { describe as describe2, expect as expect2, test as test2 } from "vitest";
+var START2 = 1e6;
+var LEASE2 = DEFAULT_LEASE_DURATION2;
+var REDELIVER_AFTER2 = LEASE2 + redeliveryDelay2(1);
+function schema() {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "yieldstar-execution-conformance",
+      validate(value) {
+        return { value };
+      }
+    }
+  };
+}
+
+class Point {
+  x;
+  constructor(x) {
+    this.x = x;
+  }
+}
+
+class PaymentDeclinedError extends Error {
+  code = "CARD_DECLINED";
+  constructor(message) {
+    super(message);
+    this.name = "PaymentDeclinedError";
+  }
+}
+
+class GatewayTimeoutError extends Error {
+  gateway;
+  constructor(gateway, options) {
+    super(`${gateway} timed out`, options);
+    this.name = "ConformanceGatewayTimeoutError";
+    this.gateway = gateway;
+  }
+}
+registerErrorClass2("ConformanceGatewayTimeoutError", GatewayTimeoutError);
+function registerExecutionClientConformance({
+  name,
+  create
+}) {
+  const Store = defineStore(`${name}-execution-conformance`, schema(), {
+    initial: () => ({ messages: [] })
+  });
+  async function setup() {
+    const clock = { now: START2 };
+    const harness = await create({
+      clock: () => clock.now
+    });
+    return {
+      runtime: harness.runtime,
+      harness,
+      clock,
+      advance(ms) {
+        clock.now += ms;
+      }
+    };
+  }
+  function it(title, fn) {
+    test2(title, async (testContext) => {
+      const ctx = await setup();
+      try {
+        await fn(ctx, testContext);
+      } finally {
+        await ctx.harness.dispose?.();
+      }
+    });
+  }
+  function itAfterRestart(title, fn) {
+    test2(title, async (testContext) => {
+      const ctx = await setup();
+      try {
+        if (!ctx.harness.restart) {
+          testContext.skip();
+          return;
+        }
+        await fn({ ...ctx, restart: async () => ctx.harness.restart() });
+      } finally {
+        await ctx.harness.dispose?.();
+      }
+    });
+  }
+  async function admit(runtime, executionId, workflowId = "workflow") {
+    const admitted = await runtime.executions.admit({
+      executionId,
+      workflowId,
+      params: { executionId },
+      context: new Map
+    });
+    expect2(admitted).toEqual({ status: "accepted", executionId });
+    return executionId;
+  }
+  function startFrom(runtime, callerExecutionId, stepKey, target = {}) {
+    return runtime.executions.start({
+      requestId: { executionId: callerExecutionId, stepKey },
+      workflowId: target.workflowId ?? "ship-order",
+      params: "params" in target ? target.params : { callerExecutionId, stepKey }
+    });
+  }
+  function acceptedId(result) {
+    if (result.status !== "accepted") {
+      throw new Error(`start rejected: ${result.code}: ${result.message}`);
+    }
+    return result.executionId;
+  }
+  function claim(runtime, limit = 100) {
+    return runtime.executions.claimDue({ limit, duration: LEASE2 });
+  }
+  async function claimOne(runtime, executionId) {
+    const leases = await claim(runtime);
+    expect2(leases.map((d) => d.executionId)).toEqual([executionId]);
+    return leases[0];
+  }
+  async function claimedIds(runtime) {
+    return (await claim(runtime)).map((d) => d.executionId).sort();
+  }
+  async function drain(runtime) {
+    const leases = await claim(runtime);
+    for (const lease of leases) {
+      await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+    }
+    return leases.map((d) => d.executionId).sort();
+  }
+  async function admitSuspended(runtime, executionId) {
+    await admit(runtime, executionId);
+    const lease = await claimOne(runtime, executionId);
+    expect2(await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } })).toEqual({ status: "suspended" });
+    return executionId;
+  }
+  async function admitCompleted(runtime, executionId, result) {
+    await admit(runtime, executionId);
+    const lease = await claimOne(runtime, executionId);
+    await runtime.executions.acknowledge({
+      lease,
+      outcome: { status: "completed", result }
+    });
+    return lease;
+  }
+  function waiter(executionId, instanceId, sinceVersion) {
+    return {
+      workflowId: "workflow",
+      executionId,
+      stepKey: "wait-for-message",
+      storeName: Store.name,
+      storeId: executionId,
+      instanceId,
+      sinceVersion,
+      readPaths: [["messages"]]
+    };
+  }
+  async function appendMessage(runtime, storeId, id) {
+    return runtime.stores.updateStore({
+      definition: Store,
+      id: storeId,
+      updater(draft) {
+        draft.messages.push({ id });
+      }
+    });
+  }
+  describe2(`${name} execution client conformance`, () => {
+    describe2("admission", () => {
+      it("reserves and returns an unused caller-supplied ID", async ({ runtime }) => {
+        expect2(await runtime.executions.admit({
+          executionId: "order-42",
+          workflowId: "charge-order",
+          params: { orderId: 42 },
+          context: new Map
+        })).toEqual({ status: "accepted", executionId: "order-42" });
+        expect2(await runtime.executions.get("order-42")).toMatchObject({
+          executionId: "order-42",
+          workflowId: "charge-order"
+        });
+      });
+      it("rejects an ID in use and leaves the existing record unchanged", async ({
+        runtime,
+        advance
+      }) => {
+        await runtime.executions.admit({
+          executionId: "order-42",
+          workflowId: "charge-order",
+          params: { orderId: 42 },
+          context: new Map([["tenant", "acme"]])
+        });
+        const before = await runtime.executions.get("order-42");
+        advance(10);
+        const conflict = await runtime.executions.admit({
+          executionId: "order-42",
+          workflowId: "refund-order",
+          params: { orderId: 43 },
+          context: new Map([["tenant", "other"]])
+        });
+        expect2(conflict).toMatchObject({
+          status: "rejected",
+          code: "EXECUTION_ID_CONFLICT"
+        });
+        expect2(conflict.status === "rejected" && typeof conflict.message).toBe("string");
+        const after = await runtime.executions.get("order-42");
+        expect2(after).toEqual(before);
+        expect2([...after.context.entries()]).toEqual([["tenant", "acme"]]);
+        expect2(await claimedIds(runtime)).toEqual(["order-42"]);
+      });
+      it("keeps the ID reserved after a delivery fails", async ({ runtime, advance }) => {
+        await admit(runtime, "fails");
+        const lease = await claimOne(runtime, "fails");
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "failed", error: new Error("boom") }
+        });
+        expect2(await runtime.executions.admit({
+          executionId: "fails",
+          workflowId: "workflow",
+          params: undefined,
+          context: new Map
+        })).toMatchObject({ status: "rejected", code: "EXECUTION_ID_CONFLICT" });
+        await admit(runtime, "crashes");
+        await claimOne(runtime, "crashes");
+        advance(REDELIVER_AFTER2);
+        expect2(await runtime.executions.admit({
+          executionId: "crashes",
+          workflowId: "workflow",
+          params: undefined,
+          context: new Map
+        })).toMatchObject({ status: "rejected", code: "EXECUTION_ID_CONFLICT" });
+      });
+      it("chooses a new ID when none is supplied", async ({ runtime }) => {
+        await admit(runtime, "existing");
+        const ids = new Set(["existing"]);
+        for (let i = 0;i < 20; i++) {
+          const admitted = await runtime.executions.admit({
+            workflowId: "workflow",
+            params: { i },
+            context: new Map
+          });
+          if (admitted.status !== "accepted")
+            throw new Error("admission rejected");
+          expect2(typeof admitted.executionId).toBe("string");
+          expect2(admitted.executionId).not.toBe("");
+          expect2(ids.has(admitted.executionId)).toBe(false);
+          ids.add(admitted.executionId);
+          expect2(await runtime.executions.get(admitted.executionId)).toMatchObject({
+            params: { i }
+          });
+        }
+      });
+      it("stores the event once and get returns it exactly as admitted", async ({
+        runtime
+      }) => {
+        const params = {
+          text: "é\uD83D\uDE80",
+          int: 42,
+          float: 1.5,
+          negative: -3,
+          yes: true,
+          no: false,
+          nothing: null,
+          list: [1, "two", { three: [null] }],
+          nested: { a: { b: { c: "d" } } },
+          empty: {},
+          missing: undefined,
+          holes: [1, undefined],
+          tagged: { $type: "undefined" },
+          report: { name: "launch", message: "Ship it", stack: "web" }
+        };
+        const context = new Map([
+          ["tenant", "acme"],
+          ["count", 2],
+          ["7", { roles: ["admin"] }],
+          ["nothing", undefined]
+        ]);
+        await runtime.executions.admit({
+          executionId: "event",
+          workflowId: "charge-order",
+          params,
+          context
+        });
+        params.nested.a.b.c = "mutated";
+        context.set("tenant", "mutated");
+        const record = await runtime.executions.get("event");
+        expect2(record).toBeDefined();
+        expect2(record.workflowId).toBe("charge-order");
+        expect2(record.params).toEqual({
+          ...params,
+          nested: { a: { b: { c: "d" } } }
+        });
+        const ctx = record.context;
+        expect2(typeof ctx.get).toBe("function");
+        expect2(typeof ctx.has).toBe("function");
+        expect2(Object.keys(record.params)).toContain("missing");
+        expect2(record.params.report).not.toBeInstanceOf(Error);
+        expect2(ctx.size).toBe(4);
+        expect2(ctx.get("tenant")).toBe("acme");
+        expect2(ctx.get("7")).toEqual({ roles: ["admin"] });
+        expect2([...ctx.entries()]).toEqual([
+          ["tenant", "acme"],
+          ["count", 2],
+          ["7", { roles: ["admin"] }],
+          ["nothing", undefined]
+        ]);
+        await runtime.executions.admit({
+          executionId: "no-params",
+          workflowId: "workflow",
+          params: undefined,
+          context: new Map
+        });
+        const bare = await runtime.executions.get("no-params");
+        expect2(bare.params).toBeUndefined();
+        expect2(bare.context.size).toBe(0);
+      });
+      it("hands out leases that name the execution, not a copy of its event", async ({
+        runtime,
+        clock
+      }) => {
+        await runtime.executions.admit({
+          executionId: "delivery",
+          workflowId: "charge-order",
+          params: { orderId: 42 },
+          context: new Map([["tenant", "acme"]])
+        });
+        const [lease] = await claim(runtime);
+        expect2(Object.keys(lease).sort()).toEqual(["executionId", "expiresAt", "token"]);
+        expect2(lease.executionId).toBe("delivery");
+        expect2(typeof lease.token).toBe("number");
+        expect2(lease.expiresAt).toBe(clock.now + LEASE2);
+        const record = await runtime.executions.get(lease.executionId);
+        expect2(record).toMatchObject({
+          workflowId: "charge-order",
+          params: { orderId: 42 }
+        });
+        expect2(record.context.get("tenant")).toBe("acme");
+      });
+      const cyclic = {};
+      cyclic.self = cyclic;
+      const invalidEvents = [
+        ["a Date", { params: { at: new Date(0) }, context: new Map }],
+        ["a class instance", { params: { point: new Point(1) }, context: new Map }],
+        ["NaN", { params: { n: NaN }, context: new Map }],
+        ["Infinity", { params: { n: Infinity }, context: new Map }],
+        ["a bigint", { params: { n: 10n }, context: new Map }],
+        ["a function", { params: { fn: () => 1 }, context: new Map }],
+        ["a Map", { params: { map: new Map([["a", 1]]) }, context: new Map }],
+        ["a sparse array", { params: { list: [1, , 3] }, context: new Map }],
+        ["a cycle", { params: cyclic, context: new Map }],
+        ["a Date in context", { params: {}, context: new Map([["at", new Date(0)]]) }],
+        ["an object context key", { params: {}, context: new Map([[{}, 1]]) }],
+        ["a number context key", { params: {}, context: new Map([[7, 1]]) }]
+      ];
+      for (const [label, event] of invalidEvents) {
+        it(`rejects ${label} with INVALID_EXECUTION_EVENT and stores nothing`, async ({
+          runtime
+        }) => {
+          const rejected = await runtime.executions.admit({
+            executionId: "invalid",
+            workflowId: "workflow",
+            ...event
+          });
+          expect2(rejected).toMatchObject({
+            status: "rejected",
+            code: "INVALID_EXECUTION_EVENT"
+          });
+          expect2(await runtime.executions.get("invalid")).toBeUndefined();
+          expect2(await claim(runtime)).toEqual([]);
+          await admit(runtime, "invalid");
+        });
+      }
+      it("creates an admitted record that claimDue returns", async ({ runtime, clock }) => {
+        await admit(runtime, "admitted");
+        expect2(await runtime.executions.get("admitted")).toMatchObject({
+          status: "admitted",
+          admittedAt: clock.now,
+          updatedAt: clock.now
+        });
+        expect2((await runtime.executions.get("admitted")).outcome).toBeUndefined();
+        await claimOne(runtime, "admitted");
+      });
+    });
+    describe2("wakes", () => {
+      it("returns an execution once when two wakes are requested before a delivery", async ({
+        runtime,
+        clock
+      }) => {
+        await admitSuspended(runtime, "twice");
+        expect2(await runtime.executions.requestWake({ executionId: "twice", wakeAt: clock.now })).toEqual({ status: "requested" });
+        expect2(await runtime.executions.requestWake({ executionId: "twice", wakeAt: clock.now })).toEqual({ status: "requested" });
+        expect2(await claimedIds(runtime)).toEqual(["twice"]);
+        await admit(runtime, "admitted-and-woken");
+        await runtime.executions.requestWake({
+          executionId: "admitted-and-woken",
+          wakeAt: clock.now
+        });
+        expect2(await claimedIds(runtime)).toEqual(["admitted-and-woken"]);
+      });
+      it("merges wakes into the earliest requested time", async ({ runtime, clock, advance }) => {
+        await admitSuspended(runtime, "earliest");
+        await runtime.executions.requestWake({ executionId: "earliest", wakeAt: clock.now + 200 });
+        await runtime.executions.requestWake({ executionId: "earliest", wakeAt: clock.now + 100 });
+        await runtime.executions.requestWake({ executionId: "earliest", wakeAt: clock.now + 300 });
+        advance(99);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["earliest"]);
+      });
+      it("keeps a wake requested during a delivery after it acknowledges", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "during");
+        const lease = await claimOne(runtime, "during");
+        await runtime.executions.requestWake({ executionId: "during", wakeAt: clock.now + 50 });
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        advance(49);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["during"]);
+      });
+      it("makes a suspended delivery due at its wakeAt", async ({ runtime, clock, advance }) => {
+        await admit(runtime, "delay");
+        const lease = await claimOne(runtime, "delay");
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "suspended", wakeAt: clock.now + 500 }
+        });
+        advance(499);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["delay"]);
+      });
+      it("prefers an earlier wake requested during a delivery over its wakeAt", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "race");
+        const lease = await claimOne(runtime, "race");
+        await runtime.executions.requestWake({ executionId: "race", wakeAt: clock.now + 100 });
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "suspended", wakeAt: clock.now + 500 }
+        });
+        advance(99);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["race"]);
+      });
+      it("does not make a suspended delivery due without wakeAt or a new wake", async ({
+        runtime,
+        advance
+      }) => {
+        await admitSuspended(runtime, "idle");
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+        expect2(await runtime.executions.get("idle")).toMatchObject({ status: "suspended" });
+      });
+      it("redelivers an unacknowledged delivery whose paused step reached wakeAt", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "paused");
+        const first = await claimOne(runtime, "paused");
+        await runtime.executions.acknowledge({
+          lease: first,
+          outcome: { status: "suspended", wakeAt: clock.now + 100 }
+        });
+        advance(100);
+        const second = await claimOne(runtime, "paused");
+        advance(REDELIVER_AFTER2 - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        const third = await claimOne(runtime, "paused");
+        expect2(third.token).toBeGreaterThan(second.token);
+        expect2(await runtime.executions.acknowledge({
+          lease: third,
+          outcome: { status: "completed", result: "done" }
+        })).toEqual({ status: "completed", result: "done" });
+      });
+      it("does not let a future wake requested during a past-due delivery inherit its due time", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admitSuspended(runtime, "past-due");
+        await runtime.executions.requestWake({ executionId: "past-due", wakeAt: clock.now - 500 });
+        const lease = await claimOne(runtime, "past-due");
+        await runtime.executions.requestWake({ executionId: "past-due", wakeAt: clock.now + 300 });
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        expect2(await claim(runtime)).toEqual([]);
+        advance(299);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["past-due"]);
+      });
+      it("rejects a wake for an unknown execution without creating a record", async ({
+        runtime,
+        clock
+      }) => {
+        const result = await runtime.executions.requestWake({
+          executionId: "ghost",
+          wakeAt: clock.now
+        });
+        expect2(result).toMatchObject({ status: "rejected", code: "EXECUTION_NOT_FOUND" });
+        expect2(result.status === "rejected" && typeof result.message).toBe("string");
+        expect2(await runtime.executions.get("ghost")).toBeUndefined();
+        expect2(await claim(runtime)).toEqual([]);
+        await admit(runtime, "ghost");
+      });
+      it("does not return a leased execution again before its lease expires", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "claimed");
+        await claimOne(runtime, "claimed");
+        expect2(await claim(runtime)).toEqual([]);
+        await runtime.executions.requestWake({ executionId: "claimed", wakeAt: clock.now });
+        advance(REDELIVER_AFTER2 - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        expect2(await claimedIds(runtime)).toEqual(["claimed"]);
+      });
+      it("keeps the wakes of a never-acknowledged delivery pending and redelivers it", async ({
+        runtime,
+        advance
+      }) => {
+        await admit(runtime, "lost");
+        const first = await claimOne(runtime, "lost");
+        advance(REDELIVER_AFTER2);
+        expect2(await runtime.executions.get("lost")).toMatchObject({ status: "admitted" });
+        const second = await claimOne(runtime, "lost");
+        expect2(second.token).toBeGreaterThan(first.token);
+        await runtime.executions.acknowledge({
+          lease: second,
+          outcome: { status: "suspended" }
+        });
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("ignores a wake for a terminal execution", async ({ runtime, clock, advance }) => {
+        await admitCompleted(runtime, "done", 1);
+        await admit(runtime, "failed");
+        const lease = await claimOne(runtime, "failed");
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "failed", error: new Error("boom") }
+        });
+        for (const executionId of ["done", "failed"]) {
+          expect2(await runtime.executions.requestWake({ executionId, wakeAt: clock.now })).toEqual({ status: "ignored" });
+        }
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("clears pending wakes when an execution reaches a terminal status", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "finishing");
+        const lease = await claimOne(runtime, "finishing");
+        await runtime.executions.requestWake({ executionId: "finishing", wakeAt: clock.now });
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: null }
+        });
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("returns each due execution at most once per claim", async ({ runtime, clock }) => {
+        for (const id of ["a", "b", "c"])
+          await admit(runtime, id);
+        await runtime.executions.requestWake({ executionId: "b", wakeAt: clock.now - 1 });
+        await runtime.executions.requestWake({ executionId: "b", wakeAt: clock.now });
+        expect2(await claimedIds(runtime)).toEqual(["a", "b", "c"]);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+    });
+    describe2("store waiters", () => {
+      it("wakes a waiting execution when a store commit satisfies its waiter", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "consumer");
+        const snapshot = await runtime.stores.getStore({
+          definition: Store,
+          id: "consumer"
+        });
+        await runtime.stores.registerWaiter(waiter("consumer", snapshot.instanceId, snapshot.version));
+        expect2(await claim(runtime)).toEqual([]);
+        await appendMessage(runtime, "consumer", "m1");
+        expect2(await claimedIds(runtime)).toEqual(["consumer"]);
+      });
+      it("deletes a waiter with the write that records its step's result", async ({
+        runtime,
+        clock
+      }) => {
+        await admitSuspended(runtime, "recorded");
+        const snapshot = await runtime.stores.getStore({
+          definition: Store,
+          id: "recorded"
+        });
+        const registered = waiter("recorded", snapshot.instanceId, snapshot.version);
+        await runtime.stores.registerWaiter(registered);
+        await runtime.executions.requestWake({ executionId: "recorded", wakeAt: clock.now });
+        const waiting = await claimOne(runtime, "recorded");
+        await runtime.heap.writeStep({
+          lease: waiting,
+          stepKey: registered.stepKey,
+          stepAttempt: 1,
+          done: false,
+          stepResponseJson: JSON.stringify({ waiting: true })
+        });
+        await runtime.executions.acknowledge({
+          lease: waiting,
+          outcome: { status: "suspended" }
+        });
+        await appendMessage(runtime, "recorded", "m1");
+        const lease = await claimOne(runtime, "recorded");
+        await runtime.heap.writeStep({
+          lease,
+          stepKey: registered.stepKey,
+          stepAttempt: 2,
+          done: true,
+          stepResponseJson: JSON.stringify({ id: "m1" })
+        });
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        await appendMessage(runtime, "recorded", "m2");
+        expect2(await claim(runtime)).toEqual([]);
+      });
+    });
+    describe2("clock", () => {
+      it("reads time from the runtime clock, not the wall clock", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        clock.now = 5000;
+        await admit(runtime, "clocked");
+        expect2(await runtime.executions.get("clocked")).toMatchObject({
+          admittedAt: 5000,
+          updatedAt: 5000
+        });
+        const lease = await claimOne(runtime, "clocked");
+        advance(7);
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "suspended", wakeAt: Date.now() }
+        });
+        expect2(await runtime.executions.get("clocked")).toMatchObject({
+          status: "suspended",
+          updatedAt: 5007
+        });
+        expect2(await claim(runtime)).toEqual([]);
+        await runtime.executions.requestWake({ executionId: "clocked", wakeAt: 5100 });
+        advance(92);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        await claimOne(runtime, "clocked");
+        advance(REDELIVER_AFTER2 - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        await claimOne(runtime, "clocked");
+      });
+    });
+    describe2("outcomes", () => {
+      it("records a suspended acknowledgement without an outcome", async ({
+        runtime,
+        advance,
+        clock
+      }) => {
+        await admit(runtime, "suspends");
+        const lease = await claimOne(runtime, "suspends");
+        advance(5);
+        expect2(await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "suspended", wakeAt: clock.now + 1000 }
+        })).toEqual({ status: "suspended" });
+        const record = await runtime.executions.get("suspends");
+        expect2(record).toMatchObject({
+          status: "suspended",
+          admittedAt: START2,
+          updatedAt: START2 + 5
+        });
+        expect2(record.outcome).toBeUndefined();
+      });
+      it("records a completed acknowledgement and its result", async ({ runtime }) => {
+        const result = { receipt: "r-1", amount: 12.5, lines: [{ sku: "a" }] };
+        await admit(runtime, "completes");
+        const lease = await claimOne(runtime, "completes");
+        expect2(await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result }
+        })).toEqual({ status: "completed", result });
+        expect2(await runtime.executions.get("completes")).toMatchObject({
+          status: "completed",
+          outcome: { status: "completed", result }
+        });
+        await admitCompleted(runtime, "void", undefined);
+        const voidRecord = await runtime.executions.get("void");
+        expect2(voidRecord.status).toBe("completed");
+        expect2(voidRecord.outcome).toEqual({ status: "completed", result: undefined });
+      });
+      it("records a failed acknowledgement with the error name and message", async ({
+        runtime
+      }) => {
+        await admit(runtime, "fails");
+        const lease = await claimOne(runtime, "fails");
+        const acknowledged = await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "failed", error: new PaymentDeclinedError("card declined") }
+        });
+        expect2(acknowledged.status).toBe("failed");
+        const record = await runtime.executions.get("fails");
+        expect2(record.status).toBe("failed");
+        for (const outcome of [acknowledged, record.outcome]) {
+          if (outcome.status !== "failed")
+            throw new Error("expected a failed outcome");
+          expect2(outcome.error).toBeInstanceOf(Error);
+          expect2(outcome.error.name).toBe("PaymentDeclinedError");
+          expect2(outcome.error.message).toBe("card declined");
+          expect2(Object.getPrototypeOf(outcome.error)).toBe(Error.prototype);
+          expect2(outcome.error.code).toBe("CARD_DECLINED");
+        }
+        const again = await runtime.executions.get("fails");
+        expect2(again.outcome).toMatchObject({ status: "failed" });
+        const error = again.outcome.error;
+        expect2([error.name, error.message]).toEqual(["PaymentDeclinedError", "card declined"]);
+      });
+      it("records a failed outcome's registered error class, code, cause and fields", async ({
+        runtime
+      }) => {
+        await admit(runtime, "fails-registered");
+        const lease = await claimOne(runtime, "fails-registered");
+        const error = new GatewayTimeoutError("stripe", {
+          cause: new PaymentDeclinedError("card declined")
+        });
+        const acknowledged = await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "failed", error }
+        });
+        const record = await runtime.executions.get("fails-registered");
+        for (const outcome of [acknowledged, record.outcome]) {
+          if (outcome.status !== "failed")
+            throw new Error("expected a failed outcome");
+          expect2(outcome.error).toBeInstanceOf(GatewayTimeoutError);
+          expect2(outcome.error).toMatchObject({
+            name: "ConformanceGatewayTimeoutError",
+            message: "stripe timed out",
+            gateway: "stripe"
+          });
+          expect2(outcome.error.stack).toBe(error.stack);
+          const cause = outcome.error.cause;
+          expect2([cause.name, cause.message, cause.code]).toEqual([
+            "PaymentDeclinedError",
+            "card declined",
+            "CARD_DECLINED"
+          ]);
+        }
+      });
+      it("records a completed result's undefined values, errors and tag-shaped objects", async ({
+        runtime
+      }) => {
+        const result = {
+          ok: false,
+          error: new TypeError("bad input"),
+          missing: undefined,
+          tagged: { $type: "error", name: "E", message: "m" }
+        };
+        await admitCompleted(runtime, "completes-tagged", result);
+        const outcome = (await runtime.executions.get("completes-tagged")).outcome;
+        if (outcome.status !== "completed")
+          throw new Error("expected completed");
+        const recorded = outcome.result;
+        expect2(recorded).toEqual(result);
+        expect2(Object.keys(recorded)).toContain("missing");
+        expect2(recorded.error).toBeInstanceOf(TypeError);
+        expect2(recorded.tagged).not.toBeInstanceOf(Error);
+      });
+      it("records a non-durable completed result as failed with INVALID_STEP_VALUE", async ({
+        runtime
+      }) => {
+        await admit(runtime, "invalid-result");
+        const lease = await claimOne(runtime, "invalid-result");
+        const acknowledged = await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: { at: new Date(0) } }
+        });
+        const record = await runtime.executions.get("invalid-result");
+        expect2(record.status).toBe("failed");
+        for (const outcome of [acknowledged, record.outcome]) {
+          expect2(outcome).toMatchObject({
+            status: "failed",
+            error: { code: "INVALID_STEP_VALUE", stepKey: "$$workflow-result$$" }
+          });
+          expect2(outcome.error.name).toBe("WorkflowValueError");
+        }
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("keeps the first terminal outcome: a later acknowledgement under the ended lease is lost", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        const lease = await admitCompleted(runtime, "first-wins", "first");
+        const recorded = await runtime.executions.get("first-wins");
+        advance(10);
+        for (const outcome of [
+          { status: "failed", error: new Error("second") },
+          { status: "completed", result: "second" },
+          { status: "suspended", wakeAt: clock.now }
+        ]) {
+          expect2(await runtime.executions.acknowledge({ lease, outcome })).toEqual({
+            status: "lost"
+          });
+        }
+        expect2(await runtime.executions.get("first-wins")).toEqual(recorded);
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("keeps a terminal outcome when a stale lease acknowledges after a reclaim", async ({
+        runtime,
+        advance
+      }) => {
+        await admit(runtime, "duplicate");
+        const slow = await claimOne(runtime, "duplicate");
+        advance(REDELIVER_AFTER2);
+        const redelivered = await claimOne(runtime, "duplicate");
+        expect2(await runtime.executions.acknowledge({
+          lease: redelivered,
+          outcome: { status: "completed", result: "fast" }
+        })).toEqual({ status: "completed", result: "fast" });
+        const recorded = await runtime.executions.get("duplicate");
+        expect2(await runtime.executions.acknowledge({
+          lease: slow,
+          outcome: { status: "completed", result: "slow" }
+        })).toEqual({ status: "lost" });
+        expect2(await runtime.executions.get("duplicate")).toEqual(recorded);
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      it("leaves the status unchanged after an infrastructure error and redelivers", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admitSuspended(runtime, "infra");
+        const before = await runtime.executions.get("infra");
+        await runtime.executions.requestWake({ executionId: "infra", wakeAt: clock.now });
+        await claimOne(runtime, "infra");
+        advance(REDELIVER_AFTER2);
+        expect2(await runtime.executions.get("infra")).toMatchObject({
+          status: "suspended",
+          updatedAt: before.updatedAt
+        });
+        expect2((await runtime.executions.get("infra")).outcome).toBeUndefined();
+        await claimOne(runtime, "infra");
+      });
+    });
+    describe2("leases", () => {
+      it("grants exactly one lease when two clients claim one due execution concurrently", async ({
+        runtime,
+        harness
+      }) => {
+        await admit(runtime, "contended");
+        const peer = await harness.createPeer?.() ?? runtime;
+        const claims = await Promise.all([claim(runtime), claim(peer), claim(runtime)]);
+        const leases = claims.flat();
+        expect2(leases.map((lease) => lease.executionId)).toEqual(["contended"]);
+      });
+      it("never grants a second live lease to concurrent claimers of many executions", async ({
+        runtime,
+        harness
+      }) => {
+        const ids = Array.from({ length: 20 }, (_, i) => `many-${String(i).padStart(2, "0")}`);
+        for (const id of ids)
+          await admit(runtime, id);
+        const peer = await harness.createPeer?.() ?? runtime;
+        const claims = await Promise.all(Array.from({ length: 6 }, (_, i) => claim(i % 2 ? peer : runtime, 4)));
+        const claimed = claims.flat().map((lease) => lease.executionId).sort();
+        expect2(new Set(claimed).size).toBe(claimed.length);
+        expect2(claimed).toEqual(ids);
+      });
+      it("returns at most `limit` leases, earliest due first", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        for (const id of ["late", "early", "middle"])
+          await admitSuspended(runtime, id);
+        await runtime.executions.requestWake({ executionId: "late", wakeAt: clock.now + 30 });
+        await runtime.executions.requestWake({ executionId: "early", wakeAt: clock.now + 10 });
+        await runtime.executions.requestWake({ executionId: "middle", wakeAt: clock.now + 20 });
+        advance(30);
+        expect2(await claim(runtime, 0)).toEqual([]);
+        expect2((await claim(runtime, 2)).map((lease) => lease.executionId)).toEqual([
+          "early",
+          "middle"
+        ]);
+        expect2((await claim(runtime, 2)).map((lease) => lease.executionId)).toEqual(["late"]);
+      });
+      it("claims only the requested executions and leaves the others due and unclaimed", async ({
+        runtime
+      }) => {
+        for (const id of ["a", "b", "c", "d"])
+          await admit(runtime, id);
+        const claimIds = (executionIds) => runtime.executions.claimDue({ limit: 100, duration: LEASE2, filter: { executionIds } });
+        expect2(await claimIds([])).toEqual([]);
+        const leases = await claimIds(["d", "b", "unknown"]);
+        expect2(leases.map((lease) => lease.executionId).sort()).toEqual(["b", "d"]);
+        for (const id of ["a", "c"]) {
+          expect2(await runtime.executions.get(id)).toMatchObject({
+            status: "admitted",
+            unacknowledgedDeliveryCount: 0
+          });
+        }
+        expect2(await claimedIds(runtime)).toEqual(["a", "c"]);
+      });
+      it("marks a claimed execution running", async ({ runtime }) => {
+        await admit(runtime, "running");
+        expect2(await runtime.executions.get("running")).toMatchObject({ status: "admitted" });
+        await claimOne(runtime, "running");
+        expect2(await runtime.executions.get("running")).toMatchObject({
+          status: "running",
+          unacknowledgedDeliveryCount: 0
+        });
+      });
+      it("makes an execution claimable with a higher token once its lease expires", async ({
+        runtime,
+        advance
+      }) => {
+        await admit(runtime, "expires");
+        const first = await claimOne(runtime, "expires");
+        advance(LEASE2 - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        expect2(await runtime.executions.get("expires")).toMatchObject({ status: "running" });
+        advance(REDELIVER_AFTER2 - LEASE2 + 1);
+        const second = await claimOne(runtime, "expires");
+        expect2(second.token).toBeGreaterThan(first.token);
+        expect2(await runtime.executions.get("expires")).toMatchObject({
+          status: "running",
+          unacknowledgedDeliveryCount: 1
+        });
+      });
+      it("returns an expired lease's execution to admitted before any acknowledgement", async ({
+        runtime,
+        advance
+      }) => {
+        await admit(runtime, "never-acked");
+        await claimOne(runtime, "never-acked");
+        advance(LEASE2);
+        expect2(await runtime.executions.get("never-acked")).toMatchObject({
+          status: "admitted",
+          unacknowledgedDeliveryCount: 1
+        });
+      });
+      it("returns an expired lease's execution to suspended after an earlier suspended delivery", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admitSuspended(runtime, "was-suspended");
+        await runtime.executions.requestWake({ executionId: "was-suspended", wakeAt: clock.now });
+        await claimOne(runtime, "was-suspended");
+        advance(LEASE2);
+        expect2(await runtime.executions.get("was-suspended")).toMatchObject({
+          status: "suspended",
+          unacknowledgedDeliveryCount: 1
+        });
+      });
+      it("keeps a renewed lease past its original expiry with one claim", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "long");
+        let lease = await claimOne(runtime, "long");
+        for (let i = 0;i < 5; i++) {
+          advance(LEASE2 - 1);
+          const renewed = await runtime.executions.renew({ lease, duration: LEASE2 });
+          expect2(renewed).toEqual({
+            status: "renewed",
+            lease: { executionId: "long", token: lease.token, expiresAt: clock.now + LEASE2 }
+          });
+          if (renewed.status !== "renewed")
+            throw new Error("renewal lost");
+          lease = renewed.lease;
+          expect2(await claim(runtime)).toEqual([]);
+          expect2(await runtime.executions.get("long")).toMatchObject({ status: "running" });
+        }
+        expect2(await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: "done" }
+        })).toEqual({ status: "completed", result: "done" });
+        expect2(await runtime.executions.get("long")).toMatchObject({
+          status: "completed",
+          unacknowledgedDeliveryCount: 0
+        });
+      });
+      it("returns lost when renewing with a stale token", async ({ runtime, advance }) => {
+        await admit(runtime, "stale-renew");
+        const stale = await claimOne(runtime, "stale-renew");
+        advance(REDELIVER_AFTER2);
+        const current = await claimOne(runtime, "stale-renew");
+        expect2(await runtime.executions.renew({ lease: stale, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        advance(LEASE2);
+        expect2(await runtime.executions.get("stale-renew")).toMatchObject({
+          status: "admitted"
+        });
+        expect2(await runtime.executions.renew({ lease: current, duration: LEASE2 })).toMatchObject({
+          status: "renewed"
+        });
+      });
+      it("keeps an expired lease current until another claim issues a higher token", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "expired-unclaimed");
+        const lease = await claimOne(runtime, "expired-unclaimed");
+        advance(REDELIVER_AFTER2 * 3);
+        expect2(await runtime.heap.writeStep({
+          lease,
+          stepKey: "step",
+          stepAttempt: 0,
+          done: true,
+          stepResponseJson: JSON.stringify({ value: 1 })
+        })).toEqual({ stepResponseJson: JSON.stringify({ value: 1 }), meta: { attempt: 0, done: true } });
+        const renewed = await runtime.executions.renew({ lease, duration: LEASE2 });
+        expect2(renewed).toEqual({
+          status: "renewed",
+          lease: { ...lease, expiresAt: clock.now + LEASE2 }
+        });
+        expect2(await runtime.executions.get("expired-unclaimed")).toMatchObject({
+          status: "running",
+          unacknowledgedDeliveryCount: 0
+        });
+        expect2(await claim(runtime)).toEqual([]);
+        expect2(await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } })).toEqual({ status: "suspended" });
+      });
+      it("makes a released execution claimable after the redelivery delay with a higher token", async ({
+        runtime,
+        advance
+      }) => {
+        await admitSuspended(runtime, "released");
+        const before = await runtime.executions.get("released");
+        await runtime.executions.requestWake({ executionId: "released", wakeAt: START2 });
+        const first = await claimOne(runtime, "released");
+        expect2(await runtime.executions.release({ lease: first })).toEqual({
+          status: "released"
+        });
+        const released = await runtime.executions.get("released");
+        expect2(released).toMatchObject({ status: "suspended", unacknowledgedDeliveryCount: 1 });
+        expect2(released.outcome).toBeUndefined();
+        expect2(released.updatedAt).toBe(before.updatedAt);
+        expect2(await runtime.executions.release({ lease: first })).toEqual({ status: "lost" });
+        expect2(await runtime.executions.renew({ lease: first, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        expect2(await runtime.executions.acknowledge({ lease: first, outcome: { status: "suspended" } })).toEqual({ status: "lost" });
+        advance(redeliveryDelay2(1) - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        const second = await claimOne(runtime, "released");
+        expect2(second.token).toBeGreaterThan(first.token);
+      });
+      it("ends the lease on a suspended acknowledgement and makes the execution due at a wake requested during it", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "woken-during");
+        const lease = await claimOne(runtime, "woken-during");
+        await runtime.executions.requestWake({ executionId: "woken-during", wakeAt: clock.now + 50 });
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        expect2(await runtime.executions.get("woken-during")).toMatchObject({
+          status: "suspended"
+        });
+        expect2(await runtime.executions.renew({ lease, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        advance(49);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        const next = await claimOne(runtime, "woken-during");
+        expect2(next.token).toBeGreaterThan(lease.token);
+      });
+      it("ends the lease on a suspended acknowledgement and makes the execution due at wakeAt", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "wake-at");
+        const lease = await claimOne(runtime, "wake-at");
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "suspended", wakeAt: clock.now + 70 }
+        });
+        expect2(await runtime.executions.renew({ lease, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        advance(69);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        await claimOne(runtime, "wake-at");
+      });
+      it("ends the lease on a suspended acknowledgement and leaves the execution not due without a wake", async ({
+        runtime,
+        advance
+      }) => {
+        await admit(runtime, "not-due");
+        const lease = await claimOne(runtime, "not-due");
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        expect2(await runtime.executions.release({ lease })).toEqual({ status: "lost" });
+        advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+        expect2(await runtime.executions.get("not-due")).toMatchObject({
+          status: "suspended",
+          unacknowledgedDeliveryCount: 0
+        });
+      });
+      it("returns lost for a lease on an unknown execution", async ({ runtime }) => {
+        const ghost = { executionId: "ghost", token: 1, expiresAt: START2 + LEASE2 };
+        expect2(await runtime.executions.renew({ lease: ghost, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        expect2(await runtime.executions.release({ lease: ghost })).toEqual({ status: "lost" });
+        expect2(await runtime.executions.acknowledge({ lease: ghost, outcome: { status: "suspended" } })).toEqual({ status: "lost" });
+        expect2(await runtime.heap.writeStep({
+          lease: ghost,
+          stepKey: "step",
+          stepAttempt: 0,
+          done: true,
+          stepResponseJson: "{}"
+        })).toEqual({ status: "lost" });
+        expect2(await runtime.executions.get("ghost")).toBeUndefined();
+      });
+      itAfterRestart("keeps leases and tokens across a restart", async ({
+        runtime,
+        advance,
+        restart
+      }) => {
+        await admit(runtime, "held");
+        const held = await claimOne(runtime, "held");
+        const restarted = await restart();
+        expect2(await restarted.executions.get("held")).toMatchObject({ status: "running" });
+        expect2(await claim(restarted)).toEqual([]);
+        expect2(await restarted.executions.renew({ lease: held, duration: LEASE2 })).toMatchObject({
+          status: "renewed"
+        });
+        advance(REDELIVER_AFTER2);
+        const next = await claimOne(restarted, "held");
+        expect2(next.token).toBeGreaterThan(held.token);
+        expect2(await restarted.executions.release({ lease: held })).toEqual({ status: "lost" });
+      });
+    });
+    describe2("redelivery delay", () => {
+      it("delays each redelivery after a release by a non-zero delay no shorter than the last", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "retrying");
+        let lease = await claimOne(runtime, "retrying");
+        let previousDelay = 0;
+        for (let attempt = 1;attempt <= 6; attempt++) {
+          await runtime.executions.release({ lease });
+          expect2(await runtime.executions.get("retrying")).toMatchObject({
+            unacknowledgedDeliveryCount: attempt
+          });
+          const releasedAt = clock.now;
+          let next;
+          while ((next = await claim(runtime)).length === 0) {
+            advance(100);
+            if (clock.now - releasedAt > 60 * 60000)
+              throw new Error("never redelivered");
+          }
+          const delay = clock.now - releasedAt;
+          expect2(delay).toBeGreaterThan(0);
+          expect2(delay).toBeGreaterThanOrEqual(previousDelay);
+          previousDelay = delay;
+          lease = next[0];
+        }
+      });
+      it("counts both a release and a later expiry", async ({ runtime, advance }) => {
+        await admit(runtime, "both");
+        const released = await claimOne(runtime, "both");
+        await runtime.executions.release({ lease: released });
+        advance(redeliveryDelay2(1));
+        await claimOne(runtime, "both");
+        advance(LEASE2);
+        expect2(await runtime.executions.get("both")).toMatchObject({
+          unacknowledgedDeliveryCount: 2
+        });
+        advance(redeliveryDelay2(2) - 1);
+        expect2(await claim(runtime)).toEqual([]);
+        advance(1);
+        await claimOne(runtime, "both");
+        expect2(await runtime.executions.get("both")).toMatchObject({
+          unacknowledgedDeliveryCount: 2
+        });
+      });
+      it("resets the count on acknowledgement, so the next wake is not delayed", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "recovers");
+        for (let i = 1;i <= 3; i++) {
+          const lease = await claimOne(runtime, "recovers");
+          await runtime.executions.release({ lease });
+          advance(redeliveryDelay2(i));
+        }
+        expect2(await runtime.executions.get("recovers")).toMatchObject({
+          unacknowledgedDeliveryCount: 3
+        });
+        const lease = await claimOne(runtime, "recovers");
+        await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+        expect2(await runtime.executions.get("recovers")).toMatchObject({
+          status: "suspended",
+          unacknowledgedDeliveryCount: 0
+        });
+        await runtime.executions.requestWake({ executionId: "recovers", wakeAt: clock.now });
+        await claimOne(runtime, "recovers");
+      });
+      it("holds wakes requested during the delay until it passes", async ({
+        runtime,
+        clock,
+        advance
+      }) => {
+        await admit(runtime, "held-back");
+        const lease = await claimOne(runtime, "held-back");
+        await runtime.executions.release({ lease });
+        await runtime.executions.requestWake({ executionId: "held-back", wakeAt: clock.now });
+        expect2(await claim(runtime)).toEqual([]);
+        advance(redeliveryDelay2(1));
+        await claimOne(runtime, "held-back");
+      });
+    });
+    describe2("fencing", () => {
+      async function reclaim(ctx, executionId) {
+        const stale = await claimOne(ctx.runtime, executionId);
+        ctx.advance(REDELIVER_AFTER2);
+        const current = await claimOne(ctx.runtime, executionId);
+        expect2(current.token).toBeGreaterThan(stale.token);
+        return { stale, current };
+      }
+      function write(runtime, lease, stepKey, value, options = {}) {
+        return runtime.heap.writeStep({
+          lease,
+          stepKey,
+          stepAttempt: options.attempt ?? 0,
+          done: options.done ?? true,
+          stepResponseJson: JSON.stringify(value)
+        });
+      }
+      it("rejects a stale holder's heap write after a reclaim and keeps the current records", async (ctx) => {
+        const { runtime } = ctx;
+        await admit(runtime, "stale-write");
+        const { stale, current } = await reclaim(ctx, "stale-write");
+        expect2(await write(runtime, current, "charge", "current")).toMatchObject({
+          stepResponseJson: JSON.stringify("current")
+        });
+        expect2(await write(runtime, stale, "charge", "stale")).toEqual({ status: "lost" });
+        expect2(await write(runtime, stale, "charge", "stale", { attempt: 1 })).toEqual({
+          status: "lost"
+        });
+        expect2(await write(runtime, stale, "other", "stale")).toEqual({ status: "lost" });
+        expect2(await runtime.heap.readStep({ executionId: "stale-write", stepKey: "charge" })).toEqual({
+          stepResponseJson: JSON.stringify("current"),
+          meta: { attempt: 0, done: true }
+        });
+        expect2(await runtime.heap.readStep({ executionId: "stale-write", stepKey: "other" })).toBeNull();
+      });
+      it("rejects a stale holder's acknowledgement after a reclaim and leaves the record unchanged", async (ctx) => {
+        const { runtime } = ctx;
+        await admitSuspended(runtime, "stale-ack");
+        await runtime.executions.requestWake({ executionId: "stale-ack", wakeAt: ctx.clock.now });
+        const { stale, current } = await reclaim(ctx, "stale-ack");
+        const before = await runtime.executions.get("stale-ack");
+        for (const outcome of [
+          { status: "completed", result: "stale" },
+          { status: "failed", error: new Error("stale") },
+          { status: "suspended", wakeAt: ctx.clock.now }
+        ]) {
+          expect2(await runtime.executions.acknowledge({ lease: stale, outcome })).toEqual({
+            status: "lost"
+          });
+        }
+        expect2(await runtime.executions.get("stale-ack")).toEqual(before);
+        expect2(before).toMatchObject({ status: "running" });
+        expect2(await runtime.executions.acknowledge({
+          lease: current,
+          outcome: { status: "completed", result: "current" }
+        })).toEqual({ status: "completed", result: "current" });
+      });
+      it("rejects every fenced write from a holder that pauses past expiry after another claims", async (ctx) => {
+        const { runtime } = ctx;
+        await admit(runtime, "paused");
+        const paused = await claimOne(runtime, "paused");
+        expect2(await write(runtime, paused, "before-pause", 1)).toMatchObject({
+          meta: { attempt: 0, done: true }
+        });
+        ctx.advance(REDELIVER_AFTER2);
+        const peer = await ctx.harness.createPeer?.() ?? runtime;
+        const current = await claimOne(peer, "paused");
+        expect2(await write(runtime, paused, "after-pause", 2)).toEqual({ status: "lost" });
+        expect2(await runtime.executions.renew({ lease: paused, duration: LEASE2 })).toEqual({
+          status: "lost"
+        });
+        expect2(await runtime.executions.release({ lease: paused })).toEqual({ status: "lost" });
+        expect2(await runtime.executions.acknowledge({
+          lease: paused,
+          outcome: { status: "completed", result: "paused" }
+        })).toEqual({ status: "lost" });
+        expect2(await write(peer, current, "after-pause", 3)).toMatchObject({
+          stepResponseJson: "3"
+        });
+        expect2(await peer.executions.get("paused")).toMatchObject({ status: "running" });
+      });
+      it("accepts the current holder's rewrite of an existing step record without changing it", async ({
+        runtime
+      }) => {
+        await admit(runtime, "rewrite");
+        const lease = await claimOne(runtime, "rewrite");
+        const first = await write(runtime, lease, "charge", { receipt: "r-1" });
+        const again = await write(runtime, lease, "charge", { receipt: "r-1" });
+        expect2(again).toEqual(first);
+        expect2(await runtime.heap.readStep({ executionId: "rewrite", stepKey: "charge" })).toEqual(first);
+      });
+      it("stores scalar step values as the exact JSON written, so rewrites match and falsy values replay", async ({
+        runtime
+      }) => {
+        await admit(runtime, "scalars");
+        const lease = await claimOne(runtime, "scalars");
+        for (const [stepKey, value] of [
+          ["zero", 0],
+          ["one", 1],
+          ["float", 1.5],
+          ["false", false],
+          ["null", null],
+          ["numeric-string", "1"]
+        ]) {
+          const record = {
+            stepResponseJson: JSON.stringify(value),
+            meta: { attempt: 0, done: true }
+          };
+          expect2(await write(runtime, lease, stepKey, value)).toEqual(record);
+          expect2(await write(runtime, lease, stepKey, value)).toEqual(record);
+          expect2(await runtime.heap.readStep({ executionId: "scalars", stepKey })).toEqual(record);
+        }
+      });
+      it("keeps an existing step record when the current holder writes a different value, and returns the recorded one", async ({
+        runtime
+      }) => {
+        await admit(runtime, "conflict");
+        const lease = await claimOne(runtime, "conflict");
+        await write(runtime, lease, "charge", { receipt: "r-1" });
+        expect2(await write(runtime, lease, "charge", { receipt: "r-2" }, { done: false })).toEqual({
+          stepResponseJson: JSON.stringify({ receipt: "r-1" }),
+          meta: { attempt: 0, done: true }
+        });
+        expect2(await runtime.heap.readStep({ executionId: "conflict", stepKey: "charge" })).toEqual({
+          stepResponseJson: JSON.stringify({ receipt: "r-1" }),
+          meta: { attempt: 0, done: true }
+        });
+        await runtime.executions.release({ lease });
+        expect2(await runtime.heap.readStep({ executionId: "conflict", stepKey: "charge" })).toEqual({
+          stepResponseJson: JSON.stringify({ receipt: "r-1" }),
+          meta: { attempt: 0, done: true }
+        });
+      });
+      it("keeps a waiter when a stale holder's step result would delete it", async (ctx) => {
+        const { runtime } = ctx;
+        await admitSuspended(runtime, "stale-waiter");
+        const snapshot = await runtime.stores.getStore({
+          definition: Store,
+          id: "stale-waiter"
+        });
+        const registered = waiter("stale-waiter", snapshot.instanceId, snapshot.version);
+        await runtime.stores.registerWaiter(registered);
+        await runtime.executions.requestWake({ executionId: "stale-waiter", wakeAt: ctx.clock.now });
+        const { stale, current } = await reclaim(ctx, "stale-waiter");
+        expect2(await write(runtime, stale, registered.stepKey, { id: "m1" }, { attempt: 1 })).toEqual({ status: "lost" });
+        await runtime.executions.acknowledge({ lease: current, outcome: { status: "suspended" } });
+        await appendMessage(runtime, "stale-waiter", "m1");
+        expect2(await claimedIds(runtime)).toEqual(["stale-waiter"]);
+      });
+      it("applies a stale holder's idempotent store update once and returns the recorded result to the current holder", async (ctx) => {
+        const { runtime } = ctx;
+        await admit(runtime, "store-receipt");
+        await runtime.stores.getStore({
+          definition: Store,
+          id: "store-receipt"
+        });
+        const { stale, current } = await reclaim(ctx, "store-receipt");
+        const stepId = { executionId: "store-receipt", stepKey: "append" };
+        const staleResult = await runtime.stores.updateStore({
+          definition: Store,
+          id: "store-receipt",
+          stepId,
+          updater(draft) {
+            draft.messages.push({ id: "stale" });
+          }
+        });
+        const currentResult = await runtime.stores.updateStore({
+          definition: Store,
+          id: "store-receipt",
+          stepId,
+          updater(draft) {
+            draft.messages.push({ id: "current" });
+          }
+        });
+        expect2(currentResult).toEqual(staleResult);
+        expect2(await runtime.stores.getStore({ definition: Store, id: "store-receipt" })).toMatchObject({ state: { messages: [{ id: "stale" }] }, version: 1 });
+        expect2(await write(runtime, stale, "append", staleResult)).toEqual({ status: "lost" });
+        expect2(await write(runtime, current, "append", currentResult)).toMatchObject({
+          meta: { done: true }
+        });
+      });
+      it("lets a stale holder's wake cause at most one extra delivery and leaves the outcome unchanged", async (ctx) => {
+        const { runtime } = ctx;
+        await admit(runtime, "stale-wake");
+        const { current } = await reclaim(ctx, "stale-wake");
+        await runtime.executions.acknowledge({ lease: current, outcome: { status: "suspended" } });
+        await runtime.executions.requestWake({ executionId: "stale-wake", wakeAt: ctx.clock.now });
+        const extra = await claimOne(runtime, "stale-wake");
+        await runtime.executions.acknowledge({ lease: extra, outcome: { status: "suspended" } });
+        ctx.advance(REDELIVER_AFTER2 * 10);
+        expect2(await claim(runtime)).toEqual([]);
+        expect2(await runtime.executions.get("stale-wake")).toMatchObject({
+          status: "suspended",
+          unacknowledgedDeliveryCount: 0
+        });
+        await admit(runtime, "stale-wake-done");
+        const done = await reclaim(ctx, "stale-wake-done");
+        await runtime.executions.acknowledge({
+          lease: done.current,
+          outcome: { status: "completed", result: "ok" }
+        });
+        expect2(await runtime.executions.requestWake({
+          executionId: "stale-wake-done",
+          wakeAt: ctx.clock.now
+        })).toEqual({ status: "ignored" });
+        expect2(await claim(runtime)).toEqual([]);
+      });
+    });
+    describe2("start", () => {
+      it("leaves no trace when a new start fails before it commits", async ({
+        runtime,
+        harness
+      }, testContext) => {
+        if (!harness.failStartCommits) {
+          testContext.skip();
+          return;
+        }
+        await admitSuspended(runtime, "caller");
+        const restore = await harness.failStartCommits();
+        try {
+          await expect2(startFrom(runtime, "caller", "ship")).rejects.toThrow();
+        } finally {
+          await restore();
+        }
+        expect2(await claim(runtime)).toEqual([]);
+        const started = await startFrom(runtime, "caller", "ship");
+        expect2(started.status).toBe("accepted");
+        const targetId = acceptedId(started);
+        expect2(await runtime.executions.get(targetId)).toMatchObject({
+          status: "admitted",
+          parent: { executionId: "caller", stepKey: "ship" }
+        });
+        expect2(await claimedIds(runtime)).toEqual([targetId]);
+      });
+      it("returns the committed target when a start is repeated after a lost response", async ({
+        runtime,
+        harness
+      }) => {
+        await admitSuspended(runtime, "caller");
+        const first = acceptedId(await startFrom(runtime, "caller", "ship"));
+        const peer = await harness.createPeer?.() ?? runtime;
+        expect2(await startFrom(peer, "caller", "ship")).toEqual({
+          status: "accepted",
+          executionId: first
+        });
+        expect2(await startFrom(runtime, "caller", "ship")).toEqual({
+          status: "accepted",
+          executionId: first
+        });
+        expect2(await claimedIds(runtime)).toEqual([first]);
+      });
+      it("admits one target for two concurrent calls with one request ID", async ({
+        runtime,
+        harness
+      }) => {
+        await admitSuspended(runtime, "caller");
+        const peer = await harness.createPeer?.() ?? runtime;
+        const [a, b] = await Promise.all([
+          startFrom(runtime, "caller", "ship"),
+          startFrom(peer, "caller", "ship")
+        ]);
+        expect2(a.status).toBe("accepted");
+        expect2(b).toEqual(a);
+        expect2(await claimedIds(runtime)).toEqual([acceptedId(a)]);
+      });
+      it("gives different request IDs different execution IDs", async ({ runtime }) => {
+        await admitSuspended(runtime, "caller-a");
+        await admitSuspended(runtime, "caller-b");
+        const ids = [
+          acceptedId(await startFrom(runtime, "caller-a", "ship")),
+          acceptedId(await startFrom(runtime, "caller-a", "bill")),
+          acceptedId(await startFrom(runtime, "caller-b", "ship"))
+        ];
+        expect2(new Set([...ids, "caller-a", "caller-b"]).size).toBe(5);
+        expect2(await claimedIds(runtime)).toEqual([...ids].sort());
+      });
+      it("admits the target due, with the caller as its parent", async ({ runtime, clock }) => {
+        await admitSuspended(runtime, "caller");
+        const targetId = acceptedId(await runtime.executions.start({
+          requestId: { executionId: "caller", stepKey: "ship" },
+          workflowId: "ship-order",
+          params: { orderId: 42, items: [{ sku: "a", qty: 1 }] }
+        }));
+        const target = await runtime.executions.get(targetId);
+        expect2(target).toMatchObject({
+          executionId: targetId,
+          workflowId: "ship-order",
+          params: { orderId: 42, items: [{ sku: "a", qty: 1 }] },
+          status: "admitted",
+          admittedAt: clock.now,
+          parent: { executionId: "caller", stepKey: "ship" }
+        });
+        expect2(await claimedIds(runtime)).toEqual([targetId]);
+        const undefinedParams = acceptedId(await startFrom(runtime, "caller", "ship-undefined", {
+          params: { orderId: 42, note: undefined }
+        }));
+        const withUndefined = (await runtime.executions.get(undefinedParams)).params;
+        expect2(withUndefined).toEqual({ orderId: 42, note: undefined });
+        expect2(Object.keys(withUndefined)).toContain("note");
+        expect2(await runtime.executions.get("caller")).not.toHaveProperty("parent");
+        const bare = acceptedId(await startFrom(runtime, "caller", "bare", { params: undefined }));
+        expect2((await runtime.executions.get(bare)).params).toBeUndefined();
+      });
+      it("admits the target with the caller's context", async ({ runtime }) => {
+        await runtime.executions.admit({
+          executionId: "caller",
+          workflowId: "charge-order",
+          params: undefined,
+          context: new Map([
+            ["tenant", "acme"],
+            ["7", { roles: ["admin"] }],
+            ["nothing", undefined]
+          ])
+        });
+        const targetId = acceptedId(await startFrom(runtime, "caller", "ship"));
+        const target = await runtime.executions.get(targetId);
+        expect2([...target.context.entries()]).toEqual([
+          ["tenant", "acme"],
+          ["7", { roles: ["admin"] }],
+          ["nothing", undefined]
+        ]);
+      });
+      it("returns the original target when a repeat differs only in context", async ({
+        runtime
+      }) => {
+        await runtime.executions.admit({
+          executionId: "caller",
+          workflowId: "charge-order",
+          params: undefined,
+          context: new Map([["tenant", "acme"]])
+        });
+        const request = {
+          requestId: { executionId: "caller", stepKey: "ship" },
+          workflowId: "ship-order",
+          params: { orderId: 42 }
+        };
+        const first = acceptedId(await runtime.executions.start(request));
+        expect2(await runtime.executions.start({
+          ...request,
+          context: new Map([["tenant", "other"]])
+        })).toEqual({ status: "accepted", executionId: first });
+        expect2([...(await runtime.executions.get(first)).context.entries()]).toEqual([["tenant", "acme"]]);
+      });
+      const cyclic = {};
+      cyclic.self = cyclic;
+      const accessor = Object.defineProperty({}, "value", {
+        get: () => 1,
+        enumerable: true
+      });
+      const hidden = Object.defineProperty({}, "value", { value: 1, enumerable: false });
+      const invalidParams = [
+        ["a Date", { at: new Date(0) }],
+        ["a class instance", { point: new Point(1) }],
+        ["NaN", { n: NaN }],
+        ["Infinity", { n: Infinity }],
+        ["a bigint", { n: 10n }],
+        ["a function", { fn: () => 1 }],
+        ["a symbol", { s: Symbol("s") }],
+        ["a symbol key", { [Symbol("s")]: 1 }],
+        ["an accessor", { nested: accessor }],
+        ["a non-enumerable property", { nested: hidden }],
+        ["a Map", { map: new Map([["a", 1]]) }],
+        ["a sparse array", { list: [1, , 3] }],
+        ["a cycle", cyclic],
+        ["an array as params", [1, 2]],
+        ["null as params", null],
+        ["a string as params", "params"],
+        ["a class instance as params", new Point(1)]
+      ];
+      for (const [label, params] of invalidParams) {
+        it(`rejects ${label} with INVALID_START_PARAMETERS and admits nothing`, async ({
+          runtime
+        }) => {
+          await admitSuspended(runtime, "caller");
+          const rejected = await runtime.executions.start({
+            requestId: { executionId: "caller", stepKey: "ship" },
+            workflowId: "ship-order",
+            params
+          });
+          expect2(rejected).toMatchObject({
+            status: "rejected",
+            code: "INVALID_START_PARAMETERS"
+          });
+          expect2(rejected.status === "rejected" && typeof rejected.message).toBe("string");
+          expect2(await claim(runtime)).toEqual([]);
+          expect2((await startFrom(runtime, "caller", "ship")).status).toBe("accepted");
+        });
+      }
+      it("rejects an empty workflow ID with INVALID_START_PARAMETERS and admits nothing", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "caller");
+        expect2(await startFrom(runtime, "caller", "ship", { workflowId: "" })).toMatchObject({
+          status: "rejected",
+          code: "INVALID_START_PARAMETERS"
+        });
+        expect2(await claim(runtime)).toEqual([]);
+        expect2((await startFrom(runtime, "caller", "ship")).status).toBe("accepted");
+      });
+      it("matches parameters whose keys are in a different order", async ({ runtime }) => {
+        const a = { orderId: 42, address: { line1: "1 High St", city: "Leeds" }, zero: 0 };
+        const b = { zero: -0, address: { city: "Leeds", line1: "1 High St" }, orderId: 42 };
+        const encodedA = durableValueCodec.encode(a);
+        expect2(encodedA.status).toBe("encoded");
+        expect2(durableValueCodec.encode(b)).toEqual(encodedA);
+        await admitSuspended(runtime, "caller");
+        const first = acceptedId(await startFrom(runtime, "caller", "ship", { params: a }));
+        expect2(await startFrom(runtime, "caller", "ship", { params: b })).toEqual({
+          status: "accepted",
+          executionId: first
+        });
+        expect2(await claimedIds(runtime)).toEqual([first]);
+      });
+      it("rejects a repeat that changes the workflow ID or parameters, leaving the original unchanged", async ({
+        runtime,
+        advance
+      }) => {
+        await admitSuspended(runtime, "caller");
+        await admitSuspended(runtime, "caller-without-params");
+        const first = acceptedId(await startFrom(runtime, "caller", "ship", { params: { orderId: 42 } }));
+        const bare = acceptedId(await startFrom(runtime, "caller-without-params", "ship", { params: undefined }));
+        const before = await runtime.executions.get(first);
+        advance(10);
+        const repeats = [
+          ["caller", { workflowId: "ship-express", params: { orderId: 42 } }],
+          ["caller", { params: { orderId: 43 } }],
+          ["caller", { params: { orderId: 42, express: true } }],
+          ["caller", { params: undefined }],
+          ["caller", { params: { orderId: 42, express: undefined } }],
+          ["caller-without-params", { params: {} }]
+        ];
+        for (const [caller, target] of repeats) {
+          const mismatch = await startFrom(runtime, caller, "ship", target);
+          expect2(mismatch).toMatchObject({
+            status: "rejected",
+            code: "START_REQUEST_MISMATCH"
+          });
+          expect2(mismatch.status === "rejected" && typeof mismatch.message).toBe("string");
+        }
+        expect2(await runtime.executions.get(first)).toEqual(before);
+        expect2(await claimedIds(runtime)).toEqual([first, bare].sort());
+        expect2(await startFrom(runtime, "caller", "ship", { params: { orderId: 42 } })).toEqual({ status: "accepted", executionId: first });
+      });
+      it("returns the original target after it is terminal, and still rejects a mismatch", async ({
+        runtime
+      }) => {
+        await admitSuspended(runtime, "caller");
+        const first = acceptedId(await startFrom(runtime, "caller", "ship"));
+        const lease = await claimOne(runtime, first);
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: "shipped" }
+        });
+        expect2((await runtime.executions.get(first)).status).toBe("completed");
+        expect2(await startFrom(runtime, "caller", "ship")).toEqual({
+          status: "accepted",
+          executionId: first
+        });
+        expect2(await startFrom(runtime, "caller", "ship", { workflowId: "ship-express" })).toMatchObject({
+          status: "rejected",
+          code: "START_REQUEST_MISMATCH"
+        });
+        expect2(await claim(runtime)).toEqual([]);
+      });
+      itAfterRestart("keeps start requests and parent links across a restart", async ({
+        runtime,
+        restart
+      }) => {
+        await admitSuspended(runtime, "caller");
+        const first = acceptedId(await startFrom(runtime, "caller", "ship"));
+        const record = await runtime.executions.get(first);
+        const restarted = await restart();
+        expect2(await restarted.executions.get(first)).toEqual(record);
+        expect2(record.parent).toEqual({ executionId: "caller", stepKey: "ship" });
+        expect2(await startFrom(restarted, "caller", "ship")).toEqual({
+          status: "accepted",
+          executionId: first
+        });
+        expect2(await startFrom(restarted, "caller", "ship", { workflowId: "ship-express" })).toMatchObject({
+          status: "rejected",
+          code: "START_REQUEST_MISMATCH"
+        });
+        expect2(await claimedIds(restarted)).toEqual([first]);
+      });
+    });
+    describe2("durability", () => {
+      itAfterRestart("preserves admitted and suspended records and their pending wakes across a restart", async ({ runtime, clock, advance, restart }) => {
+        await admit(runtime, "delayed");
+        const delayed = await claimOne(runtime, "delayed");
+        await runtime.executions.acknowledge({
+          lease: delayed,
+          outcome: { status: "suspended", wakeAt: clock.now + 500 }
+        });
+        await admitSuspended(runtime, "woken");
+        await runtime.executions.requestWake({ executionId: "woken", wakeAt: clock.now + 200 });
+        await admitSuspended(runtime, "idle");
+        await admit(runtime, "in-flight");
+        await claimOne(runtime, "in-flight");
+        await admitCompleted(runtime, "finished", { receipt: "r-1" });
+        await runtime.executions.admit({
+          executionId: "admitted",
+          workflowId: "charge-order",
+          params: { orderId: 42 },
+          context: new Map([["tenant", "acme"]])
+        });
+        const records = await Promise.all(["admitted", "delayed", "woken", "idle", "in-flight", "finished"].map((id) => runtime.executions.get(id)));
+        const restarted = await restart();
+        expect2(await Promise.all(["admitted", "delayed", "woken", "idle", "in-flight", "finished"].map((id) => restarted.executions.get(id)))).toEqual(records);
+        expect2([...(await restarted.executions.get("admitted")).context.entries()]).toEqual([["tenant", "acme"]]);
+        expect2(await drain(restarted)).toEqual(["admitted"]);
+        advance(200);
+        expect2(await drain(restarted)).toEqual(["woken"]);
+        advance(300);
+        expect2(await drain(restarted)).toEqual(["delayed"]);
+        advance(REDELIVER_AFTER2 - 500 - 1);
+        expect2(await drain(restarted)).toEqual([]);
+        advance(1);
+        expect2(await drain(restarted)).toEqual(["in-flight"]);
+        expect2(await restarted.executions.admit({
+          executionId: "finished",
+          workflowId: "workflow",
+          params: undefined,
+          context: new Map
+        })).toMatchObject({ status: "rejected", code: "EXECUTION_ID_CONFLICT" });
+      });
+      itAfterRestart("makes a store commit and the wakes it requires durable together", async ({ runtime, restart }) => {
+        await admitSuspended(runtime, "committed");
+        const snapshot = await runtime.stores.getStore({
+          definition: Store,
+          id: "committed"
+        });
+        await runtime.stores.registerWaiter(waiter("committed", snapshot.instanceId, snapshot.version));
+        await appendMessage(runtime, "committed", "m1");
+        const restarted = await restart();
+        expect2(await restarted.stores.getStore({ definition: Store, id: "committed" })).toMatchObject({ state: { messages: [{ id: "m1" }] }, version: 1 });
+        expect2(await claimedIds(restarted)).toEqual(["committed"]);
+      });
+      itAfterRestart("keeps a registered waiter across a restart", async ({ runtime, restart }) => {
+        await admitSuspended(runtime, "durable-waiter");
+        const snapshot = await runtime.stores.getStore({
+          definition: Store,
+          id: "durable-waiter"
+        });
+        await runtime.stores.registerWaiter(waiter("durable-waiter", snapshot.instanceId, snapshot.version));
+        const restarted = await restart();
+        await appendMessage(restarted, "durable-waiter", "m1");
+        expect2(await claimedIds(restarted)).toEqual(["durable-waiter"]);
+      });
+    });
+  });
+}
+
+// src/index.ts
+var WORKFLOW_ID = "workflow";
+var STEP_KEY = "wait";
+function schema2() {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "yieldstar-conformance",
+      validate(value) {
+        return { value };
+      }
+    }
+  };
+}
+function waiter(storeName, storeId, instanceId, sinceVersion, readPaths = [["messages"]], executionId = "execution") {
+  return {
+    workflowId: WORKFLOW_ID,
+    executionId,
+    stepKey: STEP_KEY,
+    storeName,
+    storeId,
+    instanceId,
+    sinceVersion,
+    readPaths
+  };
+}
+var seeds = new Map;
+function seeded(storeName, fallback) {
+  return (id) => structuredClone(seeds.get(JSON.stringify([storeName, id])) ?? fallback);
+}
+function seed(definition, id, state) {
+  seeds.set(JSON.stringify([definition.name, id]), state);
+}
+async function admitWaiting(runtime, ...executionIds) {
+  for (const executionId of executionIds) {
+    const admitted = await runtime.executions.admit({
+      executionId,
+      workflowId: WORKFLOW_ID,
+      params: undefined,
+      context: new Map
+    });
+    if (admitted.status !== "accepted") {
+      throw new Error(`admission of "${executionId}" was rejected: ${admitted.message}`);
+    }
+  }
+  const woken = await drainWakes(runtime);
+  expect3(woken).toEqual([...new Set(executionIds)].sort());
+}
+async function drainWakes(runtime) {
+  const leases = await claimAll(runtime);
+  for (const lease of leases) {
+    await runtime.executions.acknowledge({ lease, outcome: { status: "suspended" } });
+  }
+  return leases.map((lease) => lease.executionId).sort();
+}
+function claimAll(runtime) {
+  return runtime.executions.claimDue({ limit: 1000, duration: DEFAULT_LEASE_DURATION3 });
+}
+async function expectWoken(runtime, expected) {
+  const woken = [];
+  const want = [...expected].sort();
+  for (let attempt = 0;attempt < 100; attempt++) {
+    woken.push(...await drainWakes(runtime));
+    if (woken.length >= want.length)
+      break;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  expect3(woken.sort()).toEqual(want);
+}
+async function expectNotWoken(runtime) {
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  expect3(await drainWakes(runtime)).toEqual([]);
+}
+async function recordStep(runtime, executionId, stepKey = STEP_KEY) {
+  await runtime.executions.requestWake({ executionId, wakeAt: runtime.clock() });
+  const leases = await claimAll(runtime);
+  const lease = leases.find((lease) => lease.executionId === executionId);
+  if (!lease)
+    throw new Error(`could not lease "${executionId}" to record a step`);
+  const written = await runtime.heap.writeStep({
+    lease,
+    stepKey,
+    stepAttempt: 1,
+    done: true,
+    stepResponseJson: JSON.stringify({ done: true })
+  });
+  expect3(written).toMatchObject({ meta: { done: true } });
+  for (const claimed of leases) {
+    await runtime.executions.acknowledge({
+      lease: claimed,
+      outcome: { status: "suspended" }
+    });
+  }
+}
+function registerStoreClientConformance({
+  name,
+  create
+}) {
+  const Store = defineStore2(`${name}-store-conformance`, schema2(), {
+    initial: seeded(`${name}-store-conformance`, { messages: [] })
+  });
+  const TakeStore = defineStore2(`${name}-take-conformance`, schema2(), {
+    initial: seeded(`${name}-take-conformance`, { messages: [] })
+  });
+  describe3(`${name} store connector conformance`, () => {
+    test3("creates, reads, lists, deletes, and recreates logical stores", async () => {
+      const harness = await create();
+      const OtherStore = defineStore2(`${name}-other-conformance`, schema2(), {
+        initial: () => ({ messages: [] })
+      });
+      try {
+        const first = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "b"
+        });
+        const second = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "a"
+        });
+        await harness.runtime.stores.getStore({
+          definition: OtherStore,
+          id: "a"
+        });
+        expect3(first.instanceId).toMatch(/^[0-9a-f-]+$/);
+        expect3(second.instanceId).not.toBe(first.instanceId);
+        expect3(await harness.runtime.stores.listStores(Store)).toEqual(["a", "b"]);
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "b" })).toEqual(first);
+        await harness.runtime.stores.deleteStore({ definition: Store, id: "b" });
+        expect3(await harness.runtime.stores.listStores(Store)).toEqual(["a"]);
+        const recreated = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "b"
+        });
+        expect3(recreated).toMatchObject({ state: { messages: [] }, version: 0 });
+        expect3(recreated.instanceId).not.toBe(first.instanceId);
+        await harness.runtime.stores.deleteStore({ definition: Store, id: "missing" });
+        expect3(await harness.runtime.stores.listStores(Store)).toEqual(["a", "b"]);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("rejects non-durable state with INVALID_STEP_VALUE and leaves the store unchanged", async () => {
+      const harness = await create();
+      const { stores } = harness.runtime;
+      const invalid = { code: "INVALID_STEP_VALUE", name: "WorkflowValueError" };
+      try {
+        seed(Store, "never-created", { messages: [], unrelated: new Date(0) });
+        await expect3(stores.getStore({ definition: Store, id: "never-created" })).rejects.toMatchObject(invalid);
+        await expect3(stores.updateStore({
+          definition: Store,
+          id: "never-created",
+          stepId: { executionId: "never-created", stepKey: "update" },
+          updater() {}
+        })).rejects.toMatchObject({ ...invalid, stepKey: "update" });
+        expect3(await stores.listStores(Store)).toEqual([]);
+        seed(Store, "durable", { messages: [{ id: "one" }] });
+        const created = await stores.getStore({
+          definition: Store,
+          id: "durable"
+        });
+        const stepId = { executionId: "durable-execution", stepKey: "update" };
+        await expect3(stores.updateStore({
+          definition: Store,
+          id: "durable",
+          stepId,
+          updater(draft) {
+            draft.messages.push({ id: "two" });
+            draft.at = new Map;
+          }
+        })).rejects.toMatchObject({ ...invalid, stepKey: "update" });
+        await expect3(stores.updateStoreFrom({
+          definition: Store,
+          id: "durable",
+          snapshot: created,
+          updater: () => ({ messages: [], unrelated: 1n })
+        })).rejects.toMatchObject(invalid);
+        expect3(await stores.getStore({ definition: Store, id: "durable" })).toMatchObject({
+          state: { messages: [{ id: "one" }] },
+          version: 0
+        });
+        seed(TakeStore, "durable-take", { messages: [{ id: "one" }] });
+        await stores.getStore({
+          definition: TakeStore,
+          id: "durable-take"
+        });
+        await expect3(stores.takeFromStore({
+          definition: TakeStore,
+          id: "durable-take",
+          selector: (state) => state.messages.length > 0 && new Set(state.messages),
+          claim(draft) {
+            draft.messages = [];
+          }
+        })).rejects.toMatchObject(invalid);
+        expect3(await stores.getStore({ definition: TakeStore, id: "durable-take" })).toMatchObject({ state: { messages: [{ id: "one" }] }, version: 0 });
+        const retried = await stores.updateStore({
+          definition: Store,
+          id: "durable",
+          stepId,
+          updater(draft) {
+            draft.messages.push({ id: "two" });
+          }
+        });
+        expect3(retried).toMatchObject({ version: 1, state: { messages: [{ id: "one" }, { id: "two" }] } });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("stores state and receipts with the durable value codec", async () => {
+      const harness = await create();
+      const { stores } = harness.runtime;
+      try {
+        seed(Store, "codec", { messages: [], unrelated: undefined });
+        await stores.getStore({
+          definition: Store,
+          id: "codec"
+        });
+        const stepId = { executionId: "codec-execution", stepKey: "update" };
+        const update = () => stores.updateStore({
+          definition: Store,
+          id: "codec",
+          stepId,
+          updater(draft) {
+            draft.messages.push({ id: "one", $type: "undefined" });
+            draft.error = new RangeError("r");
+          }
+        });
+        const first = await update();
+        const replayed = await update();
+        const read = await stores.getStore({ definition: Store, id: "codec" });
+        for (const state of [first.state, replayed.state, read.state]) {
+          expect3(Object.keys(state).sort()).toEqual(["error", "messages", "unrelated"]);
+          expect3(state.messages).toEqual([{ id: "one", $type: "undefined" }]);
+          expect3(state.error).toBeInstanceOf(RangeError);
+        }
+        expect3(replayed.version).toBe(1);
+        if (harness.restart) {
+          const restarted = await harness.restart();
+          const reopened = await restarted.stores.getStore({ definition: Store, id: "codec" });
+          expect3(Object.keys(reopened.state).sort()).toEqual(["error", "messages", "unrelated"]);
+          expect3(reopened.state.error).toBeInstanceOf(RangeError);
+        }
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("rejects asynchronous updaters and claims without committing", async () => {
+      const harness = await create();
+      try {
+        seed(TakeStore, "sync-callbacks", { messages: [{ id: "one" }] });
+        await harness.runtime.stores.getStore({
+          definition: TakeStore,
+          id: "sync-callbacks"
+        });
+        await expect3(harness.runtime.stores.updateStore({
+          definition: TakeStore,
+          id: "sync-callbacks",
+          updater: async (draft) => {
+            draft.messages.push({ id: "two" });
+          }
+        })).rejects.toThrow(/synchronous/);
+        await expect3(harness.runtime.stores.takeFromStore({
+          definition: TakeStore,
+          id: "sync-callbacks",
+          selector: (state) => state.messages[0],
+          claim: async (_draft, selected) => {
+            selected.claimedBy = "worker";
+          }
+        })).rejects.toThrow(/synchronous/);
+        expect3(await harness.runtime.stores.getStore({ definition: TakeStore, id: "sync-callbacks" })).toMatchObject({ state: { messages: [{ id: "one" }] }, version: 0 });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("retries an updater after an interleaved CAS conflict", async () => {
+      let validations = 0;
+      let racing = false;
+      let release;
+      const bothPrepared = new Promise((resolve) => {
+        release = resolve;
+      });
+      const raceSchema = {
+        "~standard": {
+          version: 1,
+          vendor: "yieldstar-conformance",
+          async validate(value) {
+            if (!racing)
+              return { value };
+            validations++;
+            if (validations === 2)
+              release();
+            if (validations <= 2)
+              await bothPrepared;
+            return { value };
+          }
+        }
+      };
+      const RaceStore = defineStore2(`${name}-cas-race-conformance`, raceSchema, {
+        initial: () => ({ messages: [] })
+      });
+      const harness = await create();
+      let updaterRuns = 0;
+      try {
+        await harness.runtime.stores.getStore({
+          definition: RaceStore,
+          id: "race"
+        });
+        racing = true;
+        validations = 0;
+        const results = await Promise.all(["a", "b"].map((id) => harness.runtime.stores.updateStore({
+          definition: RaceStore,
+          id: "race",
+          updater(draft) {
+            updaterRuns++;
+            draft.messages.push(id);
+          }
+        })));
+        expect3(updaterRuns).toBe(3);
+        expect3(results.map((result) => result.version).sort()).toEqual([1, 2]);
+        const final = await harness.runtime.stores.getStore({ definition: RaceStore, id: "race" });
+        expect3(final).toMatchObject({ state: { messages: ["a", "b"] }, version: 2 });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("makes a step receipt and mutation exactly-once under concurrent replay", async () => {
+      const harness = await create();
+      let updaterRuns = 0;
+      try {
+        await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "receipt-race"
+        });
+        const results = await Promise.all(["a", "b"].map((id) => harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "receipt-race",
+          stepId: { executionId: "producer", stepKey: "append" },
+          updater(draft) {
+            updaterRuns++;
+            draft.messages.push({ id });
+          }
+        })));
+        expect3(results[1]).toEqual(results[0]);
+        expect3(updaterRuns).toBeGreaterThanOrEqual(1);
+        expect3(updaterRuns).toBeLessThanOrEqual(2);
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "receipt-race" })).toMatchObject({ state: { messages: [{ id: results[0].state.messages[0].id }] }, version: 1 });
+        let replayRuns = 0;
+        expect3(await harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "receipt-race",
+          stepId: { executionId: "producer", stepKey: "append" },
+          updater() {
+            replayRuns++;
+          }
+        })).toEqual(results[0]);
+        expect3(replayRuns).toBe(0);
+        await harness.runtime.stores.deleteStore({ definition: Store, id: "receipt-race" });
+        const recreated = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "receipt-race"
+        });
+        expect3(await harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "receipt-race",
+          stepId: { executionId: "producer", stepKey: "append" },
+          updater() {
+            replayRuns++;
+          }
+        })).toEqual(results[0]);
+        expect3(replayRuns).toBe(0);
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "receipt-race" })).toEqual(recreated);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("scopes receipts by execution and step key", async () => {
+      const harness = await create();
+      try {
+        await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "receipt-scope"
+        });
+        for (const [executionId, stepKey] of [["one", "a"], ["one", "b"], ["two", "a"]]) {
+          await harness.runtime.stores.updateStore({
+            definition: Store,
+            id: "receipt-scope",
+            stepId: { executionId, stepKey },
+            updater(draft) {
+              draft.messages.push({ id: `${executionId}:${stepKey}` });
+            }
+          });
+        }
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "receipt-scope" })).toMatchObject({
+          state: { messages: [{ id: "one:a" }, { id: "one:b" }, { id: "two:a" }] },
+          version: 3
+        });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("applies calls without step ids independently and returns detached state", async () => {
+      const harness = await create();
+      try {
+        const initial = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "external-update"
+        });
+        initial.state.messages.push({ id: "caller-only" });
+        for (const id of ["one", "two"]) {
+          const result = await harness.runtime.stores.updateStore({
+            definition: Store,
+            id: "external-update",
+            updater(draft) {
+              draft.messages.push({ id });
+            }
+          });
+          result.state.messages.push({ id: "result-only" });
+        }
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "external-update" })).toMatchObject({ state: { messages: [{ id: "one" }, { id: "two" }] }, version: 2 });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("committed state contains no tracking proxies", async () => {
+      const harness = await create();
+      try {
+        seed(Store, "plain-state", { messages: [{ id: "one" }] });
+        await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "plain-state"
+        });
+        await harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "plain-state",
+          updater(draft) {
+            draft.lastMessage = draft.messages[0];
+            draft.wrapped = { inner: draft.messages };
+          }
+        });
+        const snapshot = await harness.runtime.stores.getStore({ definition: Store, id: "plain-state" });
+        expect3(() => structuredClone(snapshot.state)).not.toThrow();
+        expect3(snapshot.state.lastMessage).toEqual({ id: "one" });
+        expect3(snapshot.state.wrapped).toEqual({
+          inner: [{ id: "one" }]
+        });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("mutating updates do not deep-diff the full state", async () => {
+      const PerformanceStore = defineStore2(`${name}-bounded-update-conformance`, schema2(), { initial: () => ({ changed: 0, large: {} }) });
+      const harness = await create();
+      const size = 1000;
+      const large = Object.fromEntries(Array.from({ length: size }, (_, index) => [`key-${index}`, index]));
+      const instrument = () => {
+        let reads = 0;
+        const value = new Proxy(large, {
+          get(target, property, receiver) {
+            if (typeof property === "string" && property.startsWith("key-"))
+              reads++;
+            return Reflect.get(target, property, receiver);
+          }
+        });
+        return { value, reads: () => reads };
+      };
+      try {
+        await harness.runtime.stores.getStore({
+          definition: PerformanceStore,
+          id: "mutating"
+        });
+        const mutating = instrument();
+        await harness.runtime.stores.updateStore({
+          definition: PerformanceStore,
+          id: "mutating",
+          updater(draft) {
+            draft.changed = 1;
+            draft.large = mutating.value;
+          }
+        });
+        await harness.runtime.stores.getStore({
+          definition: PerformanceStore,
+          id: "replacement"
+        });
+        const replacement = instrument();
+        await harness.runtime.stores.updateStore({
+          definition: PerformanceStore,
+          id: "replacement",
+          updater: () => ({ changed: 1, large: replacement.value })
+        });
+        expect3(replacement.reads() - mutating.reads()).toBeGreaterThanOrEqual(size);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("conditional updates conflict and replay ledger-first", async () => {
+      const harness = await create();
+      let updaterRuns = 0;
+      try {
+        const snapshot = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "conditional"
+        });
+        const stepId = { executionId: "execution", stepKey: "conditional" };
+        const committed = await harness.runtime.stores.updateStoreFrom({
+          definition: Store,
+          id: "conditional",
+          snapshot,
+          stepId,
+          updater(draft) {
+            updaterRuns++;
+            draft.messages.push({ id: "first" });
+          }
+        });
+        await harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "conditional",
+          updater(draft) {
+            draft.messages.push({ id: "second" });
+          }
+        });
+        expect3(await harness.runtime.stores.updateStoreFrom({
+          definition: Store,
+          id: "conditional",
+          snapshot: { ...snapshot, instanceId: "" },
+          stepId,
+          updater() {
+            updaterRuns++;
+          }
+        })).toEqual(committed);
+        expect3(updaterRuns).toBe(1);
+        expect3(await harness.runtime.stores.updateStoreFrom({
+          definition: Store,
+          id: "conditional",
+          snapshot,
+          updater() {
+            updaterRuns++;
+          }
+        })).toMatchObject({ updated: false, expectedVersion: 0, actualVersion: 2 });
+        expect3(updaterRuns).toBe(1);
+        await expect3(harness.runtime.stores.updateStoreFrom({
+          definition: Store,
+          id: "conditional",
+          snapshot: { ...snapshot, instanceId: "" },
+          updater() {}
+        })).rejects.toThrow(/missing instanceId/);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("claims distinct values and records only matched takes", async () => {
+      const harness = await create();
+      let selectorRuns = 0;
+      let claimRuns = 0;
+      try {
+        seed(TakeStore, "take", { messages: [{ id: "one" }, { id: "two" }] });
+        await harness.runtime.stores.getStore({
+          definition: TakeStore,
+          id: "take"
+        });
+        const take = (worker, stepKey) => harness.runtime.stores.takeFromStore({
+          definition: TakeStore,
+          id: "take",
+          stepId: { executionId: "execution", stepKey },
+          selector: (state) => {
+            selectorRuns++;
+            return state.messages.find((message) => !message.claimedBy);
+          },
+          claim: (_draft, selected) => {
+            claimRuns++;
+            selected.claimedBy = worker;
+          }
+        });
+        const [first, second] = await Promise.all([take("a", "a"), take("b", "b")]);
+        if (!first.matched || !second.matched)
+          throw new Error("both takes must match");
+        expect3(first.selected.id).not.toBe(second.selected.id);
+        expect3([first.version, second.version].sort()).toEqual([1, 2]);
+        const selectorRunsAfterCommit = selectorRuns;
+        const claimRunsAfterCommit = claimRuns;
+        expect3(await take("ignored", "a")).toEqual(first);
+        expect3(selectorRuns).toBe(selectorRunsAfterCommit);
+        expect3(claimRuns).toBe(claimRunsAfterCommit);
+        expect3(await harness.runtime.stores.getStore({ definition: TakeStore, id: "take" })).toMatchObject({ version: 2 });
+        const miss = await harness.runtime.stores.takeFromStore({
+          definition: TakeStore,
+          id: "take",
+          stepId: { executionId: "execution", stepKey: "later" },
+          selector: (state) => state.messages.find((message) => !message.claimedBy),
+          claim() {}
+        });
+        if (miss.matched)
+          throw new Error("take must not match");
+        expect3(miss.version).toBe(2);
+        expect3(miss.readPaths).toContainEqual(["messages"]);
+        await harness.runtime.stores.updateStore({
+          definition: TakeStore,
+          id: "take",
+          updater(draft) {
+            draft.messages.push({ id: "three" });
+          }
+        });
+        expect3(await harness.runtime.stores.takeFromStore({
+          definition: TakeStore,
+          id: "take",
+          stepId: { executionId: "execution", stepKey: "later" },
+          selector: (state) => state.messages.find((message) => !message.claimedBy),
+          claim: (_draft, selected) => {
+            selected.claimedBy = "c";
+          }
+        })).toMatchObject({ matched: true });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("protects recreated stores during conditional deletion and replays the receipt", async () => {
+      const harness = await create();
+      try {
+        const original = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "delete"
+        });
+        await harness.runtime.stores.updateStore({
+          definition: Store,
+          id: "delete",
+          updater(draft) {
+            draft.messages.push({ id: "changed" });
+          }
+        });
+        expect3(await harness.runtime.stores.deleteStoreFrom({ definition: Store, id: "delete", snapshot: original })).toMatchObject({ deleted: false, reason: "conflict" });
+        const current = await harness.runtime.stores.getStore({ definition: Store, id: "delete" });
+        const stepId = { executionId: "execution", stepKey: "delete" };
+        expect3(await harness.runtime.stores.deleteStoreFrom({ definition: Store, id: "delete", snapshot: current, stepId })).toEqual({ deleted: true });
+        const recreated = await harness.runtime.stores.getStore({
+          definition: Store,
+          id: "delete"
+        });
+        expect3(recreated.instanceId).not.toBe(original.instanceId);
+        expect3(await harness.runtime.stores.deleteStoreFrom({ definition: Store, id: "delete", snapshot: current, stepId })).toEqual({ deleted: true });
+        expect3(await harness.runtime.stores.getStore({ definition: Store, id: "delete" })).toEqual(recreated);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    describe3("missing stores (RFC 006)", () => {
+      function countedStore(suffix, validate) {
+        const evaluations = [];
+        const countedSchema = {
+          "~standard": {
+            version: 1,
+            vendor: "yieldstar-conformance",
+            async validate(value) {
+              await validate?.();
+              return { value };
+            }
+          }
+        };
+        const definition = defineStore2(`${name}-${suffix}-missing-conformance`, countedSchema, {
+          initial(id) {
+            evaluations.push(id);
+            return { createdBy: `initial-${evaluations.length}`, messages: [] };
+          }
+        });
+        return { definition, evaluations };
+      }
+      test3("every operation on a missing store creates it from initial in the same write", async () => {
+        const harness = await create();
+        const { stores } = harness.runtime;
+        const { definition, evaluations } = countedStore("operations");
+        const stepId = (stepKey) => ({ executionId: "operations", stepKey });
+        try {
+          expect3(await stores.getStore({ definition, id: "get" })).toMatchObject({
+            state: { createdBy: "initial-1", messages: [] },
+            version: 0
+          });
+          const updated = await stores.updateStore({
+            definition,
+            id: "update",
+            stepId: stepId("update"),
+            updater(draft) {
+              draft.messages.push({ id: "one" });
+            }
+          });
+          expect3(updated).toEqual({
+            state: { createdBy: "initial-2", messages: [{ id: "one" }] },
+            previousVersion: 0,
+            version: 1
+          });
+          const taken = await stores.takeFromStore({
+            definition,
+            id: "take",
+            stepId: stepId("take"),
+            selector: (state) => state.createdBy,
+            claim(draft) {
+              draft.messages.push({ id: "claimed" });
+            }
+          });
+          expect3(taken).toMatchObject({ matched: true, selected: "initial-3", version: 1 });
+          const unmatched = await stores.takeFromStore({
+            definition,
+            id: "unmatched-take",
+            selector: (state) => state.messages[0],
+            claim() {}
+          });
+          expect3(unmatched).toMatchObject({ matched: false, version: 0 });
+          const stale = { state: undefined, instanceId: "stale", version: 0 };
+          expect3(await stores.updateStoreFrom({
+            definition,
+            id: "update-from",
+            snapshot: stale,
+            updater() {}
+          })).toMatchObject({ updated: false, expectedInstanceId: "stale", actualVersion: 0 });
+          expect3(await stores.deleteStoreFrom({ definition, id: "delete-from", snapshot: stale })).toMatchObject({ deleted: false, reason: "conflict", actualVersion: 0 });
+          expect3(evaluations).toEqual([
+            "get",
+            "update",
+            "take",
+            "unmatched-take",
+            "update-from",
+            "delete-from"
+          ]);
+          expect3(await stores.listStores(definition)).toEqual([
+            "delete-from",
+            "get",
+            "take",
+            "unmatched-take",
+            "update",
+            "update-from"
+          ]);
+          expect3(await stores.getStore({ definition, id: "update" })).toMatchObject({
+            state: updated.state,
+            version: 1
+          });
+          expect3(await stores.getStore({ definition, id: "take" })).toMatchObject({
+            state: { createdBy: "initial-3", messages: [{ id: "claimed" }] },
+            instanceId: taken.instanceId,
+            version: 1
+          });
+          expect3((await stores.getStore({ definition, id: "unmatched-take" })).instanceId).toBe(unmatched.instanceId);
+          expect3(evaluations).toHaveLength(6);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("evaluates initial only when the store is missing", async () => {
+        const harness = await create();
+        const { stores } = harness.runtime;
+        const { definition, evaluations } = countedStore("existing");
+        try {
+          const created = await stores.getStore({ definition, id: "existing" });
+          await stores.updateStore({
+            definition,
+            id: "existing",
+            updater(draft) {
+              draft.messages.push({ id: "one" });
+            }
+          });
+          const current = await stores.getStore({ definition, id: "existing" });
+          await stores.takeFromStore({
+            definition,
+            id: "existing",
+            selector: (state) => state.messages[0],
+            claim() {}
+          });
+          await stores.updateStoreFrom({ definition, id: "existing", snapshot: created, updater() {} });
+          await stores.deleteStoreFrom({ definition, id: "existing", snapshot: created });
+          expect3(evaluations).toEqual(["existing"]);
+          await stores.deleteStoreFrom({ definition, id: "existing", snapshot: current });
+          await stores.deleteStore({ definition, id: "existing" });
+          await stores.deleteStore({ definition, id: "never-read" });
+          expect3(await stores.listStores(definition)).toEqual([]);
+          expect3(evaluations).toEqual(["existing"]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("a falsy initial state is a stored state, not a missing store", async () => {
+        const harness = await create();
+        const { stores } = harness.runtime;
+        try {
+          for (const [index, falsy] of [0, "", false, null].entries()) {
+            let evaluations = 0;
+            const Falsy = defineStore2(`${name}-falsy-${index}-missing-conformance`, schema2(), {
+              initial() {
+                evaluations += 1;
+                return falsy;
+              }
+            });
+            expect3(await stores.getStore({ definition: Falsy, id: "falsy" })).toMatchObject({
+              state: falsy,
+              version: 0
+            });
+            expect3(await stores.getStore({ definition: Falsy, id: "falsy" })).toMatchObject({
+              state: falsy,
+              version: 0
+            });
+            expect3(evaluations).toBe(1);
+          }
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("creates nothing when initial or the operation fails", async () => {
+        const harness = await create();
+        const { stores } = harness.runtime;
+        const Throwing = defineStore2(`${name}-throwing-missing-conformance`, schema2(), {
+          initial() {
+            throw new RangeError("no initial state");
+          }
+        });
+        const { definition } = countedStore("failing");
+        try {
+          await expect3(stores.getStore({ definition: Throwing, id: "throws" })).rejects.toThrow(RangeError);
+          await expect3(stores.updateStore({ definition: Throwing, id: "throws", updater() {} })).rejects.toThrow(RangeError);
+          expect3(await stores.listStores(Throwing)).toEqual([]);
+          await expect3(stores.updateStore({
+            definition,
+            id: "updater-throws",
+            updater() {
+              throw new RangeError("no update");
+            }
+          })).rejects.toThrow(RangeError);
+          await expect3(stores.takeFromStore({
+            definition,
+            id: "claim-throws",
+            selector: (state) => state.createdBy,
+            claim() {
+              throw new RangeError("no claim");
+            }
+          })).rejects.toThrow(RangeError);
+          expect3(await stores.listStores(definition)).toEqual([]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("records exactly one initial state when executions update a missing store at once", async () => {
+        let racing = false;
+        let arrived = 0;
+        let release;
+        const bothRead = new Promise((resolve) => {
+          release = resolve;
+        });
+        const { definition, evaluations } = countedStore("concurrent", async () => {
+          if (!racing || ++arrived > 2)
+            return;
+          if (arrived === 2)
+            release();
+          await bothRead;
+        });
+        const harness = await create();
+        const peer = await harness.createPeer?.() ?? harness.runtime;
+        try {
+          for (const id of ["get", "update"]) {
+            racing = true;
+            arrived = 0;
+            if (id === "get") {
+              const [first, second] = await Promise.all([
+                harness.runtime.stores.getStore({ definition, id }),
+                peer.stores.getStore({ definition, id })
+              ]);
+              expect3(second).toEqual(first);
+              continue;
+            }
+            const results = await Promise.all([harness.runtime, peer].map((runtime, index) => runtime.stores.updateStore({
+              definition,
+              id,
+              stepId: { executionId: `execution-${index}`, stepKey: "append" },
+              updater(draft) {
+                draft.messages.push({ id: `execution-${index}` });
+              }
+            })));
+            expect3(results.map((result) => result.version).sort()).toEqual([1, 2]);
+          }
+          racing = false;
+          expect3(evaluations).toEqual(["get", "get", "update", "update"]);
+          const got = await harness.runtime.stores.getStore({ definition, id: "get" });
+          expect3(got).toMatchObject({ version: 0, state: { messages: [] } });
+          expect3(["initial-1", "initial-2"]).toContain(got.state.createdBy);
+          const updated = await peer.stores.getStore({ definition, id: "update" });
+          expect3(updated.version).toBe(2);
+          expect3(["initial-3", "initial-4"]).toContain(updated.state.createdBy);
+          expect3(updated.state.messages.map((message) => message.id).sort()).toEqual([
+            "execution-0",
+            "execution-1"
+          ]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("replays a committed operation from its receipt without creating the store again", async () => {
+        const harness = await create();
+        const { definition, evaluations } = countedStore("receipt");
+        const stepId = { executionId: "crashed", stepKey: "append" };
+        let updaterRuns = 0;
+        const append = (runtime) => runtime.stores.updateStore({
+          definition,
+          id: "receipt",
+          stepId,
+          updater(draft) {
+            updaterRuns++;
+            draft.messages.push({ id: "once" });
+          }
+        });
+        try {
+          const committed = await append(harness.runtime);
+          const created = await harness.runtime.stores.getStore({ definition, id: "receipt" });
+          const runtime = await harness.restart?.() ?? harness.runtime;
+          expect3(await append(runtime)).toEqual(committed);
+          expect3(await runtime.stores.getStore({ definition, id: "receipt" })).toEqual(created);
+          expect3(created).toMatchObject({ state: { messages: [{ id: "once" }] }, version: 1 });
+          await runtime.stores.deleteStore({ definition, id: "receipt" });
+          expect3(await append(runtime)).toEqual(committed);
+          expect3(await runtime.stores.listStores(definition)).toEqual([]);
+          expect3(updaterRuns).toBe(1);
+          expect3(evaluations).toEqual(["receipt"]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("creates a store deleted between operations again from initial", async () => {
+        const harness = await create();
+        const { definition, evaluations } = countedStore("recreate");
+        const append = (runtime, id) => runtime.stores.updateStore({
+          definition,
+          id: "recreate",
+          stepId: { executionId: "recreate", stepKey: id },
+          updater(draft) {
+            draft.messages.push({ id });
+          }
+        });
+        try {
+          await append(harness.runtime, "first");
+          const original = await harness.runtime.stores.getStore({ definition, id: "recreate" });
+          await harness.runtime.stores.deleteStoreFrom({
+            definition,
+            id: "recreate",
+            snapshot: original,
+            stepId: { executionId: "recreate", stepKey: "delete" }
+          });
+          const runtime = await harness.restart?.() ?? harness.runtime;
+          expect3(await append(runtime, "second")).toEqual({
+            state: { createdBy: "initial-2", messages: [{ id: "second" }] },
+            previousVersion: 0,
+            version: 1
+          });
+          const recreated = await runtime.stores.getStore({ definition, id: "recreate" });
+          expect3(recreated.instanceId).not.toBe(original.instanceId);
+          expect3(evaluations).toEqual(["recreate", "recreate"]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+      test3("an unmatched take on a missing store lets its waiter wait", async () => {
+        const harness = await create();
+        const { runtime } = harness;
+        const { definition } = countedStore("waiting-take");
+        try {
+          await admitWaiting(runtime, "taker");
+          const miss = await runtime.stores.takeFromStore({
+            definition,
+            id: "waiting-take",
+            selector: (state) => state.messages[0],
+            claim() {}
+          });
+          if (miss.matched)
+            throw new Error("take must not match");
+          await runtime.stores.registerWaiter(waiter(definition.name, "waiting-take", miss.instanceId, miss.version, miss.readPaths, "taker"));
+          await expectNotWoken(runtime);
+          await runtime.stores.updateStore({
+            definition,
+            id: "waiting-take",
+            updater(draft) {
+              draft.messages.push({ id: "ready" });
+            }
+          });
+          await expectWoken(runtime, ["taker"]);
+        } finally {
+          await harness.dispose?.();
+        }
+      });
+    });
+    test3("wakes an intersecting waiter's execution and keeps the waiter until its step is recorded", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "execution");
+        const initial = await runtime.stores.getStore({
+          definition: Store,
+          id: "selective-wake"
+        });
+        await runtime.stores.registerWaiter(waiter(Store.name, "selective-wake", initial.instanceId, initial.version));
+        await expectNotWoken(runtime);
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "selective-wake",
+          updater(draft) {
+            draft.unrelated = 1;
+          }
+        });
+        await expectNotWoken(runtime);
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "selective-wake",
+          updater(draft) {
+            draft.messages.push({ id: "ready" });
+          }
+        });
+        await expectWoken(runtime, ["execution"]);
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "selective-wake",
+          updater(draft) {
+            draft.messages.push({ id: "again" });
+          }
+        });
+        await expectWoken(runtime, ["execution"]);
+        await recordStep(runtime, "execution", "some-other-step");
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "selective-wake",
+          updater(draft) {
+            draft.messages.push({ id: "third" });
+          }
+        });
+        await expectWoken(runtime, ["execution"]);
+        await recordStep(runtime, "execution");
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "selective-wake",
+          updater(draft) {
+            draft.messages.push({ id: "after-step" });
+          }
+        });
+        await expectNotWoken(runtime);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("collapses the wakes of many commits and waiters into one due execution", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "collapsed", "bystander");
+        for (const id of ["collapse-a", "collapse-b"]) {
+          const snapshot = await runtime.stores.getStore({
+            definition: Store,
+            id
+          });
+          await runtime.stores.registerWaiter({
+            ...waiter(Store.name, id, snapshot.instanceId, snapshot.version),
+            executionId: "collapsed",
+            stepKey: `wait-${id}`
+          });
+        }
+        const shared = await runtime.stores.getStore({
+          definition: Store,
+          id: "collapse-shared"
+        });
+        for (const executionId of ["collapsed", "bystander"]) {
+          await runtime.stores.registerWaiter(waiter(Store.name, "collapse-shared", shared.instanceId, shared.version, [["messages"]], executionId));
+        }
+        for (const id of ["collapse-a", "collapse-b", "collapse-a", "collapse-shared"]) {
+          await runtime.stores.updateStore({
+            definition: Store,
+            id,
+            updater(draft) {
+              draft.messages.push({ id: "ready" });
+            }
+          });
+        }
+        await expectWoken(runtime, ["bystander", "collapsed"]);
+        await expectNotWoken(runtime);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("ignores wakes for executions without a record or with a terminal outcome", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await runtime.executions.admit({
+          executionId: "finished",
+          workflowId: WORKFLOW_ID,
+          params: undefined,
+          context: new Map
+        });
+        const [lease] = await claimAll(runtime);
+        await runtime.executions.acknowledge({
+          lease,
+          outcome: { status: "completed", result: "done" }
+        });
+        const initial = await runtime.stores.getStore({
+          definition: Store,
+          id: "orphan-wake"
+        });
+        for (const executionId of ["unknown", "finished"]) {
+          await runtime.stores.registerWaiter(waiter(Store.name, "orphan-wake", initial.instanceId, initial.version, [["messages"]], executionId));
+        }
+        const committed = await runtime.stores.updateStore({
+          definition: Store,
+          id: "orphan-wake",
+          updater(draft) {
+            draft.messages.push({ id: "ready" });
+          }
+        });
+        expect3(committed.version).toBe(1);
+        await expectNotWoken(runtime);
+        expect3(await runtime.executions.get("unknown")).toBeUndefined();
+        expect3(await runtime.executions.get("finished")).toMatchObject({
+          status: "completed",
+          outcome: { status: "completed", result: "done" }
+        });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("deleteStore purges the store's waiters", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "execution");
+        const original = await runtime.stores.getStore({
+          definition: Store,
+          id: "deleted-waiters"
+        });
+        await runtime.stores.registerWaiter(waiter(Store.name, "deleted-waiters", original.instanceId, original.version));
+        await runtime.stores.deleteStore({ definition: Store, id: "deleted-waiters" });
+        const recreated = await runtime.stores.getStore({
+          definition: Store,
+          id: "deleted-waiters"
+        });
+        expect3(recreated.instanceId).not.toBe(original.instanceId);
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "deleted-waiters",
+          updater(draft) {
+            draft.messages.push({ id: "new-instance" });
+          }
+        });
+        await expectNotWoken(runtime);
+        const current = await runtime.stores.getStore({ definition: Store, id: "deleted-waiters" });
+        await runtime.stores.registerWaiter(waiter(Store.name, "deleted-waiters", current.instanceId, current.version));
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "deleted-waiters",
+          updater(draft) {
+            draft.messages.push({ id: "again" });
+          }
+        });
+        await expectWoken(runtime, ["execution"]);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("conditional deletion purges the store's waiters", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "execution");
+        const initial = await runtime.stores.getStore({
+          definition: Store,
+          id: "conditional-delete-wake"
+        });
+        await runtime.stores.registerWaiter(waiter(Store.name, "conditional-delete-wake", initial.instanceId, initial.version));
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "conditional-delete-wake",
+          updater(draft) {
+            draft.messages.push({ id: "old" });
+          }
+        });
+        await expectWoken(runtime, ["execution"]);
+        const current = await runtime.stores.getStore({
+          definition: Store,
+          id: "conditional-delete-wake"
+        });
+        expect3(await runtime.stores.deleteStoreFrom({
+          definition: Store,
+          id: "conditional-delete-wake",
+          snapshot: current
+        })).toEqual({ deleted: true });
+        await runtime.stores.getStore({
+          definition: Store,
+          id: "conditional-delete-wake"
+        });
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "conditional-delete-wake",
+          updater(draft) {
+            draft.messages.push({ id: "new" });
+          }
+        });
+        await expectNotWoken(runtime);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("wakes for replacement, take-claim, and shifted-array paths", async () => {
+      const QueueStore = defineStore2(`${name}-wake-paths-conformance`, schema2(), {
+        initial: seeded(`${name}-wake-paths-conformance`, { messages: [] })
+      });
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "replacement", "claim", "splice");
+        const replacement = await runtime.stores.getStore({
+          definition: QueueStore,
+          id: "replacement"
+        });
+        await runtime.stores.registerWaiter(waiter(QueueStore.name, "replacement", replacement.instanceId, replacement.version, [["messages"]], "replacement"));
+        await runtime.stores.updateStore({
+          definition: QueueStore,
+          id: "replacement",
+          updater: () => ({ messages: [{ id: "ready" }] })
+        });
+        await expectWoken(runtime, ["replacement"]);
+        seed(QueueStore, "claim", { messages: [{ id: "one" }] });
+        const claim = await runtime.stores.getStore({
+          definition: QueueStore,
+          id: "claim"
+        });
+        await runtime.stores.registerWaiter(waiter(QueueStore.name, "claim", claim.instanceId, claim.version, [["messages", 0, "claimedBy"]], "claim"));
+        const claimed = await runtime.stores.takeFromStore({
+          definition: QueueStore,
+          id: "claim",
+          selector: (state) => state.messages[0],
+          claim: (_draft, selected) => {
+            selected.claimedBy = "worker";
+          }
+        });
+        if (!claimed.matched)
+          throw new Error("take must match");
+        expect3(claimed.selected).toEqual({ id: "one", claimedBy: "worker" });
+        await expectWoken(runtime, ["claim"]);
+        seed(QueueStore, "splice", { messages: [{ id: "one" }, { id: "two" }] });
+        const splice = await runtime.stores.getStore({
+          definition: QueueStore,
+          id: "splice"
+        });
+        await runtime.stores.registerWaiter(waiter(QueueStore.name, "splice", splice.instanceId, splice.version, [["messages", 0, "id"]], "splice"));
+        await runtime.stores.takeFromStore({
+          definition: QueueStore,
+          id: "splice",
+          selector: (state) => state.messages[0],
+          claim: (draft) => {
+            draft.messages.splice(0, 1);
+          }
+        });
+        await expectWoken(runtime, ["splice"]);
+        expect3(await runtime.stores.getStore({ definition: QueueStore, id: "splice" })).toMatchObject({ state: { messages: [{ id: "two" }] }, version: 1 });
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("immediately wakes a stale registration", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      try {
+        await admitWaiting(runtime, "behind", "replaced", "missing");
+        const initial = await runtime.stores.getStore({
+          definition: Store,
+          id: "stale-registration"
+        });
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "stale-registration",
+          updater(draft) {
+            draft.messages.push({ id: "first" });
+          }
+        });
+        await runtime.stores.registerWaiter(waiter(Store.name, "stale-registration", initial.instanceId, initial.version, [["messages"]], "behind"));
+        await expectWoken(runtime, ["behind"]);
+        const original = await runtime.stores.getStore({
+          definition: Store,
+          id: "stale-instance"
+        });
+        await runtime.stores.deleteStore({ definition: Store, id: "stale-instance" });
+        await runtime.stores.getStore({
+          definition: Store,
+          id: "stale-instance"
+        });
+        await runtime.stores.registerWaiter(waiter(Store.name, "stale-instance", original.instanceId, original.version, [["messages"]], "replaced"));
+        await expectWoken(runtime, ["replaced"]);
+        const gone = await runtime.stores.getStore({
+          definition: Store,
+          id: "stale-missing"
+        });
+        await runtime.stores.deleteStore({ definition: Store, id: "stale-missing" });
+        await runtime.stores.registerWaiter(waiter(Store.name, "stale-missing", gone.instanceId, gone.version, [["messages"]], "missing"));
+        await expectWoken(runtime, ["missing"]);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("does not lose a waiter registration racing a commit", async () => {
+      const harness = await create();
+      const { runtime } = harness;
+      const executionIds = Array.from({ length: 10 }, (_, index) => `registration-race-${index}`);
+      try {
+        await admitWaiting(runtime, ...executionIds);
+        for (const [index, id] of executionIds.entries()) {
+          const initial = await runtime.stores.getStore({
+            definition: Store,
+            id
+          });
+          const register = () => runtime.stores.registerWaiter(waiter(Store.name, id, initial.instanceId, initial.version, [["messages"]], id));
+          const update = () => runtime.stores.updateStore({
+            definition: Store,
+            id,
+            updater(draft) {
+              draft.messages.push({ id: "ready" });
+            }
+          });
+          await Promise.all(index % 2 === 0 ? [register(), update()] : [update(), register()]);
+        }
+        await expectWoken(runtime, executionIds);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("qualifies declared shared-client capabilities", async () => {
+      const harness = await create();
+      try {
+        if (!harness.createPeer)
+          return;
+        const primary = harness.runtime;
+        const peer = await harness.createPeer();
+        await primary.stores.getStore({
+          definition: Store,
+          id: "shared-client"
+        });
+        const results = await Promise.all([
+          primary.stores.updateStore({
+            definition: Store,
+            id: "shared-client",
+            updater(draft) {
+              draft.messages.push({ id: "a" });
+            }
+          }),
+          peer.stores.updateStore({
+            definition: Store,
+            id: "shared-client",
+            updater(draft) {
+              draft.messages.push({ id: "b" });
+            }
+          })
+        ]);
+        expect3(results.map((result) => result.version).sort()).toEqual([1, 2]);
+        await admitWaiting(primary, "shared-wake");
+        const wakeInitial = await peer.stores.getStore({
+          definition: Store,
+          id: "shared-wake"
+        });
+        await peer.stores.registerWaiter(waiter(Store.name, "shared-wake", wakeInitial.instanceId, wakeInitial.version, [["messages"]], "shared-wake"));
+        await primary.stores.updateStore({
+          definition: Store,
+          id: "shared-wake",
+          updater(draft) {
+            draft.messages.push({ id: "ready" });
+          }
+        });
+        await expectWoken(peer, ["shared-wake"]);
+        await recordStep(primary, "shared-wake");
+        await peer.stores.updateStore({
+          definition: Store,
+          id: "shared-wake",
+          updater(draft) {
+            draft.messages.push({ id: "after-step" });
+          }
+        });
+        await expectNotWoken(primary);
+        const registrar = await harness.createPeer();
+        const committer = await harness.createPeer();
+        const executionIds = Array.from({ length: 10 }, (_, index) => `shared-registration-race-${index}`);
+        await admitWaiting(primary, ...executionIds);
+        for (const [index, id] of executionIds.entries()) {
+          const snapshot = await committer.stores.getStore({
+            definition: Store,
+            id
+          });
+          const register = () => registrar.stores.registerWaiter(waiter(Store.name, id, snapshot.instanceId, snapshot.version, [["messages"]], id));
+          const update = () => committer.stores.updateStore({
+            definition: Store,
+            id,
+            updater(draft) {
+              draft.messages.push({ id: "ready" });
+            }
+          });
+          await Promise.all(index % 2 === 0 ? [register(), update()] : [update(), register()]);
+        }
+        await expectWoken(primary, executionIds);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+    test3("qualifies declared durable-wake capabilities", async () => {
+      const harness = await create();
+      try {
+        if (!harness.restart)
+          return;
+        const { runtime } = harness;
+        await admitWaiting(runtime, "durable-wake", "durable-waiter");
+        for (const executionId of ["durable-wake", "durable-waiter"]) {
+          const initial = await runtime.stores.getStore({
+            definition: Store,
+            id: executionId
+          });
+          await runtime.stores.registerWaiter(waiter(Store.name, executionId, initial.instanceId, initial.version, [["messages"]], executionId));
+        }
+        await runtime.stores.updateStore({
+          definition: Store,
+          id: "durable-wake",
+          updater(draft) {
+            draft.messages.push({ id: "ready" });
+          }
+        });
+        const restarted = await harness.restart();
+        expect3(await restarted.stores.getStore({ definition: Store, id: "durable-wake" })).toMatchObject({ state: { messages: [{ id: "ready" }] }, version: 1 });
+        await expectWoken(restarted, ["durable-wake"]);
+        for (const id of ["durable-wake", "durable-waiter"]) {
+          await restarted.stores.updateStore({
+            definition: Store,
+            id,
+            updater(draft) {
+              draft.messages.push({ id: "after-restart" });
+            }
+          });
+        }
+        await expectWoken(restarted, ["durable-wake", "durable-waiter"]);
+      } finally {
+        await harness.dispose?.();
+      }
+    });
+  });
+}
+export {
+  registerEffectClientConformance,
+  registerExecutionClientConformance,
+  registerStoreClientConformance
+};