@earendil-works/pi-durable 1.3.0 → 1.5.0

package/dist/testing/storage-conformance.js

@@ -1,9 +1,10 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { idFromNumber } from "../ids.js";
 import { ROOT_CONVERSATION_ID, } from "../types.js";
+import { commitWrites } from "./commit-writes.js";
 const context = BACKGROUND_CONTEXT;
 async function createRoot(storage) {
-    await storage.commit([{ type: "conversation", value: { id: ROOT_CONVERSATION_ID } }], context);
+    await commitWrites(storage, [{ type: "conversation", value: { id: ROOT_CONVERSATION_ID } }], context);
     return ROOT_CONVERSATION_ID;
 }
 function pendingTask(id, conversationId, phase = "ready") {
@@ -38,8 +39,42 @@ function assertionFacade(assertions) {
         },
     });
 }
+/**
+ * `storage` with every commit checked against the receipt contract: one `receive` per stored batch, in order, with
+ * increasing seqs, all before the call settles.
+ */
+function checkReceipts(storage, assertions) {
+    const commit = async (batches, receive, commitContext) => {
+        const seqs = [];
+        let settled = false;
+        const recording = (index, seq) => {
+            assertions.ok(!settled, "Storage.commit() received a batch after it settled");
+            assertions.strictEqual(index, seqs.length);
+            if (seqs.length > 0)
+                assertions.greaterThan(seq, seqs.at(-1));
+            seqs.push(seq);
+            receive(index, seq);
+        };
+        try {
+            const result = await storage.commit(batches, recording, commitContext);
+            assertions.strictEqual(seqs.length, result.stored);
+            return result;
+        }
+        finally {
+            settled = true;
+        }
+    };
+    return new Proxy(storage, {
+        get(target, property) {
+            if (property === "commit")
+                return commit;
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}
 function createCase(options, name, test) {
-    return { name, run: () => options.withStorage(test) };
+    return { name, run: () => options.withStorage((storage) => test(checkReceipts(storage, options.assertions))) };
 }
 /** Creates runner-independent cases. `withStorage` must call and await its callback exactly once per case. */
 export function createStorageConformance(options) {
@@ -49,7 +84,30 @@ export function createStorageConformance(options) {
             expect(await storage.mintId()).toBe(2);
             await expect(createRoot(storage)).resolves.toBe(ROOT_CONVERSATION_ID);
             expect(await storage.conversation(ROOT_CONVERSATION_ID, context)).toEqual({ id: ROOT_CONVERSATION_ID });
-            await expect(storage.commit([{ type: "conversation", value: { id: ROOT_CONVERSATION_ID } }], context)).rejects.toThrow(`ID ${ROOT_CONVERSATION_ID} already belongs to conversation`);
+            await expect(commitWrites(storage, [{ type: "conversation", value: { id: ROOT_CONVERSATION_ID } }], context)).rejects.toThrow(`ID ${ROOT_CONVERSATION_ID} already belongs to conversation`);
+        }),
+        createCase(options, "receives a durable commit once before resolving, and never a refused one", async (storage) => {
+            const rootId = await createRoot(storage);
+            const events = [];
+            const entryId = await storage.mintId();
+            let read;
+            let seq;
+            const result = await storage.commit([[{ type: "entry", value: entry(entryId, rootId) }]], (_index, received) => {
+                seq = received;
+                events.push(`receive ${received}`);
+                // The batch is durable when it is received: a read started now observes it.
+                read = storage.entry(entryId, context);
+            }, context);
+            events.push(`resolve ${result.stored}`);
+            expect(events).toEqual([`receive ${seq}`, "resolve 1"]);
+            expect((await read)?.commitSeq).toBe(seq);
+            events.length = 0;
+            const refused = await storage.commit([[{ type: "conversation", value: { id: rootId } }]], (_index, received) => events.push(`receive ${received}`), context);
+            expect(refused.stored).toBe(0);
+            expect(String(refused.refused)).toBe(`Error: ID ${rootId} already belongs to conversation`);
+            expect(events).toEqual([]);
+            const next = await commitWrites(storage, [{ type: "entry", value: entry(await storage.mintId(), rootId) }], context);
+            expect(next).toBeGreaterThan(seq);
         }),
         createCase(options, "commits mixed table writes atomically and rolls all of them back on failure", async (storage) => {
             const rootId = await createRoot(storage);
@@ -65,7 +123,7 @@ export function createStorageConformance(options) {
                 status: "placed",
                 entry: entryId,
             };
-            const initialSeq = await storage.commit([
+            const initialSeq = await commitWrites(storage, [
                 { type: "entry", value: entry(entryId, rootId, "user", { data: { text: "hello" } }) },
                 { type: "task", value: task },
                 { type: "submission", value: input },
@@ -82,7 +140,7 @@ export function createStorageConformance(options) {
                 state: { status: "running", checkpoint: { phase: "effect" } },
             };
             const doneInput = { ...input, status: "done", answer: transientEntryId };
-            await expect(storage.commit([
+            await expect(commitWrites(storage, [
                 { type: "task", value: runningTask },
                 { type: "submission", value: doneInput },
                 { type: "entry", value: entry(transientEntryId, rootId, "assistant") },
@@ -91,7 +149,7 @@ export function createStorageConformance(options) {
             expect(await storage.task(taskId, context)).toEqual(task);
             expect(await storage.submission(submissionId, context)).toEqual(input);
             expect(await storage.entry(transientEntryId, context)).toBeUndefined();
-            const afterRollbackSeq = await storage.commit([{ type: "entry", value: entry(await storage.mintId(), rootId, "after-rollback") }], context);
+            const afterRollbackSeq = await commitWrites(storage, [{ type: "entry", value: entry(await storage.mintId(), rootId, "after-rollback") }], context);
             expect(afterRollbackSeq).toBeGreaterThan(initialSeq);
         }),
         createCase(options, "detaches retained writes and every returned record", async (storage) => {
@@ -115,7 +173,7 @@ export function createStorageConformance(options) {
                 reason: "failed",
                 detail,
             };
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "entry", value: storedEntry },
                 { type: "task", value: storedTask },
                 { type: "submission", value: storedInput },
@@ -148,7 +206,7 @@ export function createStorageConformance(options) {
             const rootId = await createRoot(storage);
             const entryId = await storage.mintId();
             const data = JSON.parse('{"__proto__":{"polluted":false},"constructor":{"label":"stored"},"toString":"value"}');
-            await storage.commit([{ type: "entry", value: entry(entryId, rootId, "note", { data }) }], context);
+            await commitWrites(storage, [{ type: "entry", value: entry(entryId, rootId, "note", { data }) }], context);
             Reflect.get(data, "__proto__").polluted = true;
             Reflect.get(data, "constructor").label = "mutated";
             const firstRead = (await storage.entry(entryId, context)).entry.data;
@@ -166,7 +224,7 @@ export function createStorageConformance(options) {
         }),
         createCase(options, "indexes entries committed out of ID order", async (storage) => {
             const rootId = await createRoot(storage);
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "entry", value: entry(idFromNumber(30), rootId) },
                 { type: "entry", value: entry(idFromNumber(10), rootId) },
                 {
@@ -184,7 +242,7 @@ export function createStorageConformance(options) {
             const oldestId = await storage.mintId();
             const middleId = await storage.mintId();
             const newestId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "entry", value: entry(oldestId, rootId) },
                 { type: "entry", value: entry(middleId, rootId) },
                 { type: "entry", value: entry(newestId, rootId) },
@@ -192,7 +250,7 @@ export function createStorageConformance(options) {
             const first = await storage.scanEntries({ conversationId: rootId }, 2, undefined, context);
             expect(first.items.map(({ id }) => id)).toEqual([newestId, middleId]);
             const appendedId = await storage.mintId();
-            await storage.commit([{ type: "entry", value: entry(appendedId, rootId) }], context);
+            await commitWrites(storage, [{ type: "entry", value: entry(appendedId, rootId) }], context);
             const second = await storage.scanEntries({ conversationId: rootId }, 2, first.next, context);
             expect(second.items.map(({ id }) => id)).toEqual([oldestId]);
             expect(second.next).toBeUndefined();
@@ -201,7 +259,7 @@ export function createStorageConformance(options) {
             const rootId = await createRoot(storage);
             const secondId = await storage.mintId();
             const thirdId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "conversation", value: { id: thirdId } },
                 { type: "conversation", value: { id: secondId } },
             ], context);
@@ -221,7 +279,7 @@ export function createStorageConformance(options) {
             const firstId = await storage.mintId();
             const secondId = await storage.mintId();
             const thirdId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "conversation", value: { id: otherOwnerId } },
                 {
                     type: "conversation",
@@ -250,7 +308,7 @@ export function createStorageConformance(options) {
             const rootFirst = await storage.mintId();
             const rootForkPoint = await storage.mintId();
             const rootExcludedSameCommit = await storage.mintId();
-            const rootEntriesSeq = await storage.commit([
+            const rootEntriesSeq = await commitWrites(storage, [
                 { type: "entry", value: entry(rootFirst, rootId) },
                 {
                     type: "entry",
@@ -259,7 +317,7 @@ export function createStorageConformance(options) {
                 { type: "entry", value: entry(rootExcludedSameCommit, rootId) },
             ], context);
             const childId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "conversation",
                     value: { id: childId, parent: { conversationId: rootId, at: rootForkPoint } },
@@ -267,14 +325,14 @@ export function createStorageConformance(options) {
             ], context);
             const childForkPoint = await storage.mintId();
             const childExcluded = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "entry", value: entry(childForkPoint, childId, "note") },
                 { type: "entry", value: entry(childExcluded, childId) },
             ], context);
             const rootExcludedLater = await storage.mintId();
-            await storage.commit([{ type: "entry", value: entry(rootExcludedLater, rootId) }], context);
+            await commitWrites(storage, [{ type: "entry", value: entry(rootExcludedLater, rootId) }], context);
             const grandchildId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "conversation",
                     value: { id: grandchildId, parent: { conversationId: childId, at: childForkPoint } },
@@ -282,7 +340,7 @@ export function createStorageConformance(options) {
             ], context);
             const grandchildHead = await storage.mintId();
             const grandchildTail = await storage.mintId();
-            const grandchildEntriesSeq = await storage.commit([
+            const grandchildEntriesSeq = await commitWrites(storage, [
                 {
                     type: "entry",
                     value: entry(grandchildHead, grandchildId, "marker", { head: grandchildHead }),
@@ -290,7 +348,7 @@ export function createStorageConformance(options) {
                 { type: "entry", value: entry(grandchildTail, grandchildId) },
             ], context);
             const childExcludedLater = await storage.mintId();
-            await storage.commit([{ type: "entry", value: entry(childExcludedLater, childId) }], context);
+            await commitWrites(storage, [{ type: "entry", value: entry(childExcludedLater, childId) }], context);
             const first = await storage.scanEntries({ conversationId: grandchildId }, 2, undefined, context);
             expect(first.items.map(({ id }) => id)).toEqual([grandchildTail, grandchildHead]);
             const second = await storage.scanEntries({ conversationId: grandchildId }, 2, first.next, context);
@@ -359,7 +417,7 @@ export function createStorageConformance(options) {
                 const conversationId = await storage.mintId();
                 const taskId = await storage.mintId();
                 const submissionId = await storage.mintId();
-                await storage.commit([
+                await commitWrites(storage, [
                     { type: "conversation", value: { id: conversationId } },
                     { type: "task", value: pendingTask(taskId, rootId) },
                     {
@@ -405,7 +463,7 @@ export function createStorageConformance(options) {
             const first = { ...pendingTask(firstId, rootId), memos: { winner: "first" } };
             const second = { ...pendingTask(secondId, rootId), background: true };
             const third = { ...pendingTask(thirdId, rootId), abortRequested: true };
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "task", value: first },
                 { type: "task", value: second },
                 { type: "task", value: third },
@@ -415,7 +473,7 @@ export function createStorageConformance(options) {
                 state: { status: "running", checkpoint: { phase: "effect", attempt: 1 } },
                 abortRequested: true,
             };
-            await storage.commit([{ type: "task", value: running }], context);
+            await commitWrites(storage, [{ type: "task", value: running }], context);
             expect(await storage.task(firstId, context)).toEqual(running);
             const terminal = {
                 id: firstId,
@@ -427,7 +485,7 @@ export function createStorageConformance(options) {
                 background: false,
                 abortRequested: true,
             };
-            await storage.commit([{ type: "task", value: terminal }], context);
+            await commitWrites(storage, [{ type: "task", value: terminal }], context);
             expect(await storage.task(firstId, context)).toEqual(terminal);
             const pendingPage = await storage.scanTasks({ status: "pending" }, 1, undefined, context);
             expect(pendingPage.items.map(({ id }) => id)).toEqual([secondId]);
@@ -455,7 +513,7 @@ export function createStorageConformance(options) {
                 state: { status: "completing", outcome: { status: "failed", error: { message: "held" } } },
             };
             const writes = [owner, waiting, completing].map((value) => ({ type: "task", value }));
-            await storage.commit(writes, context);
+            await commitWrites(storage, writes, context);
             expect(await storage.task(waitingId, context)).toEqual(waiting);
             expect(await storage.task(completingId, context)).toEqual(completing);
             const scan = async (status) => (await storage.scanTasks({ status }, 10, undefined, context)).items;
@@ -466,14 +524,31 @@ export function createStorageConformance(options) {
                 ...completing,
                 state: { status: "terminal", outcome: completing.state.outcome },
             };
-            await storage.commit([{ type: "task", value: terminal }], context);
+            await commitWrites(storage, [{ type: "task", value: terminal }], context);
             expect(await scan("completing")).toEqual([]);
             expect(await scan("terminal")).toEqual([terminal]);
         }),
+        createCase(options, "stores and scans sleeping tasks by status", async (storage) => {
+            const rootId = await createRoot(storage);
+            const sleepingId = await storage.mintId();
+            const sleeping = {
+                ...pendingTask(sleepingId, rootId),
+                state: { status: "sleeping", checkpoint: { phase: "next" }, until: 61_000 },
+                memos: { kept: true },
+            };
+            await commitWrites(storage, [{ type: "task", value: sleeping }], context);
+            expect(await storage.task(sleepingId, context)).toEqual(sleeping);
+            const scan = async (status) => (await storage.scanTasks({ status }, 10, undefined, context)).items;
+            expect(await scan("sleeping")).toEqual([sleeping]);
+            const running = { ...sleeping, state: { status: "running", checkpoint: { phase: "next" } } };
+            await commitWrites(storage, [{ type: "task", value: running }], context);
+            expect(await scan("sleeping")).toEqual([]);
+            expect(await scan("running")).toEqual([running]);
+        }),
         createCase(options, "indexes request IDs per conversation and replaces complete submission records", async (storage) => {
             const rootId = await createRoot(storage);
             const secondConversationId = await storage.mintId();
-            await storage.commit([{ type: "conversation", value: { id: secondConversationId } }], context);
+            await commitWrites(storage, [{ type: "conversation", value: { id: secondConversationId } }], context);
             const firstId = await storage.mintId();
             const secondId = await storage.mintId();
             const otherConversationId = await storage.mintId();
@@ -498,7 +573,7 @@ export function createStorageConformance(options) {
                 type: "input",
                 status: "queued",
             };
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "submission", value: first },
                 { type: "submission", value: second },
                 { type: "submission", value: otherConversation },
@@ -510,7 +585,7 @@ export function createStorageConformance(options) {
                 status: "placed",
                 entry: await storage.mintId(),
             };
-            await storage.commit([{ type: "submission", value: placedSecond }], context);
+            await commitWrites(storage, [{ type: "submission", value: placedSecond }], context);
             expect(await storage.submission(secondId, context)).toEqual(placedSecond);
             expect(await storage.submissionByRequest(rootId, "other", context)).toEqual(placedSecond);
             const ids = async (query) => {
@@ -554,7 +629,7 @@ export function createStorageConformance(options) {
                 type: "write",
                 status: "queued",
             };
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "submission", value: queuedDone },
                 { type: "submission", value: queuedFailed },
             ], context);
@@ -569,7 +644,7 @@ export function createStorageConformance(options) {
                 reason: "closed",
                 detail: { retryable: false },
             };
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "submission", value: done },
                 { type: "submission", value: unanswered },
             ], context);
@@ -578,6 +653,44 @@ export function createStorageConformance(options) {
             expect(await storage.submission(failedId, context)).toEqual(unanswered);
             expect(await storage.submissionByRequest(rootId, "passive-failed", context)).toEqual(unanswered);
         }),
+        createCase(options, "stores continue submissions, which have no entry and are never queued", async (storage) => {
+            const rootId = await createRoot(storage);
+            const doneId = await storage.mintId();
+            const failedId = await storage.mintId();
+            const placedDone = {
+                id: doneId,
+                conversationId: rootId,
+                requestId: "continue-done",
+                type: "continue",
+                status: "placed",
+            };
+            const placedFailed = {
+                id: failedId,
+                conversationId: rootId,
+                requestId: "continue-failed",
+                type: "continue",
+                status: "placed",
+            };
+            await commitWrites(storage, [
+                { type: "submission", value: placedDone },
+                { type: "submission", value: placedFailed },
+            ], context);
+            expect(await storage.submission(doneId, context)).toEqual(placedDone);
+            expect((await storage.scanSubmissions({ status: "placed" }, 10, undefined, context)).items).toEqual([
+                placedDone,
+                placedFailed,
+            ]);
+            const done = { ...placedDone, status: "done", answer: await storage.mintId() };
+            const unanswered = { ...placedFailed, status: "unanswered", reason: "nothing_to_answer" };
+            await commitWrites(storage, [
+                { type: "submission", value: done },
+                { type: "submission", value: unanswered },
+            ], context);
+            expect(await storage.submission(doneId, context)).toEqual(done);
+            expect(await storage.submissionByRequest(rootId, "continue-done", context)).toEqual(done);
+            expect(await storage.submission(failedId, context)).toEqual(unanswered);
+            expect(await storage.submissionByRequest(rootId, "continue-failed", context)).toEqual(unanswered);
+        }),
         createCase(options, "reconstructs rewindable documents and preserves half-open incarnations", async (storage) => {
             const rootId = await createRoot(storage);
             const firstId = await storage.mintId();
@@ -589,7 +702,7 @@ export function createStorageConformance(options) {
                 fork: "asOf",
             };
             const initial = { items: ["a"], nested: { count: 1 } };
-            const createdAt = await storage.commit([
+            const createdAt = await commitWrites(storage, [
                 {
                     type: "document.create",
                     record: firstRecord,
@@ -601,7 +714,7 @@ export function createStorageConformance(options) {
                 ["p", ["items"], 1, 0, appended],
                 ["s", ["nested", "count"], 2],
             ];
-            const changedAt = await storage.commit([{ type: "document.change", id: firstId, content: { kind: "delta", version: 1, ops } }], context);
+            const changedAt = await commitWrites(storage, [{ type: "document.change", id: firstId, content: { kind: "delta", version: 1, ops } }], context);
             initial.items.push("caller mutation");
             appended.push("caller mutation");
             expect(await storage.document(firstId, createdAt, context)).toMatchObject({
@@ -617,14 +730,14 @@ export function createStorageConformance(options) {
                 items: ["a", "b"],
                 nested: { count: 2 },
             });
-            const checkpointAt = await storage.commit([
+            const checkpointAt = await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: firstId,
                     content: { kind: "base", version: 2, value: { items: ["checkpoint"], nested: { count: 3 } } },
                 },
             ], context);
-            const replacedAt = await storage.commit([
+            const replacedAt = await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: firstId,
@@ -650,7 +763,7 @@ export function createStorageConformance(options) {
             });
             expect((await storage.document(firstId, "current", context))?.deltasSinceBase).toBe(1);
             const secondId = await storage.mintId();
-            const retiredAt = await storage.commit([
+            const retiredAt = await commitWrites(storage, [
                 {
                     type: "document.create",
                     record: { ...firstRecord, id: secondId },
@@ -688,14 +801,14 @@ export function createStorageConformance(options) {
                 revision: 0,
                 rows: Array.from({ length: 512 }, (_, value) => ({ value, stable: `row-${value}` })),
             };
-            const createdAt = await storage.commit([{ type: "document.create", record, content: { kind: "base", version: 1, value: initial } }], context);
+            const createdAt = await commitWrites(storage, [{ type: "document.create", record, content: { kind: "base", version: 1, value: initial } }], context);
             const beforeReplacement = structuredClone(initial);
             let beforeReplacementAt = createdAt;
             for (let revision = 1; revision <= 24; revision++) {
                 const index = (revision * 17) % beforeReplacement.rows.length;
                 beforeReplacement.rows[index].value = -revision;
                 beforeReplacement.revision = revision;
-                beforeReplacementAt = await storage.commit([
+                beforeReplacementAt = await commitWrites(storage, [
                     {
                         type: "document.change",
                         id,
@@ -715,7 +828,7 @@ export function createStorageConformance(options) {
                 rows: Array.from({ length: 512 }, (_, value) => ({ value: 10_000 + value, stable: `new-${value}` })),
             };
             const replacementSnapshot = structuredClone(replacement);
-            const replacementAt = await storage.commit([
+            const replacementAt = await commitWrites(storage, [
                 {
                     type: "document.change",
                     id,
@@ -728,7 +841,7 @@ export function createStorageConformance(options) {
                 const index = (revision * 19) % current.rows.length;
                 current.rows[index].value = -revision;
                 current.revision = revision;
-                await storage.commit([
+                await commitWrites(storage, [
                     {
                         type: "document.change",
                         id,
@@ -755,7 +868,7 @@ export function createStorageConformance(options) {
             const rootId = await createRoot(storage);
             const childId = await storage.mintId();
             const secondChildId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "conversation", value: { id: childId } },
                 { type: "conversation", value: { id: secondChildId } },
             ], context);
@@ -767,14 +880,14 @@ export function createStorageConformance(options) {
                 history: "rewindable",
                 fork: "asOf",
             };
-            const createdAt = await storage.commit([
+            const createdAt = await commitWrites(storage, [
                 {
                     type: "document.create",
                     record: sourceRecord,
                     content: { kind: "base", version: 2, value: { count: 1, rows: [{ value: "base" }] } },
                 },
             ], context);
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: sourceId,
@@ -798,7 +911,7 @@ export function createStorageConformance(options) {
                 history: "rewindable",
                 fork: "asOf",
             });
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.copy",
                     record: childRecord(historicalCopyId, childId),
@@ -825,7 +938,7 @@ export function createStorageConformance(options) {
                 value: { count: 2, rows: [{ value: "base" }, { value: "current" }] },
             });
             expect(await storage.document(retiredCopyId, "current", context)).toBeUndefined();
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: sourceId,
@@ -846,14 +959,14 @@ export function createStorageConformance(options) {
                 history: "latest",
                 fork: "current",
             };
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.create",
                     record: latestSource,
                     content: { kind: "base", version: 4, value: { retained: "copy" } },
                 },
             ], context);
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.copy",
                     record: {
@@ -864,7 +977,7 @@ export function createStorageConformance(options) {
                     source: { id: latestSourceId, at: "current" },
                 },
             ], context);
-            await storage.commit([
+            await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: latestSourceId,
@@ -879,7 +992,7 @@ export function createStorageConformance(options) {
             const conflictId = await storage.mintId();
             let conflictError;
             try {
-                await storage.commit([
+                await commitWrites(storage, [
                     {
                         type: "document.copy",
                         record: childRecord(conflictId, childId),
@@ -901,7 +1014,7 @@ export function createStorageConformance(options) {
             const mismatchId = await storage.mintId();
             let mismatchError;
             try {
-                await storage.commit([
+                await commitWrites(storage, [
                     {
                         type: "document.copy",
                         record: { ...childRecord(mismatchId, childId), kind: "copy.mismatch" },
@@ -923,14 +1036,14 @@ export function createStorageConformance(options) {
                 kind: "session.settings",
                 scope: { kind: "session" },
             };
-            await storage.commit([{ type: "document.create", record, content: { kind: "base", version: 1, value: { count: 1 } } }], context);
-            await storage.commit([{ type: "document.change", id, content: { kind: "delta", version: 1, ops: [["s", ["count"], 2]] } }], context);
-            const migratedAt = await storage.commit([{ type: "document.change", id, content: { kind: "base", version: 2, value: { count: 3 } } }], context);
+            await commitWrites(storage, [{ type: "document.create", record, content: { kind: "base", version: 1, value: { count: 1 } } }], context);
+            await commitWrites(storage, [{ type: "document.change", id, content: { kind: "delta", version: 1, ops: [["s", ["count"], 2]] } }], context);
+            const migratedAt = await commitWrites(storage, [{ type: "document.change", id, content: { kind: "base", version: 2, value: { count: 3 } } }], context);
             expect(await storage.document(id, "current", context)).toMatchObject({ version: 2, value: { count: 3 } });
             await expect(storage.document(id, migratedAt, context)).rejects.toThrow("does not retain historical content");
-            await expect(storage.commit([{ type: "document.change", id, content: { kind: "delta", version: 1, ops: [["s", ["count"], 4]] } }], context)).rejects.toThrow("version transition requires a base");
+            await expect(commitWrites(storage, [{ type: "document.change", id, content: { kind: "delta", version: 1, ops: [["s", ["count"], 4]] } }], context)).rejects.toThrow("version transition requires a base");
             expect((await storage.document(id, "current", context))?.value).toEqual({ count: 3 });
-            await storage.commit([{ type: "document.retire", id }], context);
+            await commitWrites(storage, [{ type: "document.retire", id }], context);
             expect(await storage.document(id, "current", context)).toBeUndefined();
         }),
         createCase(options, "indexes logical addresses and exact-scope scans independently", async (storage) => {
@@ -942,7 +1055,7 @@ export function createStorageConformance(options) {
             const taskSingletonId = await storage.mintId();
             const taskFamilyId = await storage.mintId();
             const taskOtherKindId = await storage.mintId();
-            const createdAt = await storage.commit([
+            const createdAt = await commitWrites(storage, [
                 { type: "task", value: pendingTask(taskId, rootId) },
                 {
                     type: "document.create",
@@ -1026,8 +1139,8 @@ export function createStorageConformance(options) {
                 kind: "singleton",
                 scope: { kind: "session" },
             };
-            await storage.commit([{ type: "document.create", record, content: { kind: "base", version: 1, value: { value: 1 } } }], context);
-            await expect(storage.commit([
+            await commitWrites(storage, [{ type: "document.create", record, content: { kind: "base", version: 1, value: { value: 1 } } }], context);
+            await expect(commitWrites(storage, [
                 {
                     type: "document.create",
                     record: { ...record, id: secondId },
@@ -1038,7 +1151,7 @@ export function createStorageConformance(options) {
             expect((await storage.document(firstId, "current", context))?.value).toEqual({ value: 1 });
             expect(await storage.document(secondId, "current", context)).toBeUndefined();
             const emptyId = await storage.mintId();
-            const emptyAt = await storage.commit([
+            const emptyAt = await commitWrites(storage, [
                 {
                     type: "document.create",
                     record: {
@@ -1061,6 +1174,25 @@ export function createStorageConformance(options) {
                 key: "empty",
             }, emptyAt, context)).toBeUndefined();
         }),
+        createCase(options, "refuses a creation and a change of one document in one commit, in either order", async (storage) => {
+            await createRoot(storage);
+            for (const order of ["create first", "change first"]) {
+                const id = await storage.mintId();
+                const create = {
+                    type: "document.create",
+                    record: { id, kind: "twice", key: order, scope: { kind: "session" } },
+                    content: { kind: "base", version: 1, value: { x: 1 } },
+                };
+                const change = {
+                    type: "document.change",
+                    id,
+                    content: { kind: "delta", version: 1, ops: [["s", ["x"], 2]] },
+                };
+                const writes = order === "create first" ? [create, change] : [change, create];
+                await expect(commitWrites(storage, writes, context)).rejects.toThrow("more than one content command");
+                expect(await storage.document(id, "current", context)).toBeUndefined();
+            }
+        }),
         createCase(options, "rolls back record tables and secondary indexes when a document command fails", async (storage) => {
             const rootId = await createRoot(storage);
             const taskId = await storage.mintId();
@@ -1079,14 +1211,14 @@ export function createStorageConformance(options) {
                 kind: "atomic",
                 scope: { kind: "session" },
             };
-            const baselineSeq = await storage.commit([
+            const baselineSeq = await commitWrites(storage, [
                 { type: "task", value: task },
                 { type: "submission", value: submission },
                 { type: "document.create", record, content: { kind: "base", version: 1, value: { count: 1 } } },
             ], context);
             const entryId = await storage.mintId();
             const conflictingDocumentId = await storage.mintId();
-            await expect(storage.commit([
+            await expect(commitWrites(storage, [
                 {
                     type: "task",
                     value: { ...task, state: { status: "running", checkpoint: { phase: "effect" } } },
@@ -1108,7 +1240,7 @@ export function createStorageConformance(options) {
             expect(await storage.entry(entryId, context)).toBeUndefined();
             expect(await storage.document(conflictingDocumentId, "current", context)).toBeUndefined();
             expect((await storage.findDocument({ kind: record.kind, scope: record.scope }, "current", context))?.id).toBe(documentId);
-            const afterRollbackSeq = await storage.commit([
+            const afterRollbackSeq = await commitWrites(storage, [
                 {
                     type: "document.change",
                     id: documentId,
@@ -1129,7 +1261,7 @@ export function createStorageConformance(options) {
             const secondKindDocumentId = await storage.mintId();
             const firstKeyDocumentId = await storage.mintId();
             const secondKeyDocumentId = await storage.mintId();
-            await storage.commit([
+            await commitWrites(storage, [
                 { type: "task", value: { ...pendingTask(firstTaskId, rootId), kind: first } },
                 { type: "task", value: { ...pendingTask(secondTaskId, rootId), kind: second } },
                 {
@@ -1194,18 +1326,188 @@ export function createStorageConformance(options) {
         createCase(options, "keeps one global record ID namespace and rejects exhausted ID minting", async (storage) => {
             const rootId = await createRoot(storage);
             const explicitEntryId = idFromNumber(100);
-            await storage.commit([{ type: "entry", value: entry(explicitEntryId, rootId) }], context);
+            await commitWrites(storage, [{ type: "entry", value: entry(explicitEntryId, rootId) }], context);
             expect(await storage.mintId()).toBe(101);
-            await expect(storage.commit([{ type: "task", value: pendingTask(idFromNumber(explicitEntryId), rootId) }], context)).rejects.toThrow(`ID ${explicitEntryId} already belongs to entry`);
-            await storage.commit([{ type: "entry", value: entry(idFromNumber(Number.MAX_SAFE_INTEGER), rootId, "last-id") }], context);
+            await expect(commitWrites(storage, [{ type: "task", value: pendingTask(idFromNumber(explicitEntryId), rootId) }], context)).rejects.toThrow(`ID ${explicitEntryId} already belongs to entry`);
+            await commitWrites(storage, [{ type: "entry", value: entry(idFromNumber(Number.MAX_SAFE_INTEGER), rootId, "last-id") }], context);
             await expect(storage.mintId()).rejects.toThrow("ID space is exhausted");
             await expect(storage.mintId()).rejects.toThrow("ID space is exhausted");
         }),
+        createCase(options, "commits batches in order, each with its seq, checked against the earlier ones", async (storage) => {
+            const rootId = await createRoot(storage);
+            const firstId = await storage.mintId();
+            const lastId = await storage.mintId();
+            const documentId = await storage.mintId();
+            const receipts = [];
+            let read;
+            const result = await storage.commit([
+                [
+                    { type: "entry", value: entry(firstId, rootId) },
+                    {
+                        type: "document.create",
+                        record: {
+                            id: documentId,
+                            kind: "batch.doc",
+                            scope: { kind: "conversation", conversationId: rootId },
+                            history: "latest",
+                            fork: "initial",
+                        },
+                        content: { kind: "base", version: 1, value: { count: 1 } },
+                    },
+                ],
+                // Changes the document the batch before created.
+                [
+                    {
+                        type: "document.change",
+                        id: documentId,
+                        content: { kind: "delta", version: 1, ops: [["s", ["count"], 2]] },
+                    },
+                ],
+                [{ type: "entry", value: entry(lastId, rootId) }],
+            ], (index, seq) => {
+                receipts.push([index, seq]);
+                // Receipts follow the last durable batch: a read started at the first observes it.
+                read ??= storage.entry(lastId, context);
+            }, context);
+            expect(result).toEqual({ stored: 3 });
+            expect(receipts.map(([index]) => index)).toEqual([0, 1, 2]);
+            const [[, first], [, second], [, last]] = receipts;
+            expect(second).toBeGreaterThan(first);
+            expect(last).toBeGreaterThan(second);
+            expect((await read)?.commitSeq).toBe(last);
+            expect((await storage.entry(firstId, context))?.commitSeq).toBe(first);
+            expect((await storage.document(documentId, "current", context))?.value).toEqual({ count: 2 });
+            const next = await commitWrites(storage, [{ type: "entry", value: entry(await storage.mintId(), rootId) }], context);
+            expect(next).toBeGreaterThan(last);
+        }),
+        createCase(options, "stores the batches before the first one refused, and none after it", async (storage) => {
+            const rootId = await createRoot(storage);
+            const firstId = await storage.mintId();
+            const afterId = await storage.mintId();
+            const receipts = [];
+            const result = await storage.commit([
+                [{ type: "entry", value: entry(firstId, rootId) }],
+                // Refused against the state the first batch left: the ID is taken now.
+                [
+                    { type: "task", value: pendingTask(await storage.mintId(), rootId) },
+                    { type: "entry", value: entry(firstId, rootId) },
+                ],
+                [{ type: "entry", value: entry(afterId, rootId) }],
+            ], (index) => receipts.push(index), context);
+            expect(result.stored).toBe(1);
+            expect(String(result.refused)).toBe(`Error: ID ${firstId} already belongs to entry`);
+            expect(receipts).toEqual([0]);
+            expect(await storage.entry(firstId, context)).toBeDefined();
+            expect(await storage.entry(afterId, context)).toBeUndefined();
+            expect((await storage.scanTasks({}, 10, undefined, context)).items.map((task) => task.id)).toEqual([]);
+            // A refused first batch stores nothing; the storage goes on.
+            const refused = await storage.commit([[{ type: "conversation", value: { id: rootId } }]], (index) => receipts.push(index), context);
+            expect(refused.stored).toBe(0);
+            expect(String(refused.refused)).toBe(`Error: ID ${rootId} already belongs to conversation`);
+            expect(receipts).toEqual([0]);
+            await commitWrites(storage, [{ type: "entry", value: entry(afterId, rootId) }], context);
+            expect(await storage.entry(afterId, context)).toBeDefined();
+        }),
+        createCase(options, "refuses a later batch its own malformed actions fail, keeping the batches before it", async (storage) => {
+            const rootId = await createRoot(storage);
+            const documentId = await storage.mintId();
+            await commitWrites(storage, [
+                {
+                    type: "document.create",
+                    record: { id: documentId, kind: "staged", scope: { kind: "session" } },
+                    content: { kind: "base", version: 1, value: { n: 1 } },
+                },
+            ], context);
+            const firstId = await storage.mintId();
+            const secondId = await storage.mintId();
+            const afterId = await storage.mintId();
+            const receipts = [];
+            const result = await storage.commit([
+                [{ type: "entry", value: entry(firstId, rootId) }],
+                // Malformed in itself, whatever is stored: one document retired twice.
+                [
+                    { type: "entry", value: entry(secondId, rootId) },
+                    { type: "document.retire", id: documentId },
+                    { type: "document.retire", id: documentId },
+                ],
+                [{ type: "entry", value: entry(afterId, rootId) }],
+            ], (index) => receipts.push(index), context);
+            expect(result.stored).toBe(1);
+            expect(result.refused).toBeDefined();
+            expect(receipts).toEqual([0]);
+            expect(await storage.entry(firstId, context)).toBeDefined();
+            expect(await storage.entry(secondId, context)).toBeUndefined();
+            expect(await storage.entry(afterId, context)).toBeUndefined();
+            expect((await storage.document(documentId, "current", context))?.value).toEqual({ n: 1 });
+        }),
+        createCase(options, "resolves a batched copy against the state the earlier batches left", async (storage) => {
+            const rootId = await createRoot(storage);
+            const childId = await storage.mintId();
+            const sourceId = await storage.mintId();
+            const copyId = await storage.mintId();
+            const record = (id, conversationId) => ({
+                id,
+                kind: "batch.copy",
+                scope: { kind: "conversation", conversationId },
+                history: "rewindable",
+                fork: "asOf",
+            });
+            const seqs = [];
+            const result = await storage.commit([
+                [
+                    {
+                        type: "document.create",
+                        record: record(sourceId, rootId),
+                        content: { kind: "base", version: 1, value: { count: 1 } },
+                    },
+                ],
+                [
+                    {
+                        type: "document.change",
+                        id: sourceId,
+                        content: { kind: "delta", version: 1, ops: [["s", ["count"], 2]] },
+                    },
+                ],
+                [
+                    { type: "conversation", value: { id: childId } },
+                    {
+                        type: "document.copy",
+                        record: record(copyId, childId),
+                        source: { id: sourceId, at: "current" },
+                    },
+                ],
+            ], (_index, seq) => seqs.push(seq), context);
+            expect(result).toEqual({ stored: 3 });
+            expect((await storage.document(copyId, "current", context))?.value).toEqual({ count: 2 });
+            expect((await storage.document(sourceId, seqs[0], context))?.value).toEqual({ count: 1 });
+            // A copy whose source the same batch changes is refused before the batch writes anything.
+            const laterId = await storage.mintId();
+            const laterCopyId = await storage.mintId();
+            const refused = await storage.commit([
+                [
+                    { type: "conversation", value: { id: laterId } },
+                    {
+                        type: "document.copy",
+                        record: record(laterCopyId, laterId),
+                        source: { id: sourceId, at: "current" },
+                    },
+                    {
+                        type: "document.change",
+                        id: sourceId,
+                        content: { kind: "delta", version: 1, ops: [["s", ["count"], 3]] },
+                    },
+                ],
+            ], () => { }, context);
+            expect(refused.stored).toBe(0);
+            expect(refused.refused).toBeDefined();
+            expect(await storage.conversation(laterId, context)).toBeUndefined();
+            expect((await storage.document(sourceId, "current", context))?.value).toEqual({ count: 2 });
+        }),
         createCase(options, "rejects every operation after close", async (storage) => {
             await createRoot(storage);
             await storage.close(context);
             await expect(storage.conversation(ROOT_CONVERSATION_ID, context)).rejects.toThrow("closed");
-            await expect(storage.commit([], context)).rejects.toThrow("closed");
+            await expect(commitWrites(storage, [{ type: "conversation", value: { id: ROOT_CONVERSATION_ID } }], context)).rejects.toThrow("closed");
             await expect(storage.mintId()).rejects.toThrow("closed");
         }),
     ];