@rotorsoft/act-tck 1.41.3 → 2.0.0

package/dist/index.js

@@ -28,8 +28,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);
@@ -592,14 +591,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: SNAP_EVENT, data: { count: op.count } }],
+        [
+          {
+            stream: op.stream,
+            msgs: [{ name: SNAP_EVENT, data: { count: op.count } }]
+          }
+        ],
         make_meta({ stream: op.stream, correlation: plan.correlation })
       );
     } else if (op.t === "truncate") {
@@ -608,8 +610,12 @@ var apply_plan = async (store, plan, pii_isolation) => {
       ]);
     } else if (op.t === "truncate_windowed") {
       await store.commit(
-        op.stream,
-        [{ name: SNAP_EVENT, data: { count: 1 } }],
+        [
+          {
+            stream: op.stream,
+            msgs: [{ name: SNAP_EVENT, data: { count: 1 } }]
+          }
+        ],
         make_meta({ stream: op.stream, correlation: plan.correlation })
       );
       await store.truncate([
@@ -920,8 +926,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) => {
@@ -946,8 +951,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 })
             );
           }
@@ -955,10 +959,8 @@ var runStorePropertyTck = (options) => {
           const before = await collect(store, { stream, stream_exact: true });
           await expect7(
             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 });
@@ -985,8 +987,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") {
@@ -1028,8 +1029,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 })
             );
           }
@@ -1041,8 +1041,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 })
             );
           }
@@ -1068,8 +1067,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 })
             );
           }
@@ -1079,8 +1077,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);
@@ -1098,6 +1095,8 @@ import {
   act,
   ConcurrencyError,
   InMemoryCache,
+  is_literal_source,
+  PreconditionError,
   SNAP_EVENT as SNAP_EVENT2,
   sensitive,
   sleep,
@@ -1111,7 +1110,6 @@ var runStoreTck = (options) => {
   describe8(`TCK / Store / ${options.name}`, () => {
     let store;
     const caps = { ...options.capabilities };
-    const is_literal = (source) => !/[\]^$.*+?()[{}|\\]/.test(source);
     const correlate = async (target = store) => {
       const rows = [];
       await target.query_streams(
@@ -1131,7 +1129,10 @@ var runStoreTck = (options) => {
           (e) => {
             mark = Math.max(mark, e.id);
           },
-          row.source !== void 0 ? { stream: row.source, stream_exact: is_literal(row.source) } : {}
+          row.source !== void 0 ? {
+            stream: row.source,
+            stream_exact: is_literal_source(row.source, row.stream)
+          } : {}
         );
         if (mark > row.at)
           marks.push({
@@ -1167,14 +1168,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 })
             );
             expect8(first[0].version).toBe(0);
             const second = await zero_config.commit(
-              s,
-              [inc(2)],
+              [{ stream: s, msgs: [inc(2)] }],
               make_meta({ stream: s })
             );
             expect8(second[0].version).toBe(1);
@@ -1190,12 +1189,371 @@ var runStoreTck = (options) => {
         });
       });
     }
+    describe8("commit across streams", () => {
+      const meta = make_meta({ stream: "across" });
+      const count = (stream) => store.query(() => {
+      }, { stream, stream_exact: true });
+      it7("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
+        );
+        expect8(committed.map((e) => [e.stream, e.version])).toEqual([
+          [a, 1],
+          [a, 2],
+          [b, 0]
+        ]);
+        for (let i = 1; i < committed.length; i++)
+          expect8(committed[i].id).toBeGreaterThan(committed[i - 1].id);
+        const read = [];
+        await store.query((e) => read.push(e.id), {
+          after: committed[0].id - 1
+        });
+        expect8(read.filter((id) => committed.some((e) => e.id === id))).toEqual(
+          committed.map((e) => e.id)
+        );
+      });
+      it7("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 expect8(refused).rejects.toBeInstanceOf(ConcurrencyError);
+          await expect8(refused).rejects.toMatchObject({ stream: streams[at] });
+          for (const stream of streams) expect8(await count(stream)).toBe(1);
+        }
+      });
+      it7("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 expect8(
+          store.commit(
+            [
+              { stream: a, msgs: [inc(1)] },
+              { stream: a, msgs: [inc(2)] }
+            ],
+            meta
+          )
+        ).rejects.toThrow(`stream "${a}" is named twice`);
+        await expect8(
+          store.commit(
+            [
+              { stream: a, msgs: [inc(1)] },
+              { stream: b, msgs: [] }
+            ],
+            meta
+          )
+        ).rejects.toThrow(`the append to "${b}" has no events`);
+        expect8(await count(a)).toBe(0);
+        expect8(await count(b)).toBe(0);
+      });
+      it7("commits nothing for no appends", async () => {
+        expect8(await store.commit([], meta)).toEqual([]);
+      });
+      it7("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
+        );
+        expect8(committed.map((e) => [e.stream, e.version])).toEqual([
+          [a, 0],
+          [b, 1]
+        ]);
+      });
+      it7("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]
+        ];
+        expect8(committed.filter((e) => e.stream === b).map(shape)).toEqual(
+          expected
+        );
+        const stored = [];
+        await store.query((e) => stored.push(e), {
+          stream: b,
+          stream_exact: true
+        });
+        expect8(stored.map(shape)).toEqual(expected);
+      });
+      it7.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
+          });
+          expect8(stored).toEqual([{ email: "e" }]);
+        }
+      );
+      it7("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)]);
+        expect8(rs.filter((r) => r.status === "fulfilled")).toHaveLength(1);
+        expect8(await count(x) + await count(y)).toBe(1);
+      });
+      it7("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)
+        ]);
+        expect8(
+          shared_race.filter((r2) => r2.status === "fulfilled")
+        ).toHaveLength(1);
+        const lost = shared_race.find((r2) => r2.status === "rejected");
+        expect8(lost.reason).toBeInstanceOf(
+          ConcurrencyError
+        );
+        expect8(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)]);
+        expect8(disjoint.every((d) => d.status === "fulfilled")).toBe(true);
+      });
+    });
+    describe8("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 });
+      it7("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);
+        expect8(e).toBeInstanceOf(ConcurrencyError);
+        expect8(e.stream).toBe(a);
+      });
+      it7("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 expect8(
+          store.commit(
+            [
+              { stream: a, msgs: [E()], expectedVersion: -1 },
+              { stream: b, msgs: [E()], expectedVersion: 0 }
+            ],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(ConcurrencyError);
+        expect8(await rows(one(a))).toHaveLength(0);
+      });
+      it7("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)
+          expect8((await rows(one(stream)))[0].meta.correlation).toBe(c);
+      });
+      it7("refuses a stream named twice when not adjacent", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await expect8(
+          store.commit(
+            [
+              { stream: a, msgs: [E()] },
+              { stream: b, msgs: [E()] },
+              { stream: a, msgs: [E()] }
+            ],
+            edge_meta()
+          )
+        ).rejects.toThrow("named twice");
+        expect8(await rows(one(a))).toHaveLength(0);
+      });
+      it7("refuses a lone empty append (a version check alone)", async () => {
+        const a = `a-${edge_uid()}`;
+        await expect8(
+          store.commit(
+            [{ stream: a, msgs: [], expectedVersion: -1 }],
+            edge_meta()
+          )
+        ).rejects.toThrow("no events");
+      });
+      it7("refuses an empty FIRST append", async () => {
+        const [a, b] = [`a-${edge_uid()}`, `b-${edge_uid()}`];
+        await expect8(
+          store.commit(
+            [
+              { stream: a, msgs: [] },
+              { stream: b, msgs: [E()] }
+            ],
+            edge_meta()
+          )
+        ).rejects.toThrow("no events");
+        expect8(await rows(one(b))).toHaveLength(0);
+      });
+      it7("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()
+        );
+        expect8((await rows(one(a)))[0].pii).toEqual({ email: "x" });
+      });
+      it7("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: SNAP_EVENT2, data: {} }],
+              expectedVersion: 0
+            }
+          ],
+          edge_meta()
+        );
+        await expect8(
+          store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 0 }],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(ConcurrencyError);
+      });
+      it7("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 expect8(
+          store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 0 }],
+            edge_meta()
+          )
+        ).rejects.toBeInstanceOf(ConcurrencyError);
+      });
+      it7("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()
+        );
+        expect8(c.version).toBe(1);
+      });
+      it7("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) }
+        ]);
+        expect8(r.get(a).committed.version).toBe(0);
+        const [seed] = await rows({ ...one(a), with_snaps: true });
+        expect8(seed.version).toBe(0);
+        expect8(seed.meta.correlation).toBe(c);
+      });
+    });
     describe8("commit", () => {
       it7("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 })
         );
         expect8(committed).toHaveLength(3);
@@ -1212,8 +1570,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 })
         );
         expect8(committed[0].stream).toBe(s);
@@ -1222,64 +1579,50 @@ var runStoreTck = (options) => {
       it7("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 expect8(
-          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(ConcurrencyError);
       });
       it7("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
-        );
-        expect8(first.version).toBe(0);
-        await expect8(
-          store.commit(s, [inc(1)], make_meta({ stream: s }), -1)
-        ).rejects.toBeInstanceOf(ConcurrencyError);
-      });
-      it7("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 })
         );
+        expect8(first.version).toBe(0);
         await expect8(
-          store.commit(s, [], make_meta({ stream: s }), 5)
+          store.commit(
+            [{ stream: s, msgs: [inc(1)], expectedVersion: -1 }],
+            make_meta({ stream: s })
+          )
         ).rejects.toBeInstanceOf(ConcurrencyError);
-        expect8(
-          await store.commit(s, [], make_meta({ stream: s }), 0)
-        ).toEqual([]);
       });
       it7("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.
@@ -1301,12 +1644,14 @@ var runStoreTck = (options) => {
       it7("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 expect8(
-          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(ConcurrencyError);
         const found = await collect(store, { stream: s, stream_exact: true });
         expect8(found).toHaveLength(2);
@@ -1318,13 +1663,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, {
@@ -1350,8 +1693,7 @@ var runStoreTck = (options) => {
       it7("excludes snapshots when called with no query object", async () => {
         const s = `q-nofilter-${uid()}`;
         await store.commit(
-          s,
-          [{ name: SNAP_EVENT2, data: { count: 0 } }],
+          [{ stream: s, msgs: [{ name: SNAP_EVENT2, data: { count: 0 } }] }],
           make_meta({ stream: s })
         );
         const names = [];
@@ -1363,18 +1705,15 @@ var runStoreTck = (options) => {
       it7("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: SNAP_EVENT2, data: { count: 2 } }],
+          [{ stream: s, msgs: [{ name: SNAP_EVENT2, 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, {
@@ -1395,8 +1734,7 @@ var runStoreTck = (options) => {
         expect8(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, {
@@ -1409,18 +1747,15 @@ var runStoreTck = (options) => {
       it7("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: SNAP_EVENT2, data: { count: 2 } }],
+          [{ stream: s, msgs: [{ name: SNAP_EVENT2, 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, {
@@ -1434,8 +1769,7 @@ var runStoreTck = (options) => {
         expect8(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, {
@@ -1449,8 +1783,7 @@ var runStoreTck = (options) => {
       it7("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 });
@@ -1475,8 +1808,7 @@ var runStoreTck = (options) => {
       it7("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, {
@@ -1499,8 +1831,7 @@ var runStoreTck = (options) => {
       it7("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, {
@@ -1515,8 +1846,7 @@ var runStoreTck = (options) => {
       it7("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 })
         );
         expect8(
@@ -1547,8 +1877,7 @@ var runStoreTck = (options) => {
       it7("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();
@@ -1571,8 +1900,7 @@ var runStoreTck = (options) => {
       it7("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;
@@ -1592,8 +1920,7 @@ var runStoreTck = (options) => {
       it7("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, {
@@ -1610,8 +1937,7 @@ var runStoreTck = (options) => {
       it7("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);
@@ -1626,8 +1952,7 @@ var runStoreTck = (options) => {
       it7("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);
@@ -1644,13 +1969,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 });
@@ -1662,13 +1985,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` });
@@ -1679,13 +2000,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$` });
@@ -1698,18 +2017,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-` });
@@ -1720,8 +2036,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 })
           );
       };
@@ -1885,13 +2200,22 @@ var runStoreTck = (options) => {
         const leases = await store.claim(5, 5, `w-${uid()}`, 5e3);
         expect8(leases.filter((l) => l.stream === s)).toHaveLength(0);
       });
+      it7("takes a target reading itself, whatever its name holds", async () => {
+        const name = `self-a+b(${uid()}`;
+        await store.subscribe([{ stream: name, source: name }]);
+        const found = [];
+        await store.query_streams((p) => found.push(p.stream), {
+          stream: name,
+          stream_exact: true
+        });
+        expect8(found).toEqual([name]);
+      });
       it7("claims a fresh subscription as soon as its first event is marked", async () => {
         const s = `fresh-first-${uid()}`;
         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 }]);
@@ -2080,8 +2404,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 })
           );
           expect8(await claimable(s)).toBe(false);
@@ -2113,8 +2436,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()}`;
@@ -2137,8 +2459,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();
@@ -2147,8 +2468,7 @@ var runStoreTck = (options) => {
         expect8(targetA).toBeDefined();
         await store.subscribe([{ stream: other }]);
         await store.commit(
-          other,
-          [inc(2)],
+          [{ stream: other, msgs: [inc(2)] }],
           make_meta({ stream: other })
         );
         await correlate();
@@ -2161,8 +2481,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();
@@ -2188,8 +2507,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();
@@ -2218,13 +2536,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()}`;
@@ -2240,8 +2556,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 })
               );
             }
@@ -2255,8 +2570,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();
@@ -2269,13 +2583,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();
@@ -2325,8 +2637,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);
@@ -2351,8 +2662,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);
@@ -2381,8 +2691,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);
@@ -2511,8 +2820,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 })
             );
           }
@@ -2584,8 +2892,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();
@@ -2607,8 +2914,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();
@@ -2633,8 +2939,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();
@@ -2652,8 +2957,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();
@@ -2678,8 +2982,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 })
           );
         expect8(await store.defer([s], Date.now() + 36e5)).toBe(1);
@@ -2692,8 +2995,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 })
         );
         expect8(await store.defer([s], Date.now() + 6e4)).toBe(1);
@@ -2716,8 +3018,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 })
         );
         expect8(await store.defer([s], Date.now() - 1e3)).toBe(1);
@@ -2733,8 +3034,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);
@@ -2756,8 +3056,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);
@@ -2772,8 +3071,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;
@@ -2795,15 +3093,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(
@@ -2825,8 +3121,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 })
         );
         expect8(await store.defer([s, s], Date.now() + 36e5)).toBe(1);
@@ -2838,13 +3133,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();
@@ -2858,8 +3151,7 @@ var runStoreTck = (options) => {
         expect8(acked.find((l) => l.stream === ctl)).toBeDefined();
         expect8(acked.find((l) => l.stream === s)).toBeUndefined();
         await store.commit(
-          ctl,
-          [inc(2)],
+          [{ stream: ctl, msgs: [inc(2)] }],
           make_meta({ stream: ctl })
         );
         await correlate();
@@ -2871,8 +3163,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();
@@ -2891,8 +3182,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();
@@ -2911,13 +3201,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();
@@ -2939,8 +3227,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();
@@ -2958,8 +3245,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();
@@ -2978,8 +3264,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();
@@ -3001,8 +3286,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 })
         );
         expect8(await store.reset([s, s])).toBe(1);
@@ -3013,13 +3297,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();
@@ -3052,8 +3334,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 })
         );
         expect8(await store.unblock([s])).toBe(0);
@@ -3067,13 +3348,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();
@@ -3091,18 +3370,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();
@@ -3130,13 +3406,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();
@@ -3156,8 +3430,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 })
         );
         expect8(
@@ -3180,18 +3453,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();
@@ -3222,13 +3492,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();
@@ -3307,8 +3575,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([
@@ -3354,8 +3621,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([
@@ -3453,13 +3719,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([
@@ -3526,8 +3790,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([
@@ -3556,8 +3819,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([
@@ -3586,8 +3848,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([
@@ -3612,8 +3873,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 })
           );
         }
@@ -3637,8 +3897,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 }]);
@@ -3653,8 +3912,7 @@ var runStoreTck = (options) => {
       it7("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 }]);
@@ -3674,8 +3932,7 @@ var runStoreTck = (options) => {
       it7("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([
@@ -3698,8 +3955,7 @@ var runStoreTck = (options) => {
       it7("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([
@@ -3720,13 +3976,11 @@ var runStoreTck = (options) => {
       it7("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 sleep(5);
@@ -3763,28 +4017,23 @@ var runStoreTck = (options) => {
       describe8("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: SNAP_EVENT2, data: { count: 2 } }],
+            [{ stream: s, msgs: [{ name: SNAP_EVENT2, 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: SNAP_EVENT2, data: { count: 3 } }],
+            [{ stream: s, msgs: [{ name: SNAP_EVENT2, 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 };
@@ -3854,8 +4103,7 @@ var runStoreTck = (options) => {
         it7("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([
@@ -3863,8 +4111,7 @@ var runStoreTck = (options) => {
           ]);
           expect8(none.has(s)).toBe(false);
           await store.commit(
-            s,
-            [{ name: SNAP_EVENT2, data: { count: 2 } }],
+            [{ stream: s, msgs: [{ name: SNAP_EVENT2, data: { count: 2 } }] }],
             make_meta({ stream: s })
           );
           const too_early = await store.truncate([
@@ -3902,8 +4149,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([
@@ -3923,8 +4169,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 })
           );
           expect8(next.version).toBe(6);
@@ -4062,8 +4307,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();
@@ -4094,18 +4338,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]);
@@ -4123,8 +4364,7 @@ var runStoreTck = (options) => {
       it7("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 };
@@ -4145,8 +4385,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 = [];
@@ -4169,18 +4408,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], {
@@ -4196,14 +4432,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], {
@@ -4222,13 +4456,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]);
@@ -4252,18 +4484,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;
@@ -4287,18 +4516,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({
@@ -4321,13 +4547,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();
@@ -4352,13 +4576,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({});
@@ -4369,8 +4591,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], {
@@ -4401,8 +4622,7 @@ var runStoreTck = (options) => {
         ];
         for (const s of streams) {
           await store.commit(
-            s,
-            [inc(1)],
+            [{ stream: s, msgs: [inc(1)] }],
             make_meta({ stream: s })
           );
         }
@@ -4432,8 +4652,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}-.*` };
@@ -4582,8 +4801,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 = [];
@@ -4599,7 +4817,7 @@ var runStoreTck = (options) => {
       const actor2 = { id: "reader", name: "Reader" };
       const reader = (shape) => {
         const Happened = z2.object(shape);
-        return state({ Reader: z2.object({ n: z2.number() }) }).init(() => ({ n: 0 })).emits({ Happened }).patch({ Happened: (_, s) => ({ n: s.n + 1 }) }).on({ Do: Happened }).emit((p) => ["Happened", p]).build();
+        return state({ Reader: z2.object({ n: z2.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();
@@ -4692,10 +4910,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();
           expect8(d.label).toBeUndefined();
@@ -4709,10 +4933,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
           );
           expect8((await t.read()).at).toBe("not a date");
         } finally {
@@ -4852,6 +5080,19 @@ var runStoreTck = (options) => {
           expect8((await take(k, who)).correlating).toBe(true);
           await release(k, who);
         });
+        it7("advances the checkpoint for a caller refused the lease", async () => {
+          const k = key();
+          const holder = by();
+          expect8((await take(k, holder)).correlating).toBe(true);
+          const refused = await store.subscribe([], 123456, {
+            key: k,
+            by: by(),
+            millis: 1e4
+          });
+          expect8(refused.correlating).toBe(false);
+          expect8((await take(k, holder)).correlated_at).toBe(123456);
+          await release(k, holder);
+        });
         it7("answers undefined when no correlator is supplied", async () => {
           expect8(await store.subscribe([])).not.toHaveProperty("correlating");
         });
@@ -4933,7 +5174,234 @@ var runStoreTck = (options) => {
         });
       }
     );
+    describe8("an action across streams", () => {
+      const SeatTaken = z2.object({ student: z2.string() });
+      const Seats = state({
+        Seats: z2.object({ taken: z2.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 = z2.object({ course: z2.string(), student: z2.string() });
+      const course = (data) => `course-${data.course}`;
+      const Enrollment = 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 InMemoryCache();
+        const app = 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 {
+          vi.restoreAllMocks();
+          await app.shutdown();
+          await cache.dispose();
+          await fresh.dispose();
+        }
+      };
+      it7("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"));
+        expect8(snapshots.map((s) => s.event?.name)).toEqual([
+          "Enrolled"
+        ]);
+        const [own] = await events2(stream);
+        const [other] = await events2(`course-${c}`);
+        expect8(own.name).toBe("Enrolled");
+        expect8(other.name).toBe("SeatTaken");
+        expect8(other.id).toBeGreaterThan(own.id);
+        expect8(other.meta.correlation).toBe(own.meta.correlation);
+        expect8(heard.map((h) => h[0].event?.stream)).toEqual([
+          stream,
+          `course-${c}`
+        ]);
+        expect8((await app.load(Seats, `course-${c}`)).state.taken).toBe(1);
+      }));
+      it7("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 expect8(app.do("Enroll", at(a), seat("late"))).rejects.toThrow(
+          PreconditionError
+        );
+        await expect8(app.do("Overfill", at(b), seat("late"))).rejects.toThrow(
+          ValidationError
+        );
+        expect8(await events2(a)).toEqual([]);
+        expect8(await events2(b)).toEqual([]);
+        expect8(await events2(`course-${c}`)).toHaveLength(3);
+      }));
+      it7("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);
+        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);
+        expect8(err).toBeInstanceOf(ConcurrencyError);
+        expect8(err.stream).toBe(`course-${c}`);
+        expect8(await events2(stream)).toEqual([]);
+        expect8(await events2(`course-${c}`)).toHaveLength(1);
+      }));
+      it7("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}`))
+          )
+        );
+        expect8(results.filter((r) => r.status === "fulfilled")).toHaveLength(
+          3
+        );
+        for (const r of results.filter((r2) => r2.status === "rejected"))
+          expect8(r.reason).toBeInstanceOf(
+            PreconditionError
+          );
+        expect8(await events2(`course-${c}`)).toHaveLength(3);
+      }));
+    });
     describe8.skipIf(!caps.restore)("restore (capability)", () => {
+      describe8("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 });
+        it7("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()
+          );
+          expect8(c.version).toBe(2);
+        });
+        it7("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)));
+          });
+          expect8(ids[1]).toBe(ids[0] + 1);
+          expect8(ids[0]).toBeLessThanOrEqual(1);
+        });
+        it7("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 expect8(
+            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
+          });
+          expect8(subscriptions).toEqual([sub]);
+          expect8((await store.subscribe([])).correlated_at).toBe(
+            shared.correlated_at
+          );
+          await sleep(5);
+          const keyed_after = await store.subscribe([], void 0, {
+            key,
+            by: "w2",
+            millis: 1
+          });
+          expect8(keyed_after.correlated_at).toBe(keyed.correlated_at);
+          expect8((await rows(one(a)))[0].pii).toEqual({ email: "x" });
+          const [next] = await store.commit(
+            [{ stream: a, msgs: [E()], expectedVersion: 1 }],
+            edge_meta()
+          );
+          expect8(next.version).toBe(2);
+          expect8(next.id).toBeGreaterThan(head);
+        });
+      });
       beforeEach(async () => {
         await store.drop();
         await store.seed();
@@ -5119,8 +5587,7 @@ var runStoreTck = (options) => {
       it7("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()}`;
@@ -5267,8 +5734,7 @@ var runStoreTck = (options) => {
       it7("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 = {
@@ -5441,12 +5907,16 @@ var runStoreTck = (options) => {
       it7("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 })
@@ -5469,12 +5939,16 @@ var runStoreTck = (options) => {
       });
       describe8("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 })
@@ -5535,12 +6009,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 })
@@ -5563,17 +6041,21 @@ var runStoreTck = (options) => {
       it7("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 })
@@ -5597,8 +6079,7 @@ var runStoreTck = (options) => {
       it7("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 = [];
@@ -5614,17 +6095,21 @@ var runStoreTck = (options) => {
       it7("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 })
@@ -5649,12 +6134,16 @@ var runStoreTck = (options) => {
       it7("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 })
@@ -5669,23 +6158,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 })
@@ -5711,8 +6208,7 @@ var runStoreTck = (options) => {
       it7("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);
@@ -5737,8 +6233,7 @@ var runStoreTck = (options) => {
           try {
             const stream = `notify-${uid()}`;
             await writer.commit(
-              stream,
-              [inc(1)],
+              [{ stream, msgs: [inc(1)] }],
               make_meta({ stream })
             );
             await arrived;
@@ -5766,18 +6261,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;
@@ -5789,7 +6281,7 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
-        it7("delivers one notification per commit transaction carrying the full event batch", async () => {
+        it7("delivers one notification carrying a stream's full batch from one commit", async () => {
           const received = [];
           let resolve_sentinel;
           const sentinel_arrived = new Promise((res) => {
@@ -5804,13 +6296,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;
@@ -5833,6 +6323,45 @@ var runStoreTck = (options) => {
             await Promise.resolve(disposer());
           }
         });
+        it7("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);
+              expect8(of_stream).toHaveLength(1);
+              expect8(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());
+          }
+        });
       });
     }
   });