@rotorsoft/act-tck 1.41.4 → 2.0.0

package/dist/index.cjs

@@ -82,8 +82,7 @@ var seed_stream = async (store, stream, count, correlation) => {
   const out = [];
   for (let i = 0; i < count; i++) {
     const committed = await store.commit(
-      stream,
-      [inc(1)],
+      [{ stream, msgs: [inc(1)] }],
       make_meta({ correlation, stream })
     );
     out.push(...committed);
@@ -646,14 +645,17 @@ var apply_plan = async (store, plan, pii_isolation) => {
     if (op.t === "commit") {
       const msgs = op.pii && pii_isolation ? op.msgs.map((m, i) => i === 0 ? { ...m, pii: op.pii } : m) : op.msgs;
       await store.commit(
-        op.stream,
-        msgs,
+        [{ stream: op.stream, msgs }],
         make_meta({ stream: op.stream, correlation: plan.correlation })
       );
     } else if (op.t === "snapshot") {
       await store.commit(
-        op.stream,
-        [{ name: import_act.SNAP_EVENT, data: { count: op.count } }],
+        [
+          {
+            stream: op.stream,
+            msgs: [{ name: import_act.SNAP_EVENT, data: { count: op.count } }]
+          }
+        ],
         make_meta({ stream: op.stream, correlation: plan.correlation })
       );
     } else if (op.t === "truncate") {
@@ -662,8 +664,12 @@ var apply_plan = async (store, plan, pii_isolation) => {
       ]);
     } else if (op.t === "truncate_windowed") {
       await store.commit(
-        op.stream,
-        [{ name: import_act.SNAP_EVENT, data: { count: 1 } }],
+        [
+          {
+            stream: op.stream,
+            msgs: [{ name: import_act.SNAP_EVENT, data: { count: 1 } }]
+          }
+        ],
         make_meta({ stream: op.stream, correlation: plan.correlation })
       );
       await store.truncate([
@@ -974,8 +980,7 @@ var runStorePropertyTck = (options) => {
           for (const { stream, count } of commits) {
             const before = expected.get(stream) ?? -1;
             const committed = await store.commit(
-              stream,
-              events(count),
+              [{ stream, msgs: events(count) }],
               make_meta({ stream })
             );
             committed.forEach((e, i) => {
@@ -1000,8 +1005,7 @@ var runStorePropertyTck = (options) => {
           await reset2();
           for (const { stream: stream2, count } of commits) {
             await store.commit(
-              stream2,
-              events(count),
+              [{ stream: stream2, msgs: events(count) }],
               make_meta({ stream: stream2 })
             );
           }
@@ -1009,10 +1013,8 @@ var runStorePropertyTck = (options) => {
           const before = await collect(store, { stream, stream_exact: true });
           await (0, import_vitest8.expect)(
             store.commit(
-              stream,
-              [inc(1)],
-              make_meta({ stream }),
-              before.length
+              [{ stream, msgs: [inc(1)], expectedVersion: before.length }],
+              make_meta({ stream })
             )
           ).rejects.toThrow();
           const after = await collect(store, { stream, stream_exact: true });
@@ -1039,8 +1041,7 @@ var runStorePropertyTck = (options) => {
           for (const op of ops) {
             if (op.kind === "commit") {
               await store.commit(
-                op.stream,
-                [inc(1)],
+                [{ stream: op.stream, msgs: [inc(1)] }],
                 make_meta({ stream: op.stream })
               );
             } else if (op.kind === "claim") {
@@ -1082,8 +1083,7 @@ var runStorePropertyTck = (options) => {
           await store.subscribe(all.map((stream) => ({ stream })));
           for (const stream of commitsA) {
             await store.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
           }
@@ -1095,8 +1095,7 @@ var runStorePropertyTck = (options) => {
           for (const l of acked1) watermark1.set(l.stream, l.at);
           for (const stream of commitsB) {
             await store.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
           }
@@ -1122,8 +1121,7 @@ var runStorePropertyTck = (options) => {
           await store.subscribe(streams.map((stream) => ({ stream })));
           for (const stream of commits) {
             await store.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
           }
@@ -1133,8 +1131,7 @@ var runStorePropertyTck = (options) => {
           const blockedSet = new Set(claimed.map((l) => l.stream));
           await store.subscribe([{ stream: "ctrl" }]);
           await store.commit(
-            "ctrl",
-            [inc(1)],
+            [{ stream: "ctrl", msgs: [inc(1)] }],
             make_meta({ stream: "ctrl" })
           );
           await mark_all(store);
@@ -1213,14 +1210,12 @@ var runStoreTck = (options) => {
             await zero_config.seed();
             const s = `default-config-${uid()}`;
             const first = await zero_config.commit(
-              s,
-              [inc(1)],
+              [{ stream: s, msgs: [inc(1)] }],
               make_meta({ stream: s })
             );
             (0, import_vitest9.expect)(first[0].version).toBe(0);
             const second = await zero_config.commit(
-              s,
-              [inc(2)],
+              [{ stream: s, msgs: [inc(2)] }],
               make_meta({ stream: s })
             );
             (0, import_vitest9.expect)(second[0].version).toBe(1);
@@ -1236,12 +1231,371 @@ var runStoreTck = (options) => {
         });
       });
     }
+    (0, import_vitest9.describe)("commit across streams", () => {
+      const meta = make_meta({ stream: "across" });
+      const count = (stream) => store.query(() => {
+      }, { stream, stream_exact: true });
+      (0, import_vitest9.it)("lands every append, each from its own head, with ids in append order", async () => {
+        const a = `across-a-${uid()}`;
+        const b = `across-b-${uid()}`;
+        await store.commit(
+          [{ stream: a, msgs: [inc(1)] }],
+          meta
+        );
+        const committed = await store.commit(
+          [
+            { stream: a, msgs: [inc(2), inc(3)], expectedVersion: 0 },
+            { stream: b, msgs: [dec(4)], expectedVersion: -1 }
+          ],
+          meta
+        );
+        (0, import_vitest9.expect)(committed.map((e) => [e.stream, e.version])).toEqual([
+          [a, 1],
+          [a, 2],
+          [b, 0]
+        ]);
+        for (let i = 1; i < committed.length; i++)
+          (0, import_vitest9.expect)(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+        const read = [];
+        await store.query((e) => read.push(e.id), {
+          after: committed[0].id - 1
+        });
+        (0, import_vitest9.expect)(read.filter((id) => committed.some((e) => e.id === id))).toEqual(
+          committed.map((e) => e.id)
+        );
+      });
+      (0, import_vitest9.it)("stores nothing when the first, a middle or the last append is stale, and names its stream", async () => {
+        for (const at of [0, 1, 2]) {
+          const streams = [0, 1, 2].map((i) => `across-stale-${i}-${uid()}`);
+          for (const stream of streams)
+            await store.commit(
+              [{ stream, msgs: [inc(1)] }],
+              meta
+            );
+          const refused = store.commit(
+            streams.map((stream, i) => ({
+              stream,
+              msgs: [inc(2)],
+              expectedVersion: i === at ? 5 : 0
+            })),
+            meta
+          );
+          await (0, import_vitest9.expect)(refused).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
+          await (0, import_vitest9.expect)(refused).rejects.toMatchObject({ stream: streams[at] });
+          for (const stream of streams) (0, import_vitest9.expect)(await count(stream)).toBe(1);
+        }
+      });
+      (0, import_vitest9.it)("refuses a stream named twice and an append with no events, storing nothing", async () => {
+        const a = `across-twice-${uid()}`;
+        const b = `across-empty-${uid()}`;
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [
+              { stream: a, msgs: [inc(1)] },
+              { stream: a, msgs: [inc(2)] }
+            ],
+            meta
+          )
+        ).rejects.toThrow(`stream "${a}" is named twice`);
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [
+              { stream: a, msgs: [inc(1)] },
+              { stream: b, msgs: [] }
+            ],
+            meta
+          )
+        ).rejects.toThrow(`the append to "${b}" has no events`);
+        (0, import_vitest9.expect)(await count(a)).toBe(0);
+        (0, import_vitest9.expect)(await count(b)).toBe(0);
+      });
+      (0, import_vitest9.it)("commits nothing for no appends", async () => {
+        (0, import_vitest9.expect)(await store.commit([], meta)).toEqual([]);
+      });
+      (0, import_vitest9.it)("lands an unguarded append beside guarded ones", async () => {
+        const a = `across-guarded-${uid()}`;
+        const b = `across-free-${uid()}`;
+        await store.commit(
+          [{ stream: b, msgs: [inc(1)] }],
+          meta
+        );
+        const committed = await store.commit(
+          [
+            { stream: a, msgs: [inc(1)], expectedVersion: -1 },
+            { stream: b, msgs: [inc(2)] }
+          ],
+          meta
+        );
+        (0, import_vitest9.expect)(committed.map((e) => [e.stream, e.version])).toEqual([
+          [a, 0],
+          [b, 1]
+        ]);
+      });
+      (0, import_vitest9.it)("stores every event of every append, whole", async () => {
+        const a = `across-whole-a-${uid()}`;
+        const b = `across-whole-b-${uid()}`;
+        const across = make_meta({ stream: a });
+        const committed = await store.commit(
+          [
+            { stream: a, msgs: [inc(1)] },
+            { stream: b, msgs: [inc(2), dec(3)] }
+          ],
+          across
+        );
+        const shape = (e) => [
+          e.name,
+          e.data,
+          e.meta
+        ];
+        const expected = [
+          ["Incremented", { amount: 2 }, across],
+          ["Decremented", { amount: 3 }, across]
+        ];
+        (0, import_vitest9.expect)(committed.filter((e) => e.stream === b).map(shape)).toEqual(
+          expected
+        );
+        const stored = [];
+        await store.query((e) => stored.push(e), {
+          stream: b,
+          stream_exact: true
+        });
+        (0, import_vitest9.expect)(stored.map(shape)).toEqual(expected);
+      });
+      import_vitest9.it.skipIf(!caps.pii_isolation)(
+        "keeps the sensitive fields of a later append",
+        async () => {
+          const a = `across-pii-a-${uid()}`;
+          const b = `across-pii-b-${uid()}`;
+          await store.commit(
+            [
+              { stream: a, msgs: [inc(1)] },
+              { stream: b, msgs: [{ ...inc(2), pii: { email: "e" } }] }
+            ],
+            make_meta({ stream: a })
+          );
+          const stored = [];
+          await store.query((e) => stored.push(e.pii), {
+            stream: b,
+            stream_exact: true
+          });
+          (0, import_vitest9.expect)(stored).toEqual([{ email: "e" }]);
+        }
+      );
+      (0, import_vitest9.it)("leaves nothing of the commit that lost a race, on any of its streams", async () => {
+        const shared = `across-all-shared-${uid()}`;
+        const [x, y] = [`across-all-x-${uid()}`, `across-all-y-${uid()}`];
+        const race = (own) => store.commit(
+          [
+            { stream: own, msgs: [inc(1)], expectedVersion: -1 },
+            { stream: shared, msgs: [inc(1)], expectedVersion: -1 }
+          ],
+          meta
+        );
+        const rs = await Promise.allSettled([race(x), race(y)]);
+        (0, import_vitest9.expect)(rs.filter((r) => r.status === "fulfilled")).toHaveLength(1);
+        (0, import_vitest9.expect)(await count(x) + await count(y)).toBe(1);
+      });
+      (0, import_vitest9.it)("lets one of two racing commits on a shared stream win, and both on disjoint streams", async () => {
+        const shared = `across-shared-${uid()}`;
+        const [x, y] = [`across-x-${uid()}`, `across-y-${uid()}`];
+        const race = (own, other) => store.commit(
+          [
+            { stream: own, msgs: [inc(1)], expectedVersion: -1 },
+            { stream: other, msgs: [inc(1)], expectedVersion: -1 }
+          ],
+          meta
+        );
+        const shared_race = await Promise.allSettled([
+          race(x, shared),
+          race(y, shared)
+        ]);
+        (0, import_vitest9.expect)(
+          shared_race.filter((r2) => r2.status === "fulfilled")
+        ).toHaveLength(1);
+        const lost = shared_race.find((r2) => r2.status === "rejected");
+        (0, import_vitest9.expect)(lost.reason).toBeInstanceOf(
+          import_act2.ConcurrencyError
+        );
+        (0, import_vitest9.expect)(await count(shared)).toBe(1);
+        const [p, q, r, t] = [0, 1, 2, 3].map((i) => `across-d${i}-${uid()}`);
+        const disjoint = await Promise.allSettled([race(p, q), race(r, t)]);
+        (0, import_vitest9.expect)(disjoint.every((d) => d.status === "fulfilled")).toBe(true);
+      });
+    });
+    (0, import_vitest9.describe)("what a commit, guard or truncate must not get wrong", () => {
+      const edge_uid = () => uid();
+      const E = (data = { a: 1 }, pii) => ({
+        name: "E",
+        data,
+        ...pii ? { pii } : {}
+      });
+      const edge_meta = (correlation = "m") => ({ correlation, causation: {} });
+      const rows = async (query) => {
+        const found = [];
+        await store.query((e) => found.push(e), query);
+        return found;
+      };
+      const one = (stream) => ({ stream, stream_exact: true });
+      (0, import_vitest9.it)("names the FIRST stale stream when two are stale", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        const e = await store.commit(
+          [
+            { stream: a, msgs: [E()], expectedVersion: 3 },
+            { stream: b, msgs: [E()], expectedVersion: 4 }
+          ],
+          edge_meta()
+        ).catch((x) => x);
+        (0, import_vitest9.expect)(e).toBeInstanceOf(import_act2.ConcurrencyError);
+        (0, import_vitest9.expect)(e.stream).toBe(a);
+      });
+      (0, import_vitest9.it)("checks a stale expectedVersion of 0 inside a multi-stream commit", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await store.commit(
+          [{ stream: b, msgs: [E(), E()] }],
+          edge_meta()
+        );
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [
+              { stream: a, msgs: [E()], expectedVersion: -1 },
+              { stream: b, msgs: [E()], expectedVersion: 0 }
+            ],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
+        (0, import_vitest9.expect)(await rows(one(a))).toHaveLength(0);
+      });
+      (0, import_vitest9.it)("attaches meta to every append, not just the last", async () => {
+        const ss = [0, 1, 2].map((i) => `m${i}-${edge_uid()}`);
+        const c = `corr-${edge_uid()}`;
+        await store.commit(
+          ss.map((stream) => ({ stream, msgs: [E()] })),
+          edge_meta(c)
+        );
+        for (const stream of ss)
+          (0, import_vitest9.expect)((await rows(one(stream)))[0].meta.correlation).toBe(c);
+      });
+      (0, import_vitest9.it)("refuses a stream named twice when not adjacent", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [
+              { stream: a, msgs: [E()] },
+              { stream: b, msgs: [E()] },
+              { stream: a, msgs: [E()] }
+            ],
+            edge_meta()
+          )
+        ).rejects.toThrow("named twice");
+        (0, import_vitest9.expect)(await rows(one(a))).toHaveLength(0);
+      });
+      (0, import_vitest9.it)("refuses a lone empty append (a version check alone)", async () => {
+        const a = `a-${edge_uid()}`;
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [{ stream: a, msgs: [], expectedVersion: -1 }],
+            edge_meta()
+          )
+        ).rejects.toThrow("no events");
+      });
+      (0, import_vitest9.it)("refuses an empty FIRST append", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [
+              { stream: a, msgs: [] },
+              { stream: b, msgs: [E()] }
+            ],
+            edge_meta()
+          )
+        ).rejects.toThrow("no events");
+        (0, import_vitest9.expect)(await rows(one(b))).toHaveLength(0);
+      });
+      (0, import_vitest9.it)("keeps the sensitive fields of the FIRST append", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await store.commit(
+          [
+            { stream: a, msgs: [E({}, { email: "x" })] },
+            { stream: b, msgs: [E()] }
+          ],
+          edge_meta()
+        );
+        (0, import_vitest9.expect)((await rows(one(a)))[0].pii).toEqual({ email: "x" });
+      });
+      (0, import_vitest9.it)("a guard below a trailing snapshot is stale", async () => {
+        const a = `a-${edge_uid()}`;
+        await store.commit([{ stream: a, msgs: [E()] }], edge_meta());
+        await store.commit(
+          [
+            {
+              stream: a,
+              msgs: [{ name: import_act2.SNAP_EVENT, data: {} }],
+              expectedVersion: 0
+            }
+          ],
+          edge_meta()
+        );
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 0 }],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
+      });
+      (0, import_vitest9.it)("a guard below a trailing tombstone is stale (what stops a writer during a close)", async () => {
+        const a = `a-${edge_uid()}`;
+        await store.commit([{ stream: a, msgs: [E()] }], edge_meta());
+        await store.commit(
+          [
+            {
+              stream: a,
+              msgs: [{ name: "__tombstone__", data: {} }],
+              expectedVersion: 0
+            }
+          ],
+          edge_meta()
+        );
+        await (0, import_vitest9.expect)(
+          store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 0 }],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
+      });
+      (0, import_vitest9.it)("a commit after a full truncate continues from the seed at version 0", async () => {
+        const a = `a-${edge_uid()}`;
+        await store.commit(
+          [{ stream: a, msgs: [E(), E(), E()] }],
+          edge_meta()
+        );
+        await store.truncate([{ stream: a, snapshot: { n: 3 } }]);
+        const [c] = await store.commit(
+          [{ stream: a, msgs: [E()], expectedVersion: 0 }],
+          edge_meta()
+        );
+        (0, import_vitest9.expect)(c.version).toBe(1);
+      });
+      (0, import_vitest9.it)("seeds a full truncate at version 0, carrying the meta it was given", async () => {
+        const a = `a-${edge_uid()}`;
+        await store.commit(
+          [{ stream: a, msgs: [E(), E(), E()] }],
+          edge_meta()
+        );
+        const c = `close-${edge_uid()}`;
+        const r = await store.truncate([
+          { stream: a, snapshot: { n: 3 }, meta: edge_meta(c) }
+        ]);
+        (0, import_vitest9.expect)(r.get(a).committed.version).toBe(0);
+        const [seed] = await rows({ ...one(a), with_snaps: true });
+        (0, import_vitest9.expect)(seed.version).toBe(0);
+        (0, import_vitest9.expect)(seed.meta.correlation).toBe(c);
+      });
+    });
     (0, import_vitest9.describe)("commit", () => {
       (0, import_vitest9.it)("returns committed events with sequenced ids and versions", async () => {
         const s = `commit-seq-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1), inc(2), dec(3)],
+          [{ stream: s, msgs: [inc(1), inc(2), dec(3)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(committed).toHaveLength(3);
@@ -1258,8 +1612,7 @@ var runStoreTck = (options) => {
         const s = `commit-meta-${uid()}`;
         const correlation = `cor-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s, correlation })
         );
         (0, import_vitest9.expect)(committed[0].stream).toBe(s);
@@ -1268,64 +1621,50 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("throws ConcurrencyError when expectedVersion is wrong", async () => {
         const s = `commit-cc-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(1)],
-          make_meta({ stream: s }),
-          0
+          [{ stream: s, msgs: [inc(1)], expectedVersion: 0 }],
+          make_meta({ stream: s })
         );
         await (0, import_vitest9.expect)(
-          store.commit(s, [inc(1)], make_meta({ stream: s }), 0)
+          store.commit(
+            [{ stream: s, msgs: [inc(1)], expectedVersion: 0 }],
+            make_meta({ stream: s })
+          )
         ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
       });
       (0, import_vitest9.it)("treats expectedVersion -1 as an empty stream", async () => {
         const s = `commit-new-cc-${uid()}`;
         const [first] = await store.commit(
-          s,
-          [inc(1)],
-          make_meta({ stream: s }),
-          -1
-        );
-        (0, import_vitest9.expect)(first.version).toBe(0);
-        await (0, import_vitest9.expect)(
-          store.commit(s, [inc(1)], make_meta({ stream: s }), -1)
-        ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
-      });
-      (0, import_vitest9.it)("checks expectedVersion even when committing no events", async () => {
-        const s = `commit-empty-cc-${uid()}`;
-        await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)], expectedVersion: -1 }],
           make_meta({ stream: s })
         );
+        (0, import_vitest9.expect)(first.version).toBe(0);
         await (0, import_vitest9.expect)(
-          store.commit(s, [], make_meta({ stream: s }), 5)
+          store.commit(
+            [{ stream: s, msgs: [inc(1)], expectedVersion: -1 }],
+            make_meta({ stream: s })
+          )
         ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
-        (0, import_vitest9.expect)(
-          await store.commit(s, [], make_meta({ stream: s }), 0)
-        ).toEqual([]);
       });
       (0, import_vitest9.it)("takes concurrent commits, reads and writes on one instance", async () => {
         const x = `commit-concurrent-x-${uid()}`;
         const y = `commit-concurrent-y-${uid()}`;
         const [first, second, other, read, subscribed] = await Promise.allSettled([
           store.commit(
-            x,
-            [inc(1)],
-            make_meta({ stream: x }),
-            -1
+            [{ stream: x, msgs: [inc(1)], expectedVersion: -1 }],
+            make_meta({ stream: x })
           ),
           store.commit(
-            x,
-            [inc(2)],
-            make_meta({ stream: x }),
-            -1
+            [{ stream: x, msgs: [inc(2)], expectedVersion: -1 }],
+            make_meta({ stream: x })
+          ),
+          store.commit(
+            [{ stream: y, msgs: [inc(1)] }],
+            make_meta({ stream: y })
           ),
-          store.commit(y, [inc(1)], make_meta({ stream: y })),
           store.query(() => {
           }, { stream: x, stream_exact: true }),
           // A source nothing writes, so later claims never see it.
@@ -1347,12 +1686,14 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("preserves prior events when a concurrent commit is rejected", async () => {
         const s = `commit-cc-preserve-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(2)],
+          [{ stream: s, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: s })
         );
         await (0, import_vitest9.expect)(
-          store.commit(s, [inc(3)], make_meta({ stream: s }), 0)
+          store.commit(
+            [{ stream: s, msgs: [inc(3)], expectedVersion: 0 }],
+            make_meta({ stream: s })
+          )
         ).rejects.toBeInstanceOf(import_act2.ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
         (0, import_vitest9.expect)(found).toHaveLength(2);
@@ -1364,13 +1705,11 @@ var runStoreTck = (options) => {
         const s2 = `q-s2-${uid()}`;
         const cor = `q-cor-${uid()}`;
         await store.commit(
-          s1,
-          [inc(1), dec(1)],
+          [{ stream: s1, msgs: [inc(1), dec(1)] }],
           make_meta({ stream: s1, correlation: cor })
         );
         await store.commit(
-          s2,
-          [inc(2), dec(2), reset()],
+          [{ stream: s2, msgs: [inc(2), dec(2), reset()] }],
           make_meta({ stream: s2, correlation: cor })
         );
         const by_stream = await collect(store, {
@@ -1396,8 +1735,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("excludes snapshots when called with no query object", async () => {
         const s = `q-nofilter-${uid()}`;
         await store.commit(
-          s,
-          [{ name: import_act2.SNAP_EVENT, data: { count: 0 } }],
+          [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 0 } }] }],
           make_meta({ stream: s })
         );
         const names = [];
@@ -1409,18 +1747,15 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("with_snaps resumes from the latest snapshot per stream", async () => {
         const s = `q-snap-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(1)],
+          [{ stream: s, msgs: [inc(1), inc(1)] }],
           make_meta({ stream: s })
         );
         const [snap] = await store.commit(
-          s,
-          [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }],
+          [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(1), inc(1), inc(1)],
+          [{ stream: s, msgs: [inc(1), inc(1), inc(1)] }],
           make_meta({ stream: s })
         );
         const from_snap = await collect(store, {
@@ -1441,8 +1776,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(after_snap).toHaveLength(3);
         const s2 = `q-nosnap-${uid()}`;
         await store.commit(
-          s2,
-          [inc(1), inc(1)],
+          [{ stream: s2, msgs: [inc(1), inc(1)] }],
           make_meta({ stream: s2 })
         );
         const full = await collect(store, {
@@ -1455,18 +1789,15 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("with_snaps applies the resume floor on a backward scan too", async () => {
         const s = `q-snap-back-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(1)],
+          [{ stream: s, msgs: [inc(1), inc(1)] }],
           make_meta({ stream: s })
         );
         const [snap] = await store.commit(
-          s,
-          [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }],
+          [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(1), inc(1), inc(1)],
+          [{ stream: s, msgs: [inc(1), inc(1), inc(1)] }],
           make_meta({ stream: s })
         );
         const backward = await collect(store, {
@@ -1480,8 +1811,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(backward.every((e) => e.id >= snap.id)).toBe(true);
         const s2 = `q-nosnap-back-${uid()}`;
         await store.commit(
-          s2,
-          [inc(1), inc(1)],
+          [{ stream: s2, msgs: [inc(1), inc(1)] }],
           make_meta({ stream: s2 })
         );
         const full = await collect(store, {
@@ -1495,8 +1825,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("supports backward traversal", async () => {
         const s = `q-back-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1), inc(2), inc(3)],
+          [{ stream: s, msgs: [inc(1), inc(2), inc(3)] }],
           make_meta({ stream: s })
         );
         const forward = await collect(store, { stream: s, stream_exact: true });
@@ -1521,8 +1850,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("after/before bound the id range", async () => {
         const s = `q-bounds-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1), inc(2), inc(3), inc(4)],
+          [{ stream: s, msgs: [inc(1), inc(2), inc(3), inc(4)] }],
           make_meta({ stream: s })
         );
         const after_first = await collect(store, {
@@ -1545,8 +1873,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("names:[] matches no events", async () => {
         const s = `q-names-empty-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), dec(1)],
+          [{ stream: s, msgs: [inc(1), dec(1)] }],
           make_meta({ stream: s })
         );
         const none = await collect(store, {
@@ -1561,8 +1888,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("after:0 and before:0 are honored as id bounds", async () => {
         const s = `q-zero-bound-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(2), inc(3)],
+          [{ stream: s, msgs: [inc(1), inc(2), inc(3)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(
@@ -1593,8 +1919,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("created_after/created_before filter by timestamp", async () => {
         const s = `q-ts-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const ts = committed[0].created.getTime();
@@ -1617,8 +1942,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("created bounds exclude the event they are pinned to", async () => {
         const s = `q-ts-self-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const own = committed[0].created;
@@ -1638,8 +1962,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("backward traversal short-circuits at `after` id boundary", async () => {
         const s = `q-back-after-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1), inc(2), inc(3)],
+          [{ stream: s, msgs: [inc(1), inc(2), inc(3)] }],
           make_meta({ stream: s })
         );
         const got = await collect(store, {
@@ -1656,8 +1979,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("backward traversal short-circuits at `created_after` boundary", async () => {
         const s = `q-back-cafter-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const future = new Date(Date.now() + 6e4);
@@ -1672,8 +1994,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("backward traversal honors created_before by skipping newer events", async () => {
         const s = `q-back-ts-${uid()}`;
         const committed = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta()
         );
         const past = new Date(committed[0].created.getTime() - 6e4);
@@ -1690,13 +2011,11 @@ var runStoreTck = (options) => {
         const a = `q-exact-${tag}`;
         const b = `q-exact-${tag}-extra`;
         await store.commit(
-          a,
-          [inc(1)],
+          [{ stream: a, msgs: [inc(1)] }],
           make_meta({ stream: a })
         );
         await store.commit(
-          b,
-          [inc(2)],
+          [{ stream: b, msgs: [inc(2)] }],
           make_meta({ stream: b })
         );
         const exact = await collect(store, { stream: a, stream_exact: true });
@@ -1708,13 +2027,11 @@ var runStoreTck = (options) => {
         const inner = `qr-${tag}-inner`;
         const longer = `qr-${tag}-inner-extra`;
         await store.commit(
-          inner,
-          [inc(1)],
+          [{ stream: inner, msgs: [inc(1)] }],
           make_meta({ stream: inner })
         );
         await store.commit(
-          longer,
-          [inc(2)],
+          [{ stream: longer, msgs: [inc(2)] }],
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `qr-${tag}-inner` });
@@ -1725,13 +2042,11 @@ var runStoreTck = (options) => {
         const inner = `qr-${tag}-anchor`;
         const longer = `qr-${tag}-anchor-extra`;
         await store.commit(
-          inner,
-          [inc(1)],
+          [{ stream: inner, msgs: [inc(1)] }],
           make_meta({ stream: inner })
         );
         await store.commit(
-          longer,
-          [inc(2)],
+          [{ stream: longer, msgs: [inc(2)] }],
           make_meta({ stream: longer })
         );
         const got = await collect(store, { stream: `^qr-${tag}-anchor$` });
@@ -1744,18 +2059,15 @@ var runStoreTck = (options) => {
         const b = `qr-${tag}-pfx-b`;
         const other = `zz-${tag}-other`;
         await store.commit(
-          a,
-          [inc(1)],
+          [{ stream: a, msgs: [inc(1)] }],
           make_meta({ stream: a })
         );
         await store.commit(
-          b,
-          [inc(2)],
+          [{ stream: b, msgs: [inc(2)] }],
           make_meta({ stream: b })
         );
         await store.commit(
-          other,
-          [inc(3)],
+          [{ stream: other, msgs: [inc(3)] }],
           make_meta({ stream: other })
         );
         const got = await collect(store, { stream: `^qr-${tag}-pfx-` });
@@ -1766,8 +2078,7 @@ var runStoreTck = (options) => {
       const seed_streams = async (streams) => {
         for (const s of streams)
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
       };
@@ -1946,8 +2257,7 @@ var runStoreTck = (options) => {
         const src = `fresh-first-src-${uid()}`;
         await store.subscribe([{ stream: s, source: src }]);
         const [first] = await store.commit(
-          src,
-          [inc(1)],
+          [{ stream: src, msgs: [inc(1)] }],
           make_meta({ stream: src })
         );
         await store.subscribe([{ stream: s, correlated_at: first.id }]);
@@ -2136,8 +2446,7 @@ var runStoreTck = (options) => {
           const src = `ws-unmarked-src-${uid()}`;
           await store.subscribe([{ stream: s, source: src }]);
           const [event] = await store.commit(
-            src,
-            [inc(1)],
+            [{ stream: src, msgs: [inc(1)] }],
             make_meta({ stream: src })
           );
           (0, import_vitest9.expect)(await claimable(s)).toBe(false);
@@ -2169,8 +2478,7 @@ var runStoreTck = (options) => {
         const s = `claim-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const by = `worker-${uid()}`;
@@ -2193,8 +2501,7 @@ var runStoreTck = (options) => {
         const other = `claim-other-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2203,8 +2510,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
-          other,
-          [inc(2)],
+          [{ stream: other, msgs: [inc(2)] }],
           make_meta({ stream: other })
         );
         await correlate();
@@ -2217,8 +2523,7 @@ var runStoreTck = (options) => {
         const s = `claim-stolen-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1), inc(2)],
+          [{ stream: s, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2244,8 +2549,7 @@ var runStoreTck = (options) => {
         const s = `claim-dual-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1), inc(2)],
+          [{ stream: s, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2274,13 +2578,11 @@ var runStoreTck = (options) => {
           ]);
           for (const stream of highs)
             await fresh.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
           await fresh.commit(
-            low,
-            [inc(1)],
+            [{ stream: low, msgs: [inc(1)] }],
             make_meta({ stream: low })
           );
           const by = `w-${uid()}`;
@@ -2296,8 +2598,7 @@ var runStoreTck = (options) => {
             for (const l of leases) {
               await fresh.ack([{ ...l, at: l.at + 1 }]);
               await fresh.commit(
-                l.stream,
-                [inc(1)],
+                [{ stream: l.stream, msgs: [inc(1)] }],
                 make_meta({ stream: l.stream })
               );
             }
@@ -2311,8 +2612,7 @@ var runStoreTck = (options) => {
         const s = `claim-dedup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2325,13 +2625,11 @@ var runStoreTck = (options) => {
         const sibling = `ack-sibling-${uid()}`;
         await store.subscribe([{ stream: s }, { stream: sibling }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          sibling,
-          [inc(2)],
+          [{ stream: sibling, msgs: [inc(2)] }],
           make_meta({ stream: sibling })
         );
         await correlate();
@@ -2381,8 +2679,7 @@ var runStoreTck = (options) => {
           const s = `lease-retry-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           await fresh.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           await correlate(fresh);
@@ -2407,8 +2704,7 @@ var runStoreTck = (options) => {
           const s = `lease-zero-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           const [committed] = await fresh.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           await correlate(fresh);
@@ -2437,8 +2733,7 @@ var runStoreTck = (options) => {
           const s = `lease-lag-${uid()}`;
           await fresh.subscribe([{ stream: s }]);
           await fresh.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           await correlate(fresh);
@@ -2567,8 +2862,7 @@ var runStoreTck = (options) => {
           await fresh.subscribe(streams.map((stream) => ({ stream })));
           for (const stream of streams) {
             await fresh.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
           }
@@ -2640,8 +2934,7 @@ var runStoreTck = (options) => {
         const s = `block-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2663,8 +2956,7 @@ var runStoreTck = (options) => {
         const s = `block-returns-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2689,8 +2981,7 @@ var runStoreTck = (options) => {
         const s = `block-wrong-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2708,8 +2999,7 @@ var runStoreTck = (options) => {
         const s = `block-twice-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2734,8 +3024,7 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: s }, { stream: ctl }]);
         for (const st of [s, ctl])
           await store.commit(
-            st,
-            [inc(1)],
+            [{ stream: st, msgs: [inc(1)] }],
             make_meta({ stream: st })
           );
         (0, import_vitest9.expect)(await store.defer([s], Date.now() + 36e5)).toBe(1);
@@ -2748,8 +3037,7 @@ var runStoreTck = (options) => {
         const s = `defer-clock-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(await store.defer([s], Date.now() + 6e4)).toBe(1);
@@ -2772,8 +3060,7 @@ var runStoreTck = (options) => {
         const s = `defer-past-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(await store.defer([s], Date.now() - 1e3)).toBe(1);
@@ -2789,8 +3076,7 @@ var runStoreTck = (options) => {
         const s = `defer-retry-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.defer([s], Date.now() + 36e5);
@@ -2812,8 +3098,7 @@ var runStoreTck = (options) => {
         const s = `defer-reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.defer([s], Date.now() + 36e5);
@@ -2828,8 +3113,7 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: deferred }, { stream: plain }]);
         for (const s of [deferred, plain])
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         const due = Date.now() + 36e5;
@@ -2851,15 +3135,13 @@ var runStoreTck = (options) => {
         await store.subscribe([{ stream: a }, { stream: b }]);
         for (const s of [a, b])
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         const ctl = `defer-filterctl-${tag}`;
         await store.subscribe([{ stream: ctl }]);
         await store.commit(
-          ctl,
-          [inc(1)],
+          [{ stream: ctl, msgs: [inc(1)] }],
           make_meta({ stream: ctl })
         );
         const n = await store.defer(
@@ -2881,8 +3163,7 @@ var runStoreTck = (options) => {
         const s = `defer-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(await store.defer([s, s], Date.now() + 36e5)).toBe(1);
@@ -2894,13 +3175,11 @@ var runStoreTck = (options) => {
         const ctl = `ackdefer-ctl-${uid()}`;
         await store.subscribe([{ stream: s }, { stream: ctl }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const [ctl_head] = await store.commit(
-          ctl,
-          [inc(1)],
+          [{ stream: ctl, msgs: [inc(1)] }],
           make_meta({ stream: ctl })
         );
         await correlate();
@@ -2914,8 +3193,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.expect)(acked.find((l) => l.stream === ctl)).toBeDefined();
         (0, import_vitest9.expect)(acked.find((l) => l.stream === s)).toBeUndefined();
         await store.commit(
-          ctl,
-          [inc(2)],
+          [{ stream: ctl, msgs: [inc(2)] }],
           make_meta({ stream: ctl })
         );
         await correlate();
@@ -2927,8 +3205,7 @@ var runStoreTck = (options) => {
         const s = `ackdefer-past-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2947,8 +3224,7 @@ var runStoreTck = (options) => {
         const s = `ackdefer-retry-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2967,13 +3243,11 @@ var runStoreTck = (options) => {
         const s = `ackadvance-${uid()}`;
         await store.subscribe([{ stream: s }]);
         const [e1] = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -2995,8 +3269,7 @@ var runStoreTck = (options) => {
         const s = `ackdefer-owner-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -3014,8 +3287,7 @@ var runStoreTck = (options) => {
         const s = `reset-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -3034,8 +3306,7 @@ var runStoreTck = (options) => {
         const s = `reset-blk-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -3057,8 +3328,7 @@ var runStoreTck = (options) => {
         const s = `reset-dup-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(await store.reset([s, s])).toBe(1);
@@ -3069,13 +3339,11 @@ var runStoreTck = (options) => {
         const s = `unblock-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(2)],
+          [{ stream: s, msgs: [inc(2)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -3108,8 +3376,7 @@ var runStoreTck = (options) => {
         const s = `unblock-noop-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(await store.unblock([s])).toBe(0);
@@ -3123,13 +3390,11 @@ var runStoreTck = (options) => {
         const s2 = `unblock-mix-b-${uid()}`;
         await store.subscribe([{ stream: s1 }, { stream: s2 }]);
         await store.commit(
-          s1,
-          [inc(1)],
+          [{ stream: s1, msgs: [inc(1)] }],
           make_meta({ stream: s1 })
         );
         await store.commit(
-          s2,
-          [inc(1)],
+          [{ stream: s2, msgs: [inc(1)] }],
           make_meta({ stream: s2 })
         );
         await correlate();
@@ -3147,18 +3412,15 @@ var runStoreTck = (options) => {
         const s3 = `other-${tag}`;
         await store.subscribe([{ stream: s1 }, { stream: s2 }, { stream: s3 }]);
         await store.commit(
-          s1,
-          [inc(1)],
+          [{ stream: s1, msgs: [inc(1)] }],
           make_meta({ stream: s1 })
         );
         await store.commit(
-          s2,
-          [inc(1)],
+          [{ stream: s2, msgs: [inc(1)] }],
           make_meta({ stream: s2 })
         );
         await store.commit(
-          s3,
-          [inc(1)],
+          [{ stream: s3, msgs: [inc(1)] }],
           make_meta({ stream: s3 })
         );
         await correlate();
@@ -3186,13 +3448,11 @@ var runStoreTck = (options) => {
         const s2 = `unblock-empty-${tag}-b`;
         await store.subscribe([{ stream: s1 }, { stream: s2 }]);
         await store.commit(
-          s1,
-          [inc(1)],
+          [{ stream: s1, msgs: [inc(1)] }],
           make_meta({ stream: s1 })
         );
         await store.commit(
-          s2,
-          [inc(1)],
+          [{ stream: s2, msgs: [inc(1)] }],
           make_meta({ stream: s2 })
         );
         await correlate();
@@ -3212,8 +3472,7 @@ var runStoreTck = (options) => {
         const s = `unblock-blocked-false-${tag}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         (0, import_vitest9.expect)(
@@ -3236,18 +3495,15 @@ var runStoreTck = (options) => {
           { stream: other }
         ]);
         await store.commit(
-          s1,
-          [inc(1)],
+          [{ stream: s1, msgs: [inc(1)] }],
           make_meta({ stream: s1 })
         );
         await store.commit(
-          s2,
-          [inc(1)],
+          [{ stream: s2, msgs: [inc(1)] }],
           make_meta({ stream: s2 })
         );
         await store.commit(
-          other,
-          [inc(1)],
+          [{ stream: other, msgs: [inc(1)] }],
           make_meta({ stream: other })
         );
         await correlate();
@@ -3278,13 +3534,11 @@ var runStoreTck = (options) => {
         const s2 = `reset-blocked-${tag}-fine`;
         await store.subscribe([{ stream: s1 }, { stream: s2 }]);
         await store.commit(
-          s1,
-          [inc(1)],
+          [{ stream: s1, msgs: [inc(1)] }],
           make_meta({ stream: s1 })
         );
         await store.commit(
-          s2,
-          [inc(1)],
+          [{ stream: s2, msgs: [inc(1)] }],
           make_meta({ stream: s2 })
         );
         await correlate();
@@ -3363,8 +3617,7 @@ var runStoreTck = (options) => {
           const ok = `pri-${tag}-ok`;
           const bad = `pri-${tag}-bad`;
           await fresh.commit(
-            src,
-            [inc(1)],
+            [{ stream: src, msgs: [inc(1)] }],
             make_meta({ stream: src })
           );
           await fresh.subscribe([
@@ -3410,8 +3663,7 @@ var runStoreTck = (options) => {
           const tag = uid();
           const src = `pri-src-${tag}`;
           await fresh.commit(
-            src,
-            [inc(1), inc(2)],
+            [{ stream: src, msgs: [inc(1), inc(2)] }],
             make_meta({ stream: src })
           );
           await fresh.subscribe([
@@ -3509,13 +3761,11 @@ var runStoreTck = (options) => {
         const sub_default = `lane-claim-def-${tag}`;
         const sub_slow = `lane-claim-slow-${tag}`;
         await store.commit(
-          src1,
-          [inc(1)],
+          [{ stream: src1, msgs: [inc(1)] }],
           make_meta({ stream: src1 })
         );
         await store.commit(
-          src2,
-          [inc(1)],
+          [{ stream: src2, msgs: [inc(1)] }],
           make_meta({ stream: src2 })
         );
         await store.subscribe([
@@ -3582,8 +3832,7 @@ var runStoreTck = (options) => {
         const a = `lane-reset-a-${tag}`;
         const b = `lane-reset-b-${tag}`;
         await store.commit(
-          src,
-          [inc(1)],
+          [{ stream: src, msgs: [inc(1)] }],
           make_meta({ stream: src })
         );
         await store.subscribe([
@@ -3612,8 +3861,7 @@ var runStoreTck = (options) => {
         const a = `lane-ub-a-${tag}`;
         const b = `lane-ub-b-${tag}`;
         await store.commit(
-          src,
-          [inc(1)],
+          [{ stream: src, msgs: [inc(1)] }],
           make_meta({ stream: src })
         );
         await store.subscribe([
@@ -3642,8 +3890,7 @@ var runStoreTck = (options) => {
         const tag = uid();
         const long = `${tag}-${"x".repeat(140)}`;
         await store.commit(
-          long,
-          [inc(1)],
+          [{ stream: long, msgs: [inc(1)] }],
           make_meta({ stream: long })
         );
         await store.subscribe([
@@ -3668,8 +3915,7 @@ var runStoreTck = (options) => {
         for (const s of [restarted, retired]) {
           await store.subscribe([{ stream: s }]);
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         }
@@ -3693,8 +3939,7 @@ var runStoreTck = (options) => {
         const lane = `inert-lane-${uid()}`;
         const s = `trunc-inert-${uid()}`;
         const [e] = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.subscribe([{ stream: s, correlated_at: e.id, lane }]);
@@ -3709,8 +3954,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("seeds a tombstone when no snapshot is provided", async () => {
         const s = `trunc-tomb-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(2)],
+          [{ stream: s, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: s })
         );
         const result = await store.truncate([{ stream: s }]);
@@ -3730,8 +3974,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("seeds a snapshot when one is provided", async () => {
         const s = `trunc-snap-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const result = await store.truncate([
@@ -3754,8 +3997,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("leaves exactly one seed when a stream is listed twice", async () => {
         const s = `trunc-dup-${uid()}`;
         await store.commit(
-          s,
-          [inc(1), inc(2)],
+          [{ stream: s, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: s })
         );
         const result = await store.truncate([
@@ -3776,13 +4018,11 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("applies windowed targets before full ones", async () => {
         const s = `trunc-mix-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(2)],
+          [{ stream: s, msgs: [inc(2)] }],
           make_meta({ stream: s })
         );
         await (0, import_act2.sleep)(5);
@@ -3819,28 +4059,23 @@ var runStoreTck = (options) => {
       (0, import_vitest9.describe)("windowed (before boundary)", () => {
         async function seed_windowed(s) {
           await store.commit(
-            s,
-            [inc(1), inc(1)],
+            [{ stream: s, msgs: [inc(1), inc(1)] }],
             make_meta({ stream: s })
           );
           const [snap_a] = await store.commit(
-            s,
-            [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }],
+            [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }] }],
             make_meta({ stream: s })
           );
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           const [snap_b] = await store.commit(
-            s,
-            [{ name: import_act2.SNAP_EVENT, data: { count: 3 } }],
+            [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 3 } }] }],
             make_meta({ stream: s })
           );
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           return { snap_a, snap_b };
@@ -3910,8 +4145,7 @@ var runStoreTck = (options) => {
         (0, import_vitest9.it)("no-ops when no snapshot qualifies \u2014 stream absent from the result, events untouched", async () => {
           const s = `trunc-win-noop-${uid()}`;
           await store.commit(
-            s,
-            [inc(1), inc(1)],
+            [{ stream: s, msgs: [inc(1), inc(1)] }],
             make_meta({ stream: s })
           );
           const none = await store.truncate([
@@ -3919,8 +4153,7 @@ var runStoreTck = (options) => {
           ]);
           (0, import_vitest9.expect)(none.has(s)).toBe(false);
           await store.commit(
-            s,
-            [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }],
+            [{ stream: s, msgs: [{ name: import_act2.SNAP_EVENT, data: { count: 2 } }] }],
             make_meta({ stream: s })
           );
           const too_early = await store.truncate([
@@ -3958,8 +4191,7 @@ var runStoreTck = (options) => {
           const f = `trunc-win-mix-f-${uid()}`;
           const { snap_b } = await seed_windowed(w);
           await store.commit(
-            f,
-            [inc(1)],
+            [{ stream: f, msgs: [inc(1)] }],
             make_meta({ stream: f })
           );
           const result = await store.truncate([
@@ -3979,8 +4211,7 @@ var runStoreTck = (options) => {
             { stream: s, before: new Date(Date.now() + 6e4) }
           ]);
           const [next] = await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
           (0, import_vitest9.expect)(next.version).toBe(6);
@@ -4118,8 +4349,7 @@ var runStoreTck = (options) => {
         const sibling = `qb-${tag}-other`;
         await store.subscribe([{ stream: s }, { stream: sibling }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await correlate();
@@ -4150,18 +4380,15 @@ var runStoreTck = (options) => {
         const sB = `qst-${tag}-b`;
         const sUnasked = `qst-${tag}-unasked`;
         await store.commit(
-          sA,
-          [inc(1), inc(2)],
+          [{ stream: sA, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: sA })
         );
         await store.commit(
-          sB,
-          [dec(5)],
+          [{ stream: sB, msgs: [dec(5)] }],
           make_meta({ stream: sB })
         );
         await store.commit(
-          sUnasked,
-          [inc(99)],
+          [{ stream: sUnasked, msgs: [inc(99)] }],
           make_meta({ stream: sUnasked })
         );
         const stats = await store.query_stats([sA, sB]);
@@ -4179,8 +4406,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("limit: 0 returns no rows", async () => {
         const s = `qst-zero-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const filter = { stream: s, stream_exact: true };
@@ -4201,8 +4427,7 @@ var runStoreTck = (options) => {
         ];
         for (const s of names)
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         const visited = [];
@@ -4225,18 +4450,15 @@ var runStoreTck = (options) => {
         const tag = uid();
         const s = `qst-tail-${tag}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(2)],
+          [{ stream: s, msgs: [inc(2)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(3)],
+          [{ stream: s, msgs: [inc(3)] }],
           make_meta({ stream: s })
         );
         const stats = await store.query_stats([s], {
@@ -4252,14 +4474,12 @@ var runStoreTck = (options) => {
         const tag = uid();
         const s = `qst-cn-${tag}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         await store.truncate([{ stream: s, snapshot: { count: 99 } }]);
         await store.commit(
-          s,
-          [inc(2), inc(3), dec(1)],
+          [{ stream: s, msgs: [inc(2), inc(3), dec(1)] }],
           make_meta({ stream: s })
         );
         const stats = await store.query_stats([s], {
@@ -4278,13 +4498,11 @@ var runStoreTck = (options) => {
         const s = `qst-excl-${tag}`;
         const sAllOut = `qst-allout-${tag}`;
         await store.commit(
-          s,
-          [inc(1), dec(2), inc(3)],
+          [{ stream: s, msgs: [inc(1), dec(2), inc(3)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          sAllOut,
-          [inc(7)],
+          [{ stream: sAllOut, msgs: [inc(7)] }],
           make_meta({ stream: sAllOut })
         );
         const all = await store.query_stats([s]);
@@ -4308,18 +4526,15 @@ var runStoreTck = (options) => {
         const tag = uid();
         const s = `qst-tt-${tag}`;
         const c1 = await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const c2 = await store.commit(
-          s,
-          [inc(2)],
+          [{ stream: s, msgs: [inc(2)] }],
           make_meta({ stream: s })
         );
         await store.commit(
-          s,
-          [inc(3)],
+          [{ stream: s, msgs: [inc(3)] }],
           make_meta({ stream: s })
         );
         const before = c2[0].id;
@@ -4343,18 +4558,15 @@ var runStoreTck = (options) => {
         const sB = `qsf-${tag}-orders-2`;
         const sOther = `qsf-${tag}-users-1`;
         await store.commit(
-          sA,
-          [inc(1)],
+          [{ stream: sA, msgs: [inc(1)] }],
           make_meta({ stream: sA })
         );
         await store.commit(
-          sB,
-          [inc(2)],
+          [{ stream: sB, msgs: [inc(2)] }],
           make_meta({ stream: sB })
         );
         await store.commit(
-          sOther,
-          [inc(3)],
+          [{ stream: sOther, msgs: [inc(3)] }],
           make_meta({ stream: sOther })
         );
         const orders = await store.query_stats({
@@ -4377,13 +4589,11 @@ var runStoreTck = (options) => {
         const b = `qsc-${tag}-b`;
         await store.subscribe([{ stream: a }, { stream: b }]);
         await store.commit(
-          a,
-          [inc(1)],
+          [{ stream: a, msgs: [inc(1)] }],
           make_meta({ stream: a })
         );
         await store.commit(
-          b,
-          [inc(2)],
+          [{ stream: b, msgs: [inc(2)] }],
           make_meta({ stream: b })
         );
         await correlate();
@@ -4408,13 +4618,11 @@ var runStoreTck = (options) => {
         const a = `qse-${tag}-a`;
         const b = `qse-${tag}-b`;
         await store.commit(
-          a,
-          [inc(1)],
+          [{ stream: a, msgs: [inc(1)] }],
           make_meta({ stream: a })
         );
         await store.commit(
-          b,
-          [dec(2)],
+          [{ stream: b, msgs: [dec(2)] }],
           make_meta({ stream: b })
         );
         const all = await store.query_stats({});
@@ -4425,8 +4633,7 @@ var runStoreTck = (options) => {
         const tag = uid();
         const s = `qsfl-${tag}`;
         await store.commit(
-          s,
-          [inc(1), inc(2), dec(3)],
+          [{ stream: s, msgs: [inc(1), inc(2), dec(3)] }],
           make_meta({ stream: s })
         );
         const c = await store.query_stats([s], {
@@ -4457,8 +4664,7 @@ var runStoreTck = (options) => {
         ];
         for (const s of streams) {
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         }
@@ -4488,8 +4694,7 @@ var runStoreTck = (options) => {
         const tag = uid();
         for (const s of [`qsc-${tag}-c`, `qsc-${tag}-a`, `qsc-${tag}-b`])
           await store.commit(
-            s,
-            [inc(1), inc(2)],
+            [{ stream: s, msgs: [inc(1), inc(2)] }],
             make_meta({ stream: s })
           );
         const pattern = { stream: `qsc-${tag}-.*` };
@@ -4638,8 +4843,7 @@ var runStoreTck = (options) => {
         const s = `head-${uid()}`;
         await store.subscribe([{ stream: s }]);
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const positions = [];
@@ -4655,7 +4859,7 @@ var runStoreTck = (options) => {
       const actor2 = { id: "reader", name: "Reader" };
       const reader = (shape) => {
         const Happened = import_zod2.z.object(shape);
-        return (0, import_act2.state)({ Reader: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({ Happened: (_, s) => ({ n: s.n + 1 }) }).on({ Do: Happened }).emit((p) => ["Happened", p]).build();
+        return (0, import_act2.state)({ Reader: import_zod2.z.object({ n: import_zod2.z.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({ Happened: (_, s) => ({ n: s.n + 1 }) }).on({ Do: Happened }).emit("Happened").build();
       };
       const over = async (S) => {
         const fresh = await options.factory();
@@ -4748,10 +4952,16 @@ var runStoreTck = (options) => {
         const t = await over(S);
         try {
           await t.fresh.commit(
-            t.stream,
-            [{ name: "Happened", data: { at: /* @__PURE__ */ new Date("2020-01-01") } }],
-            raw,
-            -1
+            [
+              {
+                stream: t.stream,
+                msgs: [
+                  { name: "Happened", data: { at: /* @__PURE__ */ new Date("2020-01-01") } }
+                ],
+                expectedVersion: -1
+              }
+            ],
+            raw
           );
           const d = await t.read();
           (0, import_vitest9.expect)(d.label).toBeUndefined();
@@ -4765,10 +4975,14 @@ var runStoreTck = (options) => {
         const t = await over(S);
         try {
           await t.fresh.commit(
-            t.stream,
-            [{ name: "Happened", data: { at: "not a date" } }],
-            raw,
-            -1
+            [
+              {
+                stream: t.stream,
+                msgs: [{ name: "Happened", data: { at: "not a date" } }],
+                expectedVersion: -1
+              }
+            ],
+            raw
           );
           (0, import_vitest9.expect)((await t.read()).at).toBe("not a date");
         } finally {
@@ -4908,6 +5122,19 @@ var runStoreTck = (options) => {
           (0, import_vitest9.expect)((await take(k, who)).correlating).toBe(true);
           await release(k, who);
         });
+        (0, import_vitest9.it)("advances the checkpoint for a caller refused the lease", async () => {
+          const k = key();
+          const holder = by();
+          (0, import_vitest9.expect)((await take(k, holder)).correlating).toBe(true);
+          const refused = await store.subscribe([], 123456, {
+            key: k,
+            by: by(),
+            millis: 1e4
+          });
+          (0, import_vitest9.expect)(refused.correlating).toBe(false);
+          (0, import_vitest9.expect)((await take(k, holder)).correlated_at).toBe(123456);
+          await release(k, holder);
+        });
         (0, import_vitest9.it)("answers undefined when no correlator is supplied", async () => {
           (0, import_vitest9.expect)(await store.subscribe([])).not.toHaveProperty("correlating");
         });
@@ -4989,7 +5216,234 @@ var runStoreTck = (options) => {
         });
       }
     );
+    (0, import_vitest9.describe)("an action across streams", () => {
+      const SeatTaken = import_zod2.z.object({ student: import_zod2.z.string() });
+      const Seats = (0, import_act2.state)({
+        Seats: import_zod2.z.object({ taken: import_zod2.z.number() }).refine((s) => s.taken <= 3, "the course is full")
+      }).init(() => ({ taken: 0 })).emits({ SeatTaken }).patch({ SeatTaken: (_, s) => ({ taken: s.taken + 1 }) }).on({ TakeSeat: SeatTaken }).emit("SeatTaken").build();
+      const Enroll = import_zod2.z.object({ course: import_zod2.z.string(), student: import_zod2.z.string() });
+      const course = (data) => `course-${data.course}`;
+      const Enrollment = (0, import_act2.state)({ Enrollment: Enroll }).init(() => ({ course: "", student: "" })).emits({ Enrolled: Enroll }).on({ Enroll }, { maxRetries: 8 }).loads(Seats, course, ["SeatTaken"]).requires([
+        {
+          description: "the course has a free seat",
+          holds: (_, __, ___, { Seats: Seats2 }) => Seats2.taken < 3
+        }
+      ]).emit((data) => [
+        ["Enrolled", data],
+        ["SeatTaken", { student: data.student }]
+      ]).on({ Overfill: Enroll }).loads(Seats, course, ["SeatTaken"]).emit((data) => [
+        ["Enrolled", data],
+        ["SeatTaken", { student: data.student }]
+      ]).build();
+      const actor2 = { id: "a", name: "a" };
+      const at = (stream) => ({ stream, actor: actor2 });
+      const over = async (run) => {
+        const fresh = await options.factory();
+        await fresh.seed();
+        const cache = new import_act2.InMemoryCache();
+        const app = (0, import_act2.act)().withState(Seats).withState(Enrollment).build({ scoped: { store: fresh, cache } });
+        const c = `c${uid()}`;
+        const events2 = async (stream) => {
+          const found = [];
+          await fresh.query((e) => found.push(e), {
+            stream,
+            stream_exact: true
+          });
+          return found;
+        };
+        try {
+          await run({
+            app,
+            fresh,
+            c,
+            events: events2,
+            seat: (student) => ({ course: c, student })
+          });
+        } finally {
+          import_vitest9.vi.restoreAllMocks();
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        }
+      };
+      (0, import_vitest9.it)("commits both streams at once and fires committed once per stream", () => over(async ({ app, c, events: events2, seat }) => {
+        const stream = `enr-${uid()}`;
+        const heard = [];
+        app.on("committed", (s) => heard.push(s));
+        const snapshots = await app.do("Enroll", at(stream), seat("s1"));
+        (0, import_vitest9.expect)(snapshots.map((s) => s.event?.name)).toEqual([
+          "Enrolled"
+        ]);
+        const [own] = await events2(stream);
+        const [other] = await events2(`course-${c}`);
+        (0, import_vitest9.expect)(own.name).toBe("Enrolled");
+        (0, import_vitest9.expect)(other.name).toBe("SeatTaken");
+        (0, import_vitest9.expect)(other.id).toBeGreaterThan(own.id);
+        (0, import_vitest9.expect)(other.meta.correlation).toBe(own.meta.correlation);
+        (0, import_vitest9.expect)(heard.map((h) => h[0].event?.stream)).toEqual([
+          stream,
+          `course-${c}`
+        ]);
+        (0, import_vitest9.expect)((await app.load(Seats, `course-${c}`)).state.taken).toBe(1);
+      }));
+      (0, import_vitest9.it)("stores nothing on either stream when a rule or a schema refuses", () => over(async ({ app, c, events: events2, seat }) => {
+        for (const i of [1, 2, 3])
+          await app.do("TakeSeat", at(`course-${c}`), { student: `s${i}` });
+        const [a, b] = [`enr-${uid()}`, `enr-${uid()}`];
+        await (0, import_vitest9.expect)(app.do("Enroll", at(a), seat("late"))).rejects.toThrow(
+          import_act2.PreconditionError
+        );
+        await (0, import_vitest9.expect)(app.do("Overfill", at(b), seat("late"))).rejects.toThrow(
+          import_act2.ValidationError
+        );
+        (0, import_vitest9.expect)(await events2(a)).toEqual([]);
+        (0, import_vitest9.expect)(await events2(b)).toEqual([]);
+        (0, import_vitest9.expect)(await events2(`course-${c}`)).toHaveLength(3);
+      }));
+      (0, import_vitest9.it)("a rival on the loaded stream refuses the whole commit, naming that stream", () => over(async ({ app, fresh, c, events: events2, seat }) => {
+        const commit = fresh.commit.bind(fresh);
+        import_vitest9.vi.spyOn(fresh, "commit").mockImplementationOnce(
+          async (...args) => {
+            await commit(
+              [
+                {
+                  stream: `course-${c}`,
+                  msgs: [{ name: "SeatTaken", data: { student: "rival" } }]
+                }
+              ],
+              { correlation: "rival", causation: {} }
+            );
+            return commit(...args);
+          }
+        );
+        const stream = `enr-${uid()}`;
+        const err = await app.do("Overfill", at(stream), seat("s")).catch((e) => e);
+        (0, import_vitest9.expect)(err).toBeInstanceOf(import_act2.ConcurrencyError);
+        (0, import_vitest9.expect)(err.stream).toBe(`course-${c}`);
+        (0, import_vitest9.expect)(await events2(stream)).toEqual([]);
+        (0, import_vitest9.expect)(await events2(`course-${c}`)).toHaveLength(1);
+      }));
+      (0, import_vitest9.it)("racing enrollments fill the seats exactly: the rest are refused by the rule", () => over(async ({ app, c, events: events2, seat }) => {
+        const results = await Promise.allSettled(
+          [1, 2, 3, 4, 5, 6].map(
+            (i) => app.do("Enroll", at(`race-${uid()}-${i}`), seat(`s${i}`))
+          )
+        );
+        (0, import_vitest9.expect)(results.filter((r) => r.status === "fulfilled")).toHaveLength(
+          3
+        );
+        for (const r of results.filter((r2) => r2.status === "rejected"))
+          (0, import_vitest9.expect)(r.reason).toBeInstanceOf(
+            import_act2.PreconditionError
+          );
+        (0, import_vitest9.expect)(await events2(`course-${c}`)).toHaveLength(3);
+      }));
+    });
     import_vitest9.describe.skipIf(!caps.restore)("restore (capability)", () => {
+      (0, import_vitest9.describe)("what a restore must not get wrong", () => {
+        const edge_uid = () => uid();
+        const E = (data = { a: 1 }, pii) => ({
+          name: "E",
+          data,
+          ...pii ? { pii } : {}
+        });
+        const edge_meta = (correlation = "m") => ({ correlation, causation: {} });
+        const rows = async (query) => {
+          const found = [];
+          await store.query((e) => found.push(e), query);
+          return found;
+        };
+        const one = (stream) => ({ stream, stream_exact: true });
+        (0, import_vitest9.it)("a commit after restore continues each stream from its restored head", async () => {
+          const a = `a-${edge_uid()}`;
+          await store.commit(
+            [{ stream: a, msgs: [E(), E()] }],
+            edge_meta()
+          );
+          const log = await rows({ with_snaps: true });
+          await store.restore(async (cb) => {
+            for (const e of log) await cb(e);
+          });
+          const [c] = await store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 1 }],
+            edge_meta()
+          );
+          (0, import_vitest9.expect)(c.version).toBe(2);
+        });
+        (0, import_vitest9.it)("restore renumbers: ids are dense whatever the source ids were", async () => {
+          const a = `a-${edge_uid()}`;
+          const ev = (version, id) => ({
+            id,
+            stream: a,
+            version,
+            name: "E",
+            data: {},
+            meta: edge_meta(),
+            created: /* @__PURE__ */ new Date()
+          });
+          const ids = [];
+          await store.restore(async (cb) => {
+            ids.push(await cb(ev(0, 500)));
+            ids.push(await cb(ev(1, 900)));
+          });
+          (0, import_vitest9.expect)(ids[1]).toBe(ids[0] + 1);
+          (0, import_vitest9.expect)(ids[0]).toBeLessThanOrEqual(1);
+        });
+        (0, import_vitest9.it)("changes nothing when it fails", async () => {
+          const a = `rb-${edge_uid()}`;
+          const key = `k-${edge_uid()}`;
+          const sub = `sub-${edge_uid()}`;
+          const committed = await store.commit(
+            [{ stream: a, msgs: [E({}, { email: "x" }), E()] }],
+            edge_meta()
+          );
+          const head = committed.at(-1).id;
+          await store.subscribe([{ stream: sub }], head);
+          const keyed = await store.subscribe([], head, {
+            key,
+            by: "w",
+            millis: 1
+          });
+          const shared = await store.subscribe([]);
+          await (0, import_vitest9.expect)(
+            store.restore(async (callback) => {
+              await callback({
+                id: 1,
+                stream: "other",
+                version: 0,
+                name: "E",
+                data: {},
+                meta: edge_meta(),
+                created: /* @__PURE__ */ new Date()
+              });
+              throw new Error("mid-restore");
+            })
+          ).rejects.toThrow();
+          const subscriptions = [];
+          await store.query_streams((p) => subscriptions.push(p.stream), {
+            stream: sub,
+            stream_exact: true
+          });
+          (0, import_vitest9.expect)(subscriptions).toEqual([sub]);
+          (0, import_vitest9.expect)((await store.subscribe([])).correlated_at).toBe(
+            shared.correlated_at
+          );
+          await (0, import_act2.sleep)(5);
+          const keyed_after = await store.subscribe([], void 0, {
+            key,
+            by: "w2",
+            millis: 1
+          });
+          (0, import_vitest9.expect)(keyed_after.correlated_at).toBe(keyed.correlated_at);
+          (0, import_vitest9.expect)((await rows(one(a)))[0].pii).toEqual({ email: "x" });
+          const [next] = await store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 1 }],
+            edge_meta()
+          );
+          (0, import_vitest9.expect)(next.version).toBe(2);
+          (0, import_vitest9.expect)(next.id).toBeGreaterThan(head);
+        });
+      });
       beforeEach(async () => {
         await store.drop();
         await store.seed();
@@ -5175,8 +5629,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("wipes pre-existing events before inserting", async () => {
         const old = `restore-old-${uid()}`;
         await store.commit(
-          old,
-          [inc(1), inc(2)],
+          [{ stream: old, msgs: [inc(1), inc(2)] }],
           make_meta({ stream: old })
         );
         const fresh = `restore-fresh-${uid()}`;
@@ -5323,8 +5776,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("rolls back atomically when the source throws mid-iteration", async () => {
         const original = `restore-pre-${uid()}`;
         const committed = await store.commit(
-          original,
-          [inc(1), inc(2), inc(3)],
+          [{ stream: original, msgs: [inc(1), inc(2), inc(3)] }],
           make_meta({ stream: original })
         );
         const explosive = {
@@ -5497,12 +5949,16 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("commits and loads pii alongside data", async () => {
         const s = `pii-roundtrip-${uid()}`;
         const committed = await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "u@example.com", name: "Ursula" }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "u@example.com", name: "Ursula" }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5525,12 +5981,16 @@ var runStoreTck = (options) => {
       });
       (0, import_vitest9.describe)("with_pii", () => {
         const seed_pii = async (s) => await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "w@example.com" }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "w@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5591,12 +6051,16 @@ var runStoreTck = (options) => {
         const s = `pii-date-${uid()}`;
         const when = /* @__PURE__ */ new Date("2024-03-01T10:20:30.000Z");
         await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1, at: when },
-              pii: { born: when }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1, at: when },
+                  pii: { born: when }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5619,17 +6083,21 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("query_stats head/tail never carry pii \u2014 introspection surface is pii-safe", async () => {
         const s = `pii-stats-${uid()}`;
         await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "head@example.com" }
-            },
-            {
-              name: "Incremented",
-              data: { amount: 2 },
-              pii: { email: "tail@example.com" }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "head@example.com" }
+                },
+                {
+                  name: "Incremented",
+                  data: { amount: 2 },
+                  pii: { email: "tail@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5653,8 +6121,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("passes through events without pii (pii is null or undefined on load)", async () => {
         const s = `pii-none-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const seen = [];
@@ -5670,17 +6137,21 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("wipes pii for every event on the stream via forget_pii", async () => {
         const s = `pii-forget-${uid()}`;
         await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "a@example.com" }
-            },
-            {
-              name: "Incremented",
-              data: { amount: 2 },
-              pii: { email: "b@example.com" }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "a@example.com" }
+                },
+                {
+                  name: "Incremented",
+                  data: { amount: 2 },
+                  pii: { email: "b@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5705,12 +6176,16 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("is idempotent \u2014 second forget_pii returns 0, no error", async () => {
         const s = `pii-forget-idem-${uid()}`;
         await store.commit(
-          s,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "u@example.com" }
+              stream: s,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "u@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: s })
@@ -5725,23 +6200,31 @@ var runStoreTck = (options) => {
         const sA = `pii-iso-a-${uid()}`;
         const sB = `pii-iso-b-${uid()}`;
         await store.commit(
-          sA,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "alice@example.com" }
+              stream: sA,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "alice@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: sA })
         );
         await store.commit(
-          sB,
           [
             {
-              name: "Incremented",
-              data: { amount: 1 },
-              pii: { email: "bob@example.com" }
+              stream: sB,
+              msgs: [
+                {
+                  name: "Incremented",
+                  data: { amount: 1 },
+                  pii: { email: "bob@example.com" }
+                }
+              ]
             }
           ],
           make_meta({ stream: sB })
@@ -5767,8 +6250,7 @@ var runStoreTck = (options) => {
       (0, import_vitest9.it)("forget_pii on a stream with no pii events returns 0", async () => {
         const s = `pii-forget-empty-${uid()}`;
         await store.commit(
-          s,
-          [inc(1)],
+          [{ stream: s, msgs: [inc(1)] }],
           make_meta({ stream: s })
         );
         const wiped = await store.forget_pii.call(store, s);
@@ -5793,8 +6275,7 @@ var runStoreTck = (options) => {
           try {
             const stream = `notify-${uid()}`;
             await writer.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
             await arrived;
@@ -5822,18 +6303,15 @@ var runStoreTck = (options) => {
           const writer = await options.factory();
           try {
             await store.commit(
-              own,
-              [inc(1)],
+              [{ stream: own, msgs: [inc(1)] }],
               make_meta({ stream: own })
             );
             await writer.commit(
-              remote,
-              [inc(1)],
+              [{ stream: remote, msgs: [inc(1)] }],
               make_meta({ stream: remote })
             );
             await writer.commit(
-              sentinel,
-              [inc(1)],
+              [{ stream: sentinel, msgs: [inc(1)] }],
               make_meta({ stream: sentinel })
             );
             await sentinel_arrived;
@@ -5845,7 +6323,7 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
-        (0, import_vitest9.it)("delivers one notification per commit transaction carrying the full event batch", async () => {
+        (0, import_vitest9.it)("delivers one notification carrying a stream's full batch from one commit", async () => {
           const received = [];
           let resolve_sentinel;
           const sentinel_arrived = new Promise((res) => {
@@ -5860,13 +6338,11 @@ var runStoreTck = (options) => {
           const writer = await options.factory();
           try {
             await writer.commit(
-              batch,
-              [inc(1), inc(2), inc(3)],
+              [{ stream: batch, msgs: [inc(1), inc(2), inc(3)] }],
               make_meta({ stream: batch })
             );
             await writer.commit(
-              sentinel,
-              [inc(1)],
+              [{ stream: sentinel, msgs: [inc(1)] }],
               make_meta({ stream: sentinel })
             );
             await sentinel_arrived;
@@ -5889,6 +6365,45 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
+        (0, import_vitest9.it)("delivers one notification per stream a commit appends to, with that stream's events", async () => {
+          const received = [];
+          let resolve_sentinel;
+          const sentinel_arrived = new Promise((res) => {
+            resolve_sentinel = res;
+          });
+          const a = `notify-across-a-${uid()}`;
+          const b = `notify-across-b-${uid()}`;
+          const sentinel = `notify-across-sentinel-${uid()}`;
+          const disposer = await store.notify.call(store, (n) => {
+            received.push(n);
+            if (n.stream === sentinel) resolve_sentinel();
+          });
+          const writer = await options.factory();
+          try {
+            const committed = await writer.commit(
+              [
+                { stream: a, msgs: [inc(1), inc(2)] },
+                { stream: b, msgs: [dec(3)] }
+              ],
+              make_meta({ stream: a })
+            );
+            await writer.commit(
+              [{ stream: sentinel, msgs: [inc(1)] }],
+              make_meta({ stream: sentinel })
+            );
+            await sentinel_arrived;
+            for (const stream of [a, b]) {
+              const of_stream = received.filter((n) => n.stream === stream);
+              (0, import_vitest9.expect)(of_stream).toHaveLength(1);
+              (0, import_vitest9.expect)(of_stream[0].events.map((e) => e.id)).toEqual(
+                committed.filter((e) => e.stream === stream).map((e) => e.id)
+              );
+            }
+          } finally {
+            await writer.dispose();
+            await Promise.resolve(disposer());
+          }
+        });
       });
     }
   });