cojson 0.19.22 → 0.20.1

package/dist/tests/StorageApiAsync.test.js

@@ -1,14 +1,8 @@
-import { randomUUID } from "node:crypto";
-import { unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, onTestFinished, test, vi } from "vitest";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { LocalNode, logger } from "../exports.js";
-import { createAsyncStorage } from "./testStorage.js";
-import { SyncMessagesLog, loadCoValueOrFail, randomAgentAndSessionID, waitFor, } from "./testUtils.js";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { logger } from "../exports.js";
+import { createAsyncStorage, getAllCoValuesWaitingForDelete, getCoValueStoredSessions, getDbPath, } from "./testStorage.js";
+import { SyncMessagesLog, fillCoMapWithLargeData, loadCoValueOrFail, setupTestNode, waitFor, } from "./testUtils.js";
 import { emptyKnownState } from "../knownState.js";
-const crypto = await WasmCrypto.create();
 /**
  * Helper function that gets new content since a known state, throwing if:
  * - The coValue is not verified
@@ -24,63 +18,34 @@ function getNewContentSince(coValue, knownState) {
     }
     return contentMessage;
 }
-async function createFixturesNode(customDbPath) {
-    const [admin, session] = randomAgentAndSessionID();
-    const node = new LocalNode(admin.agentSecret, session, crypto);
-    // Create a unique database file for each test
-    const dbPath = customDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
-    const storage = await createAsyncStorage({
-        filename: dbPath,
-        nodeName: "test",
-        storageName: "test-storage",
-    });
-    onTestFinished(() => {
-        try {
-            unlinkSync(dbPath);
-        }
-        catch { }
-    });
-    onTestFinished(async () => {
-        await node.gracefulShutdown();
-    });
-    node.setStorage(storage);
-    return {
-        fixturesNode: node,
-        dbPath,
-    };
-}
-async function createTestNode(dbPath) {
-    const [admin, session] = randomAgentAndSessionID();
-    const node = new LocalNode(admin.agentSecret, session, crypto);
-    const storage = await createAsyncStorage({
-        filename: dbPath,
-        nodeName: "test",
-        storageName: "test-storage",
-    });
-    onTestFinished(async () => {
-        await node.gracefulShutdown();
-        await storage.close();
-    });
-    return {
-        node,
-        storage,
-    };
-}
 afterEach(() => {
     SyncMessagesLog.clear();
+    vi.useRealTimers();
 });
 describe("StorageApiAsync", () => {
     describe("getKnownState", () => {
         test("should return known state for existing coValue ID", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const id = fixturesNode.createGroup().id;
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const id = fixtures.node.createGroup().id;
             const knownState = storage.getKnownState(id);
             expect(knownState).toEqual(emptyKnownState(id));
             expect(storage.getKnownState(id)).toBe(knownState); // Should return same instance
         });
         test("should return different known states for different coValue IDs", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
             const id1 = "test-id-1";
             const id2 = "test-id-2";
             const knownState1 = storage.getKnownState(id1);
@@ -90,7 +55,11 @@ describe("StorageApiAsync", () => {
     });
     describe("load", () => {
         test("should handle non-existent coValue gracefully", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
             const id = "non-existent-id";
             const callback = vi.fn();
             const done = vi.fn();
@@ -105,12 +74,23 @@ describe("StorageApiAsync", () => {
             expect(afterLoadKnownState).toEqual(initialKnownState);
         });
         test("should load coValue with header only successfully", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Create a real group and get its content message
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             await group.core.waitForSync();
             // Get initial known state
             const initialKnownState = storage.getKnownState(group.id);
@@ -125,16 +105,27 @@ describe("StorageApiAsync", () => {
             // Verify that storage known state is updated after load
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.core.verified.header).toEqual(group.core.verified.header);
         });
         test("should load coValue with sessions and transactions successfully", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Create a real group and add a member to create transactions
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Get initial known state
@@ -145,23 +136,31 @@ describe("StorageApiAsync", () => {
                 id: group.id,
                 header: group.core.verified.header,
                 new: expect.objectContaining({
-                    [fixturesNode.currentSessionID]: expect.any(Object),
+                    [fixtures.node.currentSessionID]: expect.any(Object),
                 }),
             }));
             expect(done).toHaveBeenCalledWith(true);
             // Verify that storage known state is updated after load
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
     });
     describe("store", () => {
         test("should store new coValue with header successfully", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
             // Create a real group and get its content message
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
             const correctionCallback = vi.fn();
             // Get initial known state
@@ -172,15 +171,23 @@ describe("StorageApiAsync", () => {
             // Verify that storage known state is updated after store
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.core.verified.header).toEqual(group.core.verified.header);
         });
         test("should store coValue with transactions successfully", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
             // Create a real group and add a member to create transactions
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "reader");
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
@@ -193,14 +200,22 @@ describe("StorageApiAsync", () => {
             // Verify that storage known state is updated after store
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
         test("should handle invalid assumption on header presence with correction", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "reader");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -217,14 +232,22 @@ describe("StorageApiAsync", () => {
             // Verify that storage known state is updated after store with correction
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
         test("should handle invalid assumption on new content with correction", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const group = fixtures.node.createGroup();
             const initialContent = getNewContentSince(group.core, emptyKnownState(group.id));
             const initialKnownState = group.core.knownState();
             group.addMember("everyone", "reader");
@@ -245,14 +268,22 @@ describe("StorageApiAsync", () => {
             // Verify that storage known state is updated after store with correction
             const finalKnownState = storage.getKnownState(group.id);
             expect(finalKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("writer");
         });
         test("should log an error when the correction callback returns undefined", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "writer");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -277,9 +308,17 @@ describe("StorageApiAsync", () => {
             errorSpy.mockClear();
         });
         test("should log an error when the correction callback returns an invalid content message", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "writer");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -308,17 +347,21 @@ describe("StorageApiAsync", () => {
             errorSpy.mockClear();
         });
         test("should handle invalid assumption when pushing multiple transactions with correction", async () => {
-            const { node, storage } = await createTestNode();
-            const core = node.createCoValue({
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const core = client.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...client.node.crypto.createdNowUnique(),
             });
             core.makeTransaction([{ count: 1 }], "trusting");
             await core.waitForSync();
             // Add storage later
-            node.setStorage(storage);
+            client.addStorage({ storage });
             core.makeTransaction([{ count: 2 }], "trusting");
             core.makeTransaction([{ count: 3 }], "trusting");
             await new Promise((resolve) => setTimeout(resolve, 10));
@@ -338,24 +381,28 @@ describe("StorageApiAsync", () => {
       `);
         });
         test("should handle invalid assumption when pushing multiple transactions on different coValues with correction", async () => {
-            const { node, storage } = await createTestNode();
-            const core = node.createCoValue({
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const core = client.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...client.node.crypto.createdNowUnique(),
             });
-            const core2 = node.createCoValue({
+            const core2 = client.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...client.node.crypto.createdNowUnique(),
             });
             core.makeTransaction([{ count: 1 }], "trusting");
             core2.makeTransaction([{ count: 1 }], "trusting");
             await core.waitForSync();
             // Add storage later
-            node.setStorage(storage);
+            client.addStorage({ storage });
             core.makeTransaction([{ count: 2 }], "trusting");
             core2.makeTransaction([{ count: 2 }], "trusting");
             core.makeTransaction([{ count: 3 }], "trusting");
@@ -388,24 +435,28 @@ describe("StorageApiAsync", () => {
       `);
         });
         test("should handle close while pushing multiple transactions on different coValues with an invalid assumption", async () => {
-            const { node, storage } = await createTestNode();
-            const core = node.createCoValue({
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const core = client.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...client.node.crypto.createdNowUnique(),
             });
-            const core2 = node.createCoValue({
+            const core2 = client.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...client.node.crypto.createdNowUnique(),
             });
             core.makeTransaction([{ count: 1 }], "trusting");
             core2.makeTransaction([{ count: 1 }], "trusting");
             await core.waitForSync();
             // Add storage later
-            node.setStorage(storage);
+            client.addStorage({ storage });
             core.makeTransaction([{ count: 2 }], "trusting");
             core2.makeTransaction([{ count: 2 }], "trusting");
             core.makeTransaction([{ count: 3 }], "trusting");
@@ -438,14 +489,29 @@ describe("StorageApiAsync", () => {
             expect(storage.getKnownState(core.id)).toEqual(knownState);
         });
         test("should handle multiple sessions correctly", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { fixturesNode: fixtureNode2 } = await createFixturesNode(dbPath);
-            const { node, storage } = await createTestNode();
-            const coValue = fixturesNode.createCoValue({
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const fixture2 = setupTestNode();
+            await fixture2.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const coValue = fixtures.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...fixtures.node.crypto.createdNowUnique(),
             });
             coValue.makeTransaction([
                 {
@@ -453,7 +519,7 @@ describe("StorageApiAsync", () => {
                 },
             ], "trusting");
             await coValue.waitForSync();
-            const mapOnNode2 = await loadCoValueOrFail(fixtureNode2, coValue.id);
+            const mapOnNode2 = await loadCoValueOrFail(fixture2.node, coValue.id);
             coValue.makeTransaction([
                 {
                     count: 2,
@@ -464,22 +530,215 @@ describe("StorageApiAsync", () => {
             const correctionCallback = vi.fn();
             await storage.store(contentMessage, correctionCallback);
             await storage.waitForSync(mapOnNode2.id, mapOnNode2.core);
-            node.setStorage(storage);
-            const finalMap = await loadCoValueOrFail(node, mapOnNode2.id);
+            client.addStorage({ storage });
+            const finalMap = await loadCoValueOrFail(client.node, mapOnNode2.id);
             expect(finalMap.core.knownState()).toEqual(knownState);
         });
     });
+    describe("delete flow", () => {
+        test("deleteCoValue enqueues the coValue for erasure", async () => {
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const client = setupTestNode();
+            client.addStorage({ storage });
+            const group = client.node.createGroup();
+            const map = group.createMap();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            expect(await getAllCoValuesWaitingForDelete(storage)).toContain(map.id);
+        });
+        test("background erasure doesn't run if not enabled", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = await node.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            vi.useFakeTimers();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            await vi.runAllTimersAsync();
+            expect(await getAllCoValuesWaitingForDelete(storage)).toContain(map.id);
+        });
+        test("background erasure runs if enabled", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = await node.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            vi.useFakeTimers();
+            node.node.enableDeletedCoValuesErasure();
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            await vi.runAllTimersAsync();
+            expect(await getAllCoValuesWaitingForDelete(storage)).not.toContain(map.id);
+            const sessionIDs = await getCoValueStoredSessions(storage, map.id);
+            expect(sessionIDs).toHaveLength(1);
+            expect(sessionIDs[0]).toMatch(/_session_d[1-9A-HJ-NP-Za-km-z]+\$$/); // Delete session format
+        });
+        test("eraseAllDeletedCoValues deletes history but preserves tombstone", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = await node.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            await waitFor(async () => {
+                const queued = await getAllCoValuesWaitingForDelete(storage);
+                expect(queued).toContain(map.id);
+                return true;
+            });
+            await storage.eraseAllDeletedCoValues();
+            const queued = await getAllCoValuesWaitingForDelete(storage);
+            expect(queued).not.toContain(map.id);
+            // Tombstone preserved + history erased when loaded from storage
+            const client = setupTestNode();
+            const { storage: clientStorage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const loaded = await loadCoValueOrFail(client.node, map.id);
+            expect(loaded.core.isDeleted).toBe(true);
+            expect(loaded.get("k")).toBeUndefined();
+            const sessionIDs = await getCoValueStoredSessions(clientStorage, map.id);
+            expect(sessionIDs).toHaveLength(1);
+            expect(sessionIDs[0]).toMatch(/_session_d[1-9A-HJ-NP-Za-km-z]+\$$/); // Delete session format
+        });
+        test("eraseAllDeletedCoValues does not break when called while a coValue is streaming from storage", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = await node.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            fillCoMapWithLargeData(map);
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            storage.close();
+            const newSession = node.spawnNewSession();
+            const { storage: newStorage } = await newSession.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const callback = vi.fn();
+            const loadPromise = new Promise((resolve) => {
+                newStorage.load(map.id, callback, resolve);
+            });
+            await newStorage.eraseAllDeletedCoValues();
+            expect(await loadPromise).toBe(true);
+        });
+        test("load interrupts eraseAllDeletedCoValues mid-run (resolves early, leaves some queued)", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = await node.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const group = node.node.createGroup();
+            const map1 = group.createMap();
+            map1.set("k", "v");
+            await map1.core.waitForSync();
+            const map2 = group.createMap();
+            map2.set("k", "v");
+            await map2.core.waitForSync();
+            map1.core.deleteCoValue();
+            map2.core.deleteCoValue();
+            await map1.core.waitForSync();
+            await map2.core.waitForSync();
+            await waitFor(async () => {
+                const queued = await getAllCoValuesWaitingForDelete(storage);
+                expect(queued).toEqual(expect.arrayContaining([map1.id, map2.id]));
+                return true;
+            });
+            let releaseBarrier;
+            const barrier = new Promise((resolve) => {
+                releaseBarrier = resolve;
+            });
+            let firstTxStartedResolve;
+            const firstTxStarted = new Promise((resolve) => {
+                firstTxStartedResolve = resolve;
+            });
+            // @ts-expect-error - dbClient is private
+            const dbClient = storage.dbClient;
+            const originalTransaction = dbClient.transaction.bind(dbClient);
+            let txCalls = 0;
+            const txSpy = vi
+                .spyOn(dbClient, "transaction")
+                .mockImplementation(async (callback) => {
+                txCalls += 1;
+                return originalTransaction(async (tx) => {
+                    if (txCalls === 1) {
+                        firstTxStartedResolve();
+                        await barrier;
+                    }
+                    return callback(tx);
+                });
+            });
+            const erasePromise = storage.eraseAllDeletedCoValues();
+            // Ensure the eraser is in-flight and inside its first transaction.
+            await firstTxStarted;
+            // Trigger interruption. We don't await the load immediately to avoid doing
+            // DB reads while the transaction is being held open by the barrier.
+            const loadDone = new Promise((resolve) => {
+                void storage.load("non-existent-id", () => { }, resolve);
+            });
+            releaseBarrier();
+            await erasePromise;
+            await loadDone;
+            const queuedAfter = await getAllCoValuesWaitingForDelete(storage);
+            expect(queuedAfter).toHaveLength(1);
+            txSpy.mockRestore();
+        });
+    });
     describe("dependencies", () => {
         test("should push dependencies before the coValue", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group and a map owned by that group to create dependencies
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Get initial known states
             const initialGroupKnownState = storage.getKnownState(group.id);
@@ -501,20 +760,31 @@ describe("StorageApiAsync", () => {
             const updatedMapKnownState = storage.getKnownState(map.id);
             expect(updatedGroupKnownState).toEqual(group.core.knownState());
             expect(updatedMapKnownState).toEqual(map.core.knownState());
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
         test("should handle dependencies that are already loaded correctly", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group and a map owned by that group
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Get initial known states
             const initialGroupKnownState = storage.getKnownState(group.id);
@@ -539,20 +809,31 @@ describe("StorageApiAsync", () => {
             // Verify map known state is updated after second load
             const finalMapKnownState = storage.getKnownState(map.id);
             expect(finalMapKnownState).toEqual(map.core.knownState());
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
         test("should load dependencies again if they were unmounted", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group and a map owned by that group
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Load the map (and its group)
             await storage.load(map.id, callback, done);
@@ -571,26 +852,37 @@ describe("StorageApiAsync", () => {
                 id: map.id,
             }));
             expect(done).toHaveBeenCalledWith(true);
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
     });
     describe("waitForSync", () => {
         test("should resolve when the coValue is already synced", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group and add a member
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Store the group in storage
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
             const correctionCallback = vi.fn();
             await storage.store(contentMessage, correctionCallback);
-            node.setStorage(storage);
+            client.addStorage({ storage });
             // Load the group on the new node
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             // Wait for sync should resolve immediately since the coValue is already synced
             await expect(storage.waitForSync(group.id, groupOnNode.core)).resolves.toBeUndefined();
             expect(groupOnNode.get("everyone")).toEqual("reader");
@@ -598,16 +890,30 @@ describe("StorageApiAsync", () => {
     });
     describe("close", () => {
         test("should close without throwing an error", async () => {
-            const { storage } = await createTestNode();
+            const storage = await createAsyncStorage({
+                nodeName: "test",
+                storageName: "test-storage",
+            });
             expect(() => storage.close()).not.toThrow();
         });
     });
     describe("loadKnownState", () => {
         test("should return cached knownState if available", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group to have data in the database
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // First call should hit the database and cache the result
@@ -624,17 +930,32 @@ describe("StorageApiAsync", () => {
             expect(result2).toEqual(result1);
         });
         test("should return undefined for non-existent CoValue", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+            });
             const result = await new Promise((resolve) => {
                 storage.loadKnownState("co_nonexistent", resolve);
             });
             expect(result).toBeUndefined();
         });
         test("should deduplicate concurrent requests for the same ID", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group to have data in the database
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Clear the cache to force database access
@@ -662,10 +983,21 @@ describe("StorageApiAsync", () => {
             expect(dbClientSpy).toHaveBeenCalledTimes(1);
         });
         test("should use cache and not query database when cache is populated", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            await fixtures.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
+            const client = setupTestNode();
+            const { storage } = await client.addAsyncStorage({
+                ourName: "test",
+                storageName: "test-storage",
+                filename: dbPath,
+            });
             // Create a group to have data in the database
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Spy on the database client to track calls