@procedures/collections 0.55.2 → 0.57.0

package/dist/testing/storage-contract.js

@@ -6,8 +6,9 @@
  * `@procedures/sqlite`. Before, each package copied the cases of `InMemoryStorage`.
  *
  * The suite is in the test-only entry `@procedures/collections/testing`. It imports no test
- * framework: the caller gives `describe` and `it`, and the checks throw `ContractViolation`. So a
- * storage package imports the suite without a cycle, and a runtime entry never loads vitest.
+ * framework: the caller gives `describe` and `it`, and the checks throw the `AssertionError` of
+ * `node:assert`. So a storage package imports the suite without a cycle, and a runtime entry does
+ * not load vitest.
  *
  * ```ts
  * import { describe, it } from "vitest";
@@ -32,7 +33,13 @@
  * conflicts and their current items, and two writes at the same time.
  */
 import { QUERY_OPERATORS, queryEntries, versionConflictsOf, } from "@procedures/client/query";
-import { holds, rejects, same, show } from "@mark1russell7/collections/testing";
+import assert from "node:assert/strict";
+import { inspect } from "node:util";
+import { rejects } from "@mark1russell7/rigor-testkit";
+/** This function gives the text of a value for the message of a failed check, on one line. */
+function show(value) {
+    return inspect(value, { breakLength: Infinity, depth: null });
+}
 /**
  * The version of an item of the suite: `v` and the field `n`. A storage of `createWithVersions`
  * gives it as its `versionOf` (roadmap CLI-16).
@@ -247,7 +254,7 @@ export function collectionStorageContract(options) {
             ["getBatch", storage.getBatch(["a"])],
         ];
         for (const [name, result] of results)
-            holds(isPromise(result), `${name}() did not give a promise`);
+            assert.ok(isPromise(result), `${name}() did not give a promise`);
         await Promise.all(results.map(([, result]) => result));
         for (const [name, start] of [
             ["set", () => storage.set("a", item("a", 1))],
@@ -257,67 +264,67 @@ export function collectionStorageContract(options) {
             ["clear", () => storage.clear()],
         ]) {
             const result = start();
-            holds(isPromise(result), `${name}() did not give a promise`);
+            assert.ok(isPromise(result), `${name}() did not give a promise`);
             await result;
         }
     }));
     add("an empty storage has no item", () => withStorage(create, async (storage) => {
-        same(await storage.size(), 0, "size() of an empty storage");
-        same(await storage.getAll(), [], "getAll() of an empty storage");
-        same(await storage.get("a"), undefined, "get() of a missing id");
-        same(await storage.has("a"), false, "has() of a missing id");
-        same(await storage.getBatch(["a", "b"]), new Map(), "getBatch() of missing ids");
-        same(await storage.find(() => true), [], "find() in an empty storage");
-        same(await storage.delete("a"), false, "delete() of a missing id");
-        same(await storage.deleteBatch(["a", "b"]), 0, "deleteBatch() of missing ids");
+        assert.deepStrictEqual(await storage.size(), 0, "size() of an empty storage");
+        assert.deepStrictEqual(await storage.getAll(), [], "getAll() of an empty storage");
+        assert.deepStrictEqual(await storage.get("a"), undefined, "get() of a missing id");
+        assert.deepStrictEqual(await storage.has("a"), false, "has() of a missing id");
+        assert.deepStrictEqual(await storage.getBatch(["a", "b"]), new Map(), "getBatch() of missing ids");
+        assert.deepStrictEqual(await storage.find(() => true), [], "find() in an empty storage");
+        assert.deepStrictEqual(await storage.delete("a"), false, "delete() of a missing id");
+        assert.deepStrictEqual(await storage.deleteBatch(["a", "b"]), 0, "deleteBatch() of missing ids");
         if (storage.getEntries)
-            same(await storage.getEntries(), [], "getEntries() of an empty storage");
+            assert.deepStrictEqual(await storage.getEntries(), [], "getEntries() of an empty storage");
         if (storage.getIds)
-            same(await storage.getIds(), [], "getIds() of an empty storage");
+            assert.deepStrictEqual(await storage.getIds(), [], "getIds() of an empty storage");
     }));
     add("set() stores an item, and a second set() of the id replaces it", () => withStorage(create, async (storage) => {
         await storage.set("a", item("a", 1, ["x"]));
         await storage.set("b", item("b", 2));
-        same(await storage.get("a"), item("a", 1, ["x"]), "get() after set()");
-        same(await storage.has("a"), true, "has() after set()");
-        same(await storage.size(), 2, "size() after two set() calls");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 1, ["x"]), "get() after set()");
+        assert.deepStrictEqual(await storage.has("a"), true, "has() after set()");
+        assert.deepStrictEqual(await storage.size(), 2, "size() after two set() calls");
         await storage.set("a", item("a", 10));
-        same(await storage.get("a"), item("a", 10), "get() after a second set() of the id");
-        same(await storage.size(), 2, "size() after a second set() of an id");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 10), "get() after a second set() of the id");
+        assert.deepStrictEqual(await storage.size(), 2, "size() after a second set() of an id");
     }));
     add("delete() gives true for an item that existed, and deleteBatch() counts the items that existed", () => withStorage(create, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)], ["c", item("c", 3)]]);
-        same(await storage.delete("a"), true, "delete() of an item");
-        same(await storage.delete("a"), false, "a second delete() of the id");
-        same(await storage.has("a"), false, "has() after delete()");
-        same(await storage.get("a"), undefined, "get() after delete()");
-        same(await storage.deleteBatch(["b", "missing", "b"]), 1, "deleteBatch() with a missing id and a repeated id");
-        same(ids(await storage.getAll()), ["c"], "getAll() after the deletes");
+        assert.deepStrictEqual(await storage.delete("a"), true, "delete() of an item");
+        assert.deepStrictEqual(await storage.delete("a"), false, "a second delete() of the id");
+        assert.deepStrictEqual(await storage.has("a"), false, "has() after delete()");
+        assert.deepStrictEqual(await storage.get("a"), undefined, "get() after delete()");
+        assert.deepStrictEqual(await storage.deleteBatch(["b", "missing", "b"]), 1, "deleteBatch() with a missing id and a repeated id");
+        assert.deepStrictEqual(ids(await storage.getAll()), ["c"], "getAll() after the deletes");
     }));
     add("setBatch() and getBatch(): the last value of an id wins, a missing id is not in the map, and empty batches change nothing", () => withStorage(create, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)], ["a", item("a", 3)]]);
-        same(await storage.get("a"), item("a", 3), "get() of an id that setBatch() set two times");
-        same(await storage.size(), 2, "size() after setBatch() with a repeated id");
-        same(await storage.getBatch(["b", "missing", "a"]), new Map([["b", item("b", 2)], ["a", item("a", 3)]]), "getBatch() with a missing id");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 3), "get() of an id that setBatch() set two times");
+        assert.deepStrictEqual(await storage.size(), 2, "size() after setBatch() with a repeated id");
+        assert.deepStrictEqual(await storage.getBatch(["b", "missing", "a"]), new Map([["b", item("b", 2)], ["a", item("a", 3)]]), "getBatch() with a missing id");
         await storage.setBatch([]);
-        same(await storage.deleteBatch([]), 0, "deleteBatch() of no id");
-        same(await storage.getBatch([]), new Map(), "getBatch() of no id");
-        same(await storage.size(), 2, "size() after the empty batches");
+        assert.deepStrictEqual(await storage.deleteBatch([]), 0, "deleteBatch() of no id");
+        assert.deepStrictEqual(await storage.getBatch([]), new Map(), "getBatch() of no id");
+        assert.deepStrictEqual(await storage.size(), 2, "size() after the empty batches");
     }));
     add("the entries keep the order of the first set() of each id, as a Map does", () => withStorage(create, async (storage) => {
         await storage.setBatch([["c", item("c", 3)], ["a", item("a", 1)], ["b", item("b", 2)]]);
         await storage.set("a", item("a", 10));
-        same(ids(await storage.getAll()), ["c", "a", "b"], "getAll() after a second set() of an id: the id keeps its place");
+        assert.deepStrictEqual(ids(await storage.getAll()), ["c", "a", "b"], "getAll() after a second set() of an id: the id keeps its place");
         // A delete, then a set: the id goes to the end
         await storage.delete("c");
         await storage.set("c", item("c", 30));
         const expected = [["a", item("a", 10)], ["b", item("b", 2)], ["c", item("c", 30)]];
-        same(await storage.getAll(), expected.map(([, value]) => value), "getAll() after a delete and a new set() of an id");
-        same(ids(await storage.find(() => true)), ["a", "b", "c"], "find() keeps the order of the entries");
+        assert.deepStrictEqual(await storage.getAll(), expected.map(([, value]) => value), "getAll() after a delete and a new set() of an id");
+        assert.deepStrictEqual(ids(await storage.find(() => true)), ["a", "b", "c"], "find() keeps the order of the entries");
         if (storage.getEntries)
-            same(await storage.getEntries(), expected, "getEntries() keeps the order of the entries");
+            assert.deepStrictEqual(await storage.getEntries(), expected, "getEntries() keeps the order of the entries");
         if (storage.getIds)
-            same(await storage.getIds(), ["a", "b", "c"], "getIds() keeps the order of the entries");
+            assert.deepStrictEqual(await storage.getIds(), ["a", "b", "c"], "getIds() keeps the order of the entries");
     }));
     add("getIds() gives the ids of the entries in their order, as a new array", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getIds", context))
@@ -326,32 +333,32 @@ export function collectionStorageContract(options) {
         await storage.delete("a");
         await storage.set("a", item("a", 10));
         const first = await storage.getIds();
-        same(first, ["c", "b", "a"], "getIds() after a delete and a new set() of an id");
+        assert.deepStrictEqual(first, ["c", "b", "a"], "getIds() after a delete and a new set() of an id");
         first.splice(0);
-        same(await storage.getIds(), ["c", "b", "a"], "getIds() after a change of an earlier result");
+        assert.deepStrictEqual(await storage.getIds(), ["c", "b", "a"], "getIds() after a change of an earlier result");
         if (storage.getEntries)
-            same(await storage.getIds(), (await storage.getEntries()).map(([id]) => id), "getIds() and the ids of getEntries()");
+            assert.deepStrictEqual(await storage.getIds(), (await storage.getEntries()).map(([id]) => id), "getIds() and the ids of getEntries()");
         await storage.clear();
-        same(await storage.getIds(), [], "getIds() after clear()");
+        assert.deepStrictEqual(await storage.getIds(), [], "getIds() after clear()");
     }));
     add("find() gives the matching items in order, and an error of the predicate rejects the promise", () => withStorage(create, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)], ["c", item("c", 3)], ["d", item("d", 4)]]);
-        same(ids(await storage.find((value) => value.n % 2 === 0)), ["b", "d"], "find() of the even items");
-        same(await storage.find(() => false), [], "find() without a match");
+        assert.deepStrictEqual(ids(await storage.find((value) => value.n % 2 === 0)), ["b", "d"], "find() of the even items");
+        assert.deepStrictEqual(await storage.find(() => false), [], "find() without a match");
         const error = await rejects(() => storage.find(() => {
             throw new Error("the predicate failed");
         }), "find() with a predicate that throws");
-        holds(error instanceof Error && error.message.includes("the predicate failed"), `find() must reject with the error of the predicate, not ${show(error instanceof Error ? error.message : error)}`);
+        assert.ok(error instanceof Error && error.message.includes("the predicate failed"), `find() must reject with the error of the predicate, not ${show(error instanceof Error ? error.message : error)}`);
     }));
     add("clear() deletes every item, and the storage takes new items after it", () => withStorage(create, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)], ["c", item("c", 3)]]);
         await storage.clear();
-        same(await storage.size(), 0, "size() after clear()");
-        same(await storage.getAll(), [], "getAll() after clear()");
-        same(await storage.has("a"), false, "has() after clear()");
+        assert.deepStrictEqual(await storage.size(), 0, "size() after clear()");
+        assert.deepStrictEqual(await storage.getAll(), [], "getAll() after clear()");
+        assert.deepStrictEqual(await storage.has("a"), false, "has() after clear()");
         await storage.clear();
         await storage.set("d", item("d", 4));
-        same(await storage.getAll(), [item("d", 4)], "getAll() after clear() and set()");
+        assert.deepStrictEqual(await storage.getAll(), [item("d", 4)], "getAll() after clear() and set()");
     }));
     add("each result is a new array or map: a change of a result does not change the storage", () => withStorage(create, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)]]);
@@ -365,9 +372,9 @@ export function collectionStorageContract(options) {
         batch.set("z", item("z", 0));
         if (storage.getEntries)
             (await storage.getEntries()).splice(0);
-        same(ids(await storage.getAll()), ["a", "b"], "getAll() after changes of the results");
-        same(await storage.has("z"), false, "has() of an id that only a result got");
-        same(await storage.getBatch(["a"]), new Map([["a", item("a", 1)]]), "getBatch() after a change of a result");
+        assert.deepStrictEqual(ids(await storage.getAll()), ["a", "b"], "getAll() after changes of the results");
+        assert.deepStrictEqual(await storage.has("z"), false, "has() of an id that only a result got");
+        assert.deepStrictEqual(await storage.getBatch(["a"]), new Map([["a", item("a", 1)]]), "getBatch() after a change of a result");
     }));
     add("the storage keeps copies: a change of a written or a read value does not change the item", () => withStorage(create, async (storage) => {
         const value = item("a", 1, ["x"]);
@@ -378,8 +385,8 @@ export function collectionStorageContract(options) {
         await storage.setBatch([["b", batch]]);
         batch.tags.push("changed after setBatch");
         const read = (await storage.get("a"));
-        same(read, item("a", 1, ["x"]), "get() after a change of the value that set() took");
-        same(await storage.get("b"), item("b", 2, ["y"]), "get() after a change of the value that setBatch() took");
+        assert.deepStrictEqual(read, item("a", 1, ["x"]), "get() after a change of the value that set() took");
+        assert.deepStrictEqual(await storage.get("b"), item("b", 2, ["y"]), "get() after a change of the value that setBatch() took");
         read.n = 98;
         read.tags.push("changed after get");
         (await storage.getAll())[0].n = 97;
@@ -409,10 +416,10 @@ export function collectionStorageContract(options) {
             });
             await storage.set("c", item("c", 3, ["z"]));
             stop();
-            same(await storage.get("c"), item("c", 3, ["z"]), "get() after an observer changed the value of a change");
+            assert.deepStrictEqual(await storage.get("c"), item("c", 3, ["z"]), "get() after an observer changed the value of a change");
         }
-        same(await storage.get("a"), item("a", 1, ["x"]), "get() after changes of the read values");
-        same(await storage.get("b"), item("b", 2, ["y"]), "get() of the other item after changes of the read values");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 1, ["x"]), "get() after changes of the read values");
+        assert.deepStrictEqual(await storage.get("b"), item("b", 2, ["y"]), "get() of the other item after changes of the read values");
     }));
     add("the storage keeps JSON values, also null", () => withStorage(create, async (typed) => {
         const storage = typed;
@@ -428,20 +435,20 @@ export function collectionStorageContract(options) {
         ];
         await storage.setBatch(values);
         for (const [id, value] of values)
-            same(await storage.get(id), value, `get("${id}")`);
-        same(await storage.getAll(), values.map(([, value]) => value), "getAll() of the JSON values");
-        same(await storage.getBatch(values.map(([id]) => id)), new Map(values), "getBatch() of the JSON values");
-        same(await storage.size(), values.length, "size() with the JSON values");
-        same(await storage.has("null"), true, "has() of an id whose value is null");
+            assert.deepStrictEqual(await storage.get(id), value, `get("${id}")`);
+        assert.deepStrictEqual(await storage.getAll(), values.map(([, value]) => value), "getAll() of the JSON values");
+        assert.deepStrictEqual(await storage.getBatch(values.map(([id]) => id)), new Map(values), "getBatch() of the JSON values");
+        assert.deepStrictEqual(await storage.size(), values.length, "size() with the JSON values");
+        assert.deepStrictEqual(await storage.has("null"), true, "has() of an id whose value is null");
         await storage.set("single", null);
-        same(await storage.get("single"), null, "get() of an id that set() gave the value null");
-        same(await storage.get("missing"), undefined, "get() of a missing id, next to a stored null");
+        assert.deepStrictEqual(await storage.get("single"), null, "get() of an id that set() gave the value null");
+        assert.deepStrictEqual(await storage.get("missing"), undefined, "get() of a missing id, next to a stored null");
     }));
     add("writes that run at the same time keep each write", () => withStorage(create, async (storage) => {
         const count = 20;
         await Promise.all(Array.from({ length: count }, (_, n) => storage.set(`k${n}`, item(`k${n}`, n))));
-        same(await storage.size(), count, `size() after ${count} writes at the same time`);
-        same(ids(await storage.getAll()).sort(), Array.from({ length: count }, (_, n) => `k${n}`).sort(), "the ids after the writes at the same time");
+        assert.deepStrictEqual(await storage.size(), count, `size() after ${count} writes at the same time`);
+        assert.deepStrictEqual(ids(await storage.getAll()).sort(), Array.from({ length: count }, (_, n) => `k${n}`).sort(), "the ids after the writes at the same time");
     }));
     add("getChangesSince() without a version gives every item, in the order of the entries", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getChangesSince", context))
@@ -451,10 +458,10 @@ export function collectionStorageContract(options) {
         await storage.setBatch(entries);
         await storage.set("c", item("c", 30));
         const first = await changes();
-        holds(typeof first.version === "string" && first.version !== "", `the version must be a text that is not empty, not ${show(first.version)}`);
-        same(first.full, true, "full of the first call");
-        same(first.changed, [["c", item("c", 30)], ["a", item("a", 1)], ["b", item("b", 2)]], "changed of the first call: every item, in the order of the entries");
-        same(first.deleted, [], "deleted of a full result");
+        assert.ok(typeof first.version === "string" && first.version !== "", `the version must be a text that is not empty, not ${show(first.version)}`);
+        assert.deepStrictEqual(first.full, true, "full of the first call");
+        assert.deepStrictEqual(first.changed, [["c", item("c", 30)], ["a", item("a", 1)], ["b", item("b", 2)]], "changed of the first call: every item, in the order of the entries");
+        assert.deepStrictEqual(first.deleted, [], "deleted of a full result");
     }));
     add("getChangesSince(version) gives the items that changed after the version and the ids that were deleted", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getChangesSince", context))
@@ -467,10 +474,10 @@ export function collectionStorageContract(options) {
         await storage.delete("missing");
         await storage.set("d", item("d", 4));
         const delta = await changes(start.version);
-        same(delta.full, false, "full of a delta");
-        same(delta.changed, [["a", item("a", 10)], ["d", item("d", 4)]], "changed of a delta");
-        same(delta.deleted, ["b"], "deleted of a delta");
-        holds(delta.version !== start.version, "the version must change after a write");
+        assert.deepStrictEqual(delta.full, false, "full of a delta");
+        assert.deepStrictEqual(delta.changed, [["a", item("a", 10)], ["d", item("d", 4)]], "changed of a delta");
+        assert.deepStrictEqual(delta.deleted, ["b"], "deleted of a delta");
+        assert.ok(delta.version !== start.version, "the version must change after a write");
     }));
     add("getChangesSince(version) gives the changes in the order of the last change of each id", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getChangesSince", context))
@@ -485,13 +492,13 @@ export function collectionStorageContract(options) {
         await storage.delete("c");
         await storage.setBatch([["e", item("e", 5)], ["b", item("b", 21)]]);
         const delta = await changes(start.version);
-        same({ changed: delta.changed, deleted: delta.deleted }, { changed: [["a", item("a", 10)], ["e", item("e", 5)], ["b", item("b", 21)]], deleted: ["d", "c"] }, "the order of a delta: an id written again after another id comes after it");
+        assert.deepStrictEqual({ changed: delta.changed, deleted: delta.deleted }, { changed: [["a", item("a", 10)], ["e", item("e", 5)], ["b", item("b", 21)]], deleted: ["d", "c"] }, "the order of a delta: an id written again after another id comes after it");
         // A delete of d again is not a change. A new set of c moves it from deleted to changed.
         await storage.delete("d");
         await storage.set("c", item("c", 30));
         await storage.deleteBatch(["e", "a"]);
         const next = await changes(delta.version);
-        same({ changed: next.changed, deleted: next.deleted }, { changed: [["c", item("c", 30)]], deleted: ["e", "a"] }, "the order of the next delta");
+        assert.deepStrictEqual({ changed: next.changed, deleted: next.deleted }, { changed: [["c", item("c", 30)]], deleted: ["e", "a"] }, "the order of the next delta");
     }));
     add("getChangesSince(): a deleted id that comes back is a change, clear() deletes each id in the order of the entries, and no write gives no change", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getChangesSince", context))
@@ -502,13 +509,13 @@ export function collectionStorageContract(options) {
         await storage.delete("b");
         await storage.set("b", item("b", 20));
         const back = await changes(start.version);
-        same({ full: back.full, changed: back.changed, deleted: back.deleted }, { full: false, changed: [["b", item("b", 20)]], deleted: [] }, "a delete, then a set of the id");
+        assert.deepStrictEqual({ full: back.full, changed: back.changed, deleted: back.deleted }, { full: false, changed: [["b", item("b", 20)]], deleted: [] }, "a delete, then a set of the id");
         // The entries are a, c, b now: b went to the end at its new set
         await storage.clear();
         const cleared = await changes(back.version);
-        same({ full: cleared.full, changed: cleared.changed, deleted: cleared.deleted }, { full: false, changed: [], deleted: ["a", "c", "b"] }, "the changes of clear()");
+        assert.deepStrictEqual({ full: cleared.full, changed: cleared.changed, deleted: cleared.deleted }, { full: false, changed: [], deleted: ["a", "c", "b"] }, "the changes of clear()");
         const quiet = await changes(cleared.version);
-        same({ full: quiet.full, changed: quiet.changed, deleted: quiet.deleted }, { full: false, changed: [], deleted: [] }, "the changes without a write");
+        assert.deepStrictEqual({ full: quiet.full, changed: quiet.changed, deleted: quiet.deleted }, { full: false, changed: [], deleted: [] }, "the changes without a write");
     }));
     add("getChangesSince() gives every item for an unknown version and for a version of another storage", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getChangesSince", context))
@@ -518,12 +525,12 @@ export function collectionStorageContract(options) {
         await changes();
         for (const unknown of ["not a version", ""]) {
             const result = await changes(unknown);
-            same({ full: result.full, changed: result.changed, deleted: result.deleted }, { full: true, changed: [["a", item("a", 1)], ["b", item("b", 2)]], deleted: [] }, `the changes since ${show(unknown)}`);
+            assert.deepStrictEqual({ full: result.full, changed: result.changed, deleted: result.deleted }, { full: true, changed: [["a", item("a", 1)], ["b", item("b", 2)]], deleted: [] }, `the changes since ${show(unknown)}`);
         }
         await withStorage(create, async (other) => {
             await other.set("x", item("x", 9));
             const foreign = (await changesOf(other)()).version;
-            same((await changes(foreign)).full, true, "full for a version of another storage");
+            assert.deepStrictEqual((await changes(foreign)).full, true, "full for a version of another storage");
         });
     }));
     if (options.createWithMaxTombstones) {
@@ -537,12 +544,12 @@ export function collectionStorageContract(options) {
             // Two deletes fit in the log
             await storage.deleteBatch(["a", "b"]);
             const two = await changes(start.version);
-            same({ full: two.full, changed: two.changed, deleted: two.deleted }, { full: false, changed: [], deleted: ["a", "b"] }, "two deletes in a log of two");
+            assert.deepStrictEqual({ full: two.full, changed: two.changed, deleted: two.deleted }, { full: false, changed: [], deleted: ["a", "b"] }, "two deletes in a log of two");
             // The third delete drops the oldest one: the start version gives all items now
             await storage.delete("c");
             const after = await changes(start.version);
-            same({ full: after.full, changed: after.changed, deleted: after.deleted }, { full: true, changed: [["d", item("d", 4)]], deleted: [] }, "a version older than a dropped delete");
-            same((await changes(after.version)).full, false, "a version after the dropped deletes still gives a delta");
+            assert.deepStrictEqual({ full: after.full, changed: after.changed, deleted: after.deleted }, { full: true, changed: [["d", item("d", 4)]], deleted: [] }, "a version older than a dropped delete");
+            assert.deepStrictEqual((await changes(after.version)).full, false, "a version after the dropped deletes still gives a delta");
         }));
     }
     add("a random sequence of writes agrees with a Map, and each version gives the right changes in the right order", () => withStorage(create, async (storage) => {
@@ -576,7 +583,7 @@ export function collectionStorageContract(options) {
                 const existed = model.delete(id);
                 if (existed)
                     note(id, true);
-                same(await storage.delete(id), existed, `the result of step ${step}: ${label}`);
+                assert.deepStrictEqual(await storage.delete(id), existed, `the result of step ${step}: ${label}`);
             }
             else if (kind < 15) {
                 const batch = Array.from({ length: 1 + random(3) }, (_, index) => {
@@ -599,7 +606,7 @@ export function collectionStorageContract(options) {
                         note(id, true);
                     return existed;
                 }).length;
-                same(await storage.deleteBatch(batch), expected, `the result of step ${step}: ${label}`);
+                assert.deepStrictEqual(await storage.deleteBatch(batch), expected, `the result of step ${step}: ${label}`);
             }
             else if (kind < 19) {
                 label = "clear()";
@@ -613,20 +620,20 @@ export function collectionStorageContract(options) {
                 if (hasChanges)
                     versions.push({ version: (await storage.getChangesSince()).version, entries: new Map(model), at: clock });
             }
-            same(await storage.getAll(), [...model.values()], `getAll() after step ${step}: ${label}`);
+            assert.deepStrictEqual(await storage.getAll(), [...model.values()], `getAll() after step ${step}: ${label}`);
         }
-        same(await storage.size(), model.size, "size() after the sequence");
+        assert.deepStrictEqual(await storage.size(), model.size, "size() after the sequence");
         if (storage.getEntries)
-            same(await storage.getEntries(), [...model.entries()], "getEntries() after the sequence");
+            assert.deepStrictEqual(await storage.getEntries(), [...model.entries()], "getEntries() after the sequence");
         if (storage.getIds)
-            same(await storage.getIds(), [...model.keys()], "getIds() after the sequence");
+            assert.deepStrictEqual(await storage.getIds(), [...model.keys()], "getIds() after the sequence");
         if (!hasChanges)
             return;
-        holds(versions.length > 0, "the sequence saved no version: change the seed");
+        assert.ok(versions.length > 0, "the sequence saved no version: change the seed");
         for (const [index, saved] of versions.entries()) {
             const result = await storage.getChangesSince(saved.version);
             if (result.full) {
-                same(result.changed, [...model.entries()], `the full changes since version ${index}: every item, in the order of the entries`);
+                assert.deepStrictEqual(result.changed, [...model.entries()], `the full changes since version ${index}: every item, in the order of the entries`);
                 continue;
             }
             // A delta: the changes after the version, in the order of the last change of each id
@@ -635,13 +642,13 @@ export function collectionStorageContract(options) {
                 changed: after.filter(([, change]) => !change.deleted).map(([id]) => [id, model.get(id)]),
                 deleted: after.filter(([, change]) => change.deleted).map(([id]) => id),
             };
-            same({ changed: result.changed, deleted: result.deleted }, expected, `the changes since version ${index}`);
+            assert.deepStrictEqual({ changed: result.changed, deleted: result.deleted }, expected, `the changes since version ${index}`);
             const rebuilt = new Map(saved.entries);
             for (const id of result.deleted)
                 rebuilt.delete(id);
             for (const [id, value] of result.changed)
                 rebuilt.set(id, value);
-            same(rebuilt, new Map(model), `the items of version ${index} with its changes`);
+            assert.deepStrictEqual(rebuilt, new Map(model), `the items of version ${index} with its changes`);
         }
     }));
     //
@@ -654,8 +661,8 @@ export function collectionStorageContract(options) {
         await storage.setBatch([...DOCUMENTS]);
         for (const [selector, expected] of SELECTOR_CASES) {
             const result = await storage.query(selector);
-            same(entryIds(result), expected, `the ids of query(${show(selector)})`);
-            same(result, queryEntries(DOCUMENTS, selector), `the entries of query(${show(selector)})`);
+            assert.deepStrictEqual(entryIds(result), expected, `the ids of query(${show(selector)})`);
+            assert.deepStrictEqual(result, queryEntries(DOCUMENTS, selector), `the entries of query(${show(selector)})`);
         }
     }));
     add("query() sorts, then skips, then limits, and items with equal keys keep the order of the entries", (context) => withStorage(create, async (typed) => {
@@ -664,9 +671,9 @@ export function collectionStorageContract(options) {
         const storage = typed;
         await storage.setBatch([...DOCUMENTS]);
         for (const [options, expected] of OPTION_CASES) {
-            same(entryIds(await storage.query({}, options)), expected, `the ids of query({}, ${show(options)})`);
+            assert.deepStrictEqual(entryIds(await storage.query({}, options)), expected, `the ids of query({}, ${show(options)})`);
         }
-        same(entryIds(await storage.query({ n: { $exists: true } }, { sort: { n: -1 }, limit: 2 })), ["e", "d"], "a selector with a sort and a limit");
+        assert.deepStrictEqual(entryIds(await storage.query({ n: { $exists: true } }, { sort: { n: -1 }, limit: 2 })), ["e", "d"], "a selector with a sort and a limit");
     }));
     add("query() rejects a selector or options that are not correct", (context) => withStorage(create, async (typed) => {
         if (lacks(typed, "query", context))
@@ -714,7 +721,7 @@ export function collectionStorageContract(options) {
             if (expected === undefined)
                 await rejects(() => storage.query(selector, options), label);
             else
-                same(await storage.query(selector, options), expected, label);
+                assert.deepStrictEqual(await storage.query(selector, options), expected, label);
         }
     }));
     add("query() refuses $regex without a policy that permits it, and a pattern that repeats a repetition", (context) => withStorage(create, async (typed) => {
@@ -734,8 +741,8 @@ export function collectionStorageContract(options) {
             await storage.setBatch([...DOCUMENTS]);
             for (const [selector, expected] of REGEX_CASES) {
                 const result = await storage.query(selector);
-                same(entryIds(result), expected, `the ids of query(${show(selector)})`);
-                same(result, queryEntries(DOCUMENTS, selector, {}, REGEX_POLICY), `the entries of query(${show(selector)})`);
+                assert.deepStrictEqual(entryIds(result), expected, `the ids of query(${show(selector)})`);
+                assert.deepStrictEqual(result, queryEntries(DOCUMENTS, selector, {}, REGEX_POLICY), `the entries of query(${show(selector)})`);
             }
             await rejects(() => storage.query(REDOS), `query(${show(REDOS)}) under a policy with $regex`);
         }));
@@ -776,7 +783,7 @@ export function collectionStorageContract(options) {
                 [{}, { skip: 5 }, ["f", "g"]],
             ];
             for (const [selector, query, expected] of permitted) {
-                same(entryIds(await storage.query(selector, query)), expected, `the ids of query(${show(selector)}, ${show(query)})`);
+                assert.deepStrictEqual(entryIds(await storage.query(selector, query)), expected, `the ids of query(${show(selector)}, ${show(query)})`);
             }
         }));
     }
@@ -788,27 +795,27 @@ export function collectionStorageContract(options) {
             return;
         const storage = typed;
         await storage.set("a", { id: "a", n: 1, tags: ["x"], meta: { kind: "k1", score: 10 } });
-        same(await storage.patch("a", { n: 2 }), { id: "a", n: 2, tags: ["x"], meta: { kind: "k1", score: 10 } }, "patch() of one field");
-        same(await storage.patch("a", { meta: { score: 11, extra: true }, tags: null }), { id: "a", n: 2, meta: { kind: "k1", score: 11, extra: true } }, "patch() of an object field and a null field");
-        same(await storage.patch("a", { tags: ["y", "z"], meta: { extra: null } }), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "patch() of an array field and a nested null");
-        same(await storage.get("a"), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "get() after the patches");
-        same(await storage.patch("missing", { n: 1 }), undefined, "patch() of a missing id");
-        same(await storage.has("missing"), false, "has() of a missing id after patch()");
-        same(await storage.size(), 1, "size() after patch() of a missing id");
+        assert.deepStrictEqual(await storage.patch("a", { n: 2 }), { id: "a", n: 2, tags: ["x"], meta: { kind: "k1", score: 10 } }, "patch() of one field");
+        assert.deepStrictEqual(await storage.patch("a", { meta: { score: 11, extra: true }, tags: null }), { id: "a", n: 2, meta: { kind: "k1", score: 11, extra: true } }, "patch() of an object field and a null field");
+        assert.deepStrictEqual(await storage.patch("a", { tags: ["y", "z"], meta: { extra: null } }), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "patch() of an array field and a nested null");
+        assert.deepStrictEqual(await storage.get("a"), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "get() after the patches");
+        assert.deepStrictEqual(await storage.patch("missing", { n: 1 }), undefined, "patch() of a missing id");
+        assert.deepStrictEqual(await storage.has("missing"), false, "has() of a missing id after patch()");
+        assert.deepStrictEqual(await storage.size(), 1, "size() after patch() of a missing id");
         await storage.set("plain", 5);
-        same(await storage.patch("plain", { n: 1 }), { n: 1 }, "patch() of an item that is not an object");
+        assert.deepStrictEqual(await storage.patch("plain", { n: 1 }), { n: 1 }, "patch() of an item that is not an object");
         for (const fields of [null, [1], "x", 3]) {
             await rejects(() => storage.patch("a", fields), `patch() with the fields ${show(fields)}`);
         }
-        same(await storage.get("a"), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "get() after the patches that were not correct");
+        assert.deepStrictEqual(await storage.get("a"), { id: "a", n: 2, meta: { kind: "k1", score: 11 }, tags: ["y", "z"] }, "get() after the patches that were not correct");
     }));
     add("patch() with the operations $set and $unset sets null and nested paths, and a patch of two forms rejects", (context) => withStorage(create, async (typed) => {
         if (lacks(typed, "patch", context))
             return;
         const storage = typed;
         await storage.set("a", { id: "a", n: 1, tags: ["x", "y"], meta: { kind: "k1", score: 10 } });
-        same(await storage.patch("a", { $set: { "meta.kind": "k2", note: null, "tags.1": "z", "deep.new.path": 1 }, $unset: ["meta.score"] }), { id: "a", n: 1, tags: ["x", "z"], meta: { kind: "k2" }, note: null, deep: { new: { path: 1 } } }, "patch() with $set and $unset");
-        same(await storage.patch("a", { $unset: ["tags.0", "missing.path", "deep"], $set: { "tags.2": "w" } }), { id: "a", n: 1, tags: [null, "z", "w"], meta: { kind: "k2" }, note: null }, "patch() that removes an element of an array, a missing path and a field, and adds an element");
+        assert.deepStrictEqual(await storage.patch("a", { $set: { "meta.kind": "k2", note: null, "tags.1": "z", "deep.new.path": 1 }, $unset: ["meta.score"] }), { id: "a", n: 1, tags: ["x", "z"], meta: { kind: "k2" }, note: null, deep: { new: { path: 1 } } }, "patch() with $set and $unset");
+        assert.deepStrictEqual(await storage.patch("a", { $unset: ["tags.0", "missing.path", "deep"], $set: { "tags.2": "w" } }), { id: "a", n: 1, tags: [null, "z", "w"], meta: { kind: "k2" }, note: null }, "patch() that removes an element of an array, a missing path and a field, and adds an element");
         const after = { id: "a", n: 1, tags: [null, "z", "w"], meta: { kind: "k2" }, note: null };
         const wrong = [
             ["a patch of two forms", { $set: { n: 2 }, n: 3 }],
@@ -821,17 +828,17 @@ export function collectionStorageContract(options) {
         ];
         for (const [what, fields] of wrong)
             await rejects(() => storage.patch("a", fields), `patch() with ${what}`);
-        same(await storage.get("a"), after, "get() after the patches that were not correct");
-        same(await storage.patch("missing", { $set: { n: 1 } }), undefined, "patch() with $set of a missing id");
-        same(await storage.has("missing"), false, "has() of a missing id after patch() with $set");
+        assert.deepStrictEqual(await storage.get("a"), after, "get() after the patches that were not correct");
+        assert.deepStrictEqual(await storage.patch("missing", { $set: { n: 1 } }), undefined, "patch() with $set of a missing id");
+        assert.deepStrictEqual(await storage.has("missing"), false, "has() of a missing id after patch() with $set");
     }));
     add("patch() with $remove and $insert moves the elements of an array, and each index refers to the item before the patch", (context) => withStorage(create, async (typed) => {
         if (lacks(typed, "patch", context))
             return;
         const storage = typed;
         await storage.set("a", { id: "a", tags: ["a", "b", "c", "d"], rows: [{ n: 1, keys: ["x"] }, { n: 2, keys: ["y"] }], meta: { kind: "k1" } });
-        same(await storage.patch("a", { $remove: ["tags.1", "tags.3", "meta.kind"], $insert: { "rows.1.keys.0": "w" } }), { id: "a", tags: ["a", "c"], rows: [{ n: 1, keys: ["x"] }, { n: 2, keys: ["w", "y"] }], meta: {} }, "patch() with $remove and $insert");
-        same(await storage.patch("a", { $insert: { "tags.0": "z", "tags.2": "e" }, $remove: ["rows.0", "missing.0"], $set: { "rows.1.n": 3 } }), { id: "a", tags: ["z", "a", "c", "e"], rows: [{ n: 3, keys: ["w", "y"] }], meta: {} }, "patch() that inserts at the start and at the end, and removes a missing path");
+        assert.deepStrictEqual(await storage.patch("a", { $remove: ["tags.1", "tags.3", "meta.kind"], $insert: { "rows.1.keys.0": "w" } }), { id: "a", tags: ["a", "c"], rows: [{ n: 1, keys: ["x"] }, { n: 2, keys: ["w", "y"] }], meta: {} }, "patch() with $remove and $insert");
+        assert.deepStrictEqual(await storage.patch("a", { $insert: { "tags.0": "z", "tags.2": "e" }, $remove: ["rows.0", "missing.0"], $set: { "rows.1.n": 3 } }), { id: "a", tags: ["z", "a", "c", "e"], rows: [{ n: 3, keys: ["w", "y"] }], meta: {} }, "patch() that inserts at the start and at the end, and removes a missing path");
         const after = { id: "a", tags: ["z", "a", "c", "e"], rows: [{ n: 3, keys: ["w", "y"] }], meta: {} };
         const wrong = [
             ["a $remove that is not a list of paths", { $remove: "tags" }],
@@ -843,7 +850,7 @@ export function collectionStorageContract(options) {
         ];
         for (const [what, fields] of wrong)
             await rejects(() => storage.patch("a", fields), `patch() with ${what}`);
-        same(await storage.get("a"), after, "get() after the patches that were not correct");
+        assert.deepStrictEqual(await storage.get("a"), after, "get() after the patches that were not correct");
     }));
     add("patch() runs in one step: patches of one item at the same time keep each field", (context) => withStorage(create, async (typed) => {
         if (lacks(typed, "patch", context))
@@ -855,7 +862,7 @@ export function collectionStorageContract(options) {
         const expected = { id: "a" };
         for (let n = 0; n < count; n++)
             expected[`f${n}`] = n;
-        same(await storage.get("a"), expected, `get() after ${count} patches at the same time`);
+        assert.deepStrictEqual(await storage.get("a"), expected, `get() after ${count} patches at the same time`);
     }));
     add("patch() is a change: getChangesSince() gives the patched item", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "patch", context) || lacks(storage, "getChangesSince", context))
@@ -865,7 +872,7 @@ export function collectionStorageContract(options) {
         await storage.patch("a", { n: 10 });
         await storage.patch("missing", { n: 3 });
         const delta = await storage.getChangesSince(start.version);
-        same({ full: delta.full, changed: delta.changed, deleted: delta.deleted }, { full: false, changed: [["a", item("a", 10)]], deleted: [] }, "the changes after a patch");
+        assert.deepStrictEqual({ full: delta.full, changed: delta.changed, deleted: delta.deleted }, { full: false, changed: [["a", item("a", 10)]], deleted: [] }, "the changes after a patch");
     }));
     //
     // ═══ observe() ═══
@@ -876,7 +883,7 @@ export function collectionStorageContract(options) {
         const batches = [];
         const stop = storage.observe((batch) => batches.push(plainBatch(batch)));
         await storage.set("a", item("a", 1));
-        same(batches.length, 1, "the batches when set() resolves");
+        assert.deepStrictEqual(batches.length, 1, "the batches when set() resolves");
         await storage.setBatch([["b", item("b", 2)], ["c", item("c", 3)]]);
         await storage.delete("a");
         await storage.deleteBatch(["b", "missing"]);
@@ -884,7 +891,7 @@ export function collectionStorageContract(options) {
             await storage.patch("c", { n: 30 });
         await storage.clear();
         stop();
-        same(batches, [
+        assert.deepStrictEqual(batches, [
             [{ type: "set", id: "a", value: item("a", 1) }],
             [
                 { type: "set", id: "b", value: item("b", 2) },
@@ -908,7 +915,7 @@ export function collectionStorageContract(options) {
         await storage.clear();
         if (storage.patch)
             await storage.patch("missing", { n: 1 });
-        same(batches, [], "the batches of the writes that change nothing");
+        assert.deepStrictEqual(batches, [], "the batches of the writes that change nothing");
         await storage.set("a", item("a", 1), { origin: "sync" });
         await storage.setBatch([["b", item("b", 2)]], { origin: "app" });
         await storage.delete("a", { origin: "sync" });
@@ -916,7 +923,7 @@ export function collectionStorageContract(options) {
         await storage.set("c", item("c", 3), {});
         await storage.clear({ origin: "reset" });
         stop();
-        same(batches, [
+        assert.deepStrictEqual(batches, [
             [{ type: "set", id: "a", value: item("a", 1), origin: "sync" }],
             [{ type: "set", id: "b", value: item("b", 2), origin: "app" }],
             [{ type: "delete", id: "a", origin: "sync" }],
@@ -938,8 +945,8 @@ export function collectionStorageContract(options) {
         await storage.delete("a");
         stopSecond();
         await storage.set("b", item("b", 2));
-        same(first, ["set"], "the changes of the first observer");
-        same(second, ["set", "delete"], "the changes of the second observer");
+        assert.deepStrictEqual(first, ["set"], "the changes of the first observer");
+        assert.deepStrictEqual(second, ["set", "delete"], "the changes of the second observer");
     }));
     add("flush() resolves, and the items stay", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "flush", context))
@@ -947,15 +954,15 @@ export function collectionStorageContract(options) {
         await storage.flush();
         await storage.set("a", item("a", 1));
         await storage.flush();
-        same(await storage.get("a"), item("a", 1), "get() after flush()");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 1), "get() after flush()");
     }));
     add("getMetadata() gives a known type and the size", (context) => withStorage(create, async (storage) => {
         if (lacks(storage, "getMetadata", context))
             return;
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 2)]]);
         const metadata = await storage.getMetadata();
-        holds(["memory", "api", "hybrid", "synced", "custom"].includes(metadata.type), `getMetadata() gave the unknown type ${show(metadata.type)}`);
-        same(metadata.size, 2, "the size of getMetadata()");
+        assert.ok(["memory", "api", "hybrid", "synced", "custom"].includes(metadata.type), `getMetadata() gave the unknown type ${show(metadata.type)}`);
+        assert.deepStrictEqual(metadata.size, 2, "the size of getMetadata()");
     }));
     add("after close(), each operation rejects with an error that says that the storage is closed, and a second close() does nothing", () => withStorage(create, async (storage) => {
         await storage.set("a", item("a", 1));
@@ -993,7 +1000,7 @@ export function collectionStorageContract(options) {
         const check = async (when) => {
             for (const [name, start] of operations) {
                 const error = await rejects(start, `${name}() ${when}`);
-                holds(error instanceof Error && /closed/i.test(error.message), `${name}() ${when} must reject with an Error whose message says "closed", not ${show(error instanceof Error ? error.message : error)}`);
+                assert.ok(error instanceof Error && /closed/i.test(error.message), `${name}() ${when} must reject with an Error whose message says "closed", not ${show(error instanceof Error ? error.message : error)}`);
             }
         };
         const checkObserve = (when) => {
@@ -1006,7 +1013,7 @@ export function collectionStorageContract(options) {
             catch (thrown) {
                 error = thrown;
             }
-            holds(error instanceof Error && /closed/i.test(error.message), `observe() ${when} must throw an Error whose message says "closed", not ${show(error instanceof Error ? error.message : error)}`);
+            assert.ok(error instanceof Error && /closed/i.test(error.message), `observe() ${when} must throw an Error whose message says "closed", not ${show(error instanceof Error ? error.message : error)}`);
         };
         await check("after close()");
         checkObserve("after close()");
@@ -1024,9 +1031,9 @@ export function collectionStorageContract(options) {
  */
 function conflictsOfRejection(error, what) {
     const code = error?.code;
-    holds(code === "VERSION_CONFLICT", `${what}: the error must have the code VERSION_CONFLICT, not ${show(code)} (${show(error instanceof Error ? error.message : error)})`);
+    assert.ok(code === "VERSION_CONFLICT", `${what}: the error must have the code VERSION_CONFLICT, not ${show(code)} (${show(error instanceof Error ? error.message : error)})`);
     const conflicts = versionConflictsOf(error);
-    holds(conflicts !== undefined, `${what}: the error must have its conflicts`);
+    assert.ok(conflicts !== undefined, `${what}: the error must have its conflicts`);
     return conflicts;
 }
 /** The cases of the preconditions of the writes (roadmap CLI-16). */
@@ -1036,10 +1043,10 @@ function addPreconditionCases(add, create, createWithVersions) {
         await rejects(() => storage.set("a", item("a", 2), { expectedVersion: "v1" }), "set() with expectedVersion on a storage without versions");
         await rejects(() => storage.delete("a", { expectedVersion: "v1" }), "delete() with expectedVersion on a storage without versions");
         await rejects(() => storage.setBatch([["a", item("a", 3)]], { expectedVersions: [["a", "v1"]] }), "setBatch() with expectedVersions on a storage without versions");
-        same(await storage.get("a"), item("a", 1), "the item after the refused writes");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 1), "the item after the refused writes");
         // A write without a precondition is the write of before
         await storage.set("a", item("a", 4));
-        same(await storage.get("a"), item("a", 4), "a write without expectedVersion");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 4), "a write without expectedVersion");
     }));
     if (!createWithVersions)
         return;
@@ -1047,11 +1054,11 @@ function addPreconditionCases(add, create, createWithVersions) {
     add("a write with the expected version of the current item writes, and a write without one writes as before", () => withStorage(versioned, async (storage) => {
         await storage.set("a", item("a", 1));
         await storage.set("a", item("a", 2), { expectedVersion: "v1" });
-        same(await storage.get("a"), item("a", 2), "the item after set() with the expected version");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 2), "the item after set() with the expected version");
         await storage.set("a", item("a", 3));
-        same(await storage.get("a"), item("a", 3), "the item after set() without expectedVersion");
-        same(await storage.delete("a", { expectedVersion: "v3" }), true, "delete() with the expected version");
-        same(await storage.get("a"), undefined, "the item after delete() with the expected version");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 3), "the item after set() without expectedVersion");
+        assert.deepStrictEqual(await storage.delete("a", { expectedVersion: "v3" }), true, "delete() with the expected version");
+        assert.deepStrictEqual(await storage.get("a"), undefined, "the item after delete() with the expected version");
     }));
     add("a write with another expected version changes nothing, and rejects with VERSION_CONFLICT and the current item", () => withStorage(versioned, async (storage) => {
         await storage.set("a", item("a", 1));
@@ -1062,35 +1069,35 @@ function addPreconditionCases(add, create, createWithVersions) {
         const before = storage.getChangesSince ? (await storage.getChangesSince()).version : undefined;
         const expected = { id: "a", expected: "v2", found: true, value: item("a", 1), version: "v1" };
         const setError = await rejects(() => storage.set("a", item("a", 3), { expectedVersion: "v2" }), "set() with a stale version");
-        same(conflictsOfRejection(setError, "set() with a stale version"), [expected], "the conflicts of set() with a stale version");
+        assert.deepStrictEqual(conflictsOfRejection(setError, "set() with a stale version"), [expected], "the conflicts of set() with a stale version");
         const deleteError = await rejects(() => storage.delete("a", { expectedVersion: "v2" }), "delete() with a stale version");
-        same(conflictsOfRejection(deleteError, "delete() with a stale version"), [expected], "the conflicts of delete() with a stale version");
-        same(await storage.get("a"), item("a", 1), "the item after the refused writes");
+        assert.deepStrictEqual(conflictsOfRejection(deleteError, "delete() with a stale version"), [expected], "the conflicts of delete() with a stale version");
+        assert.deepStrictEqual(await storage.get("a"), item("a", 1), "the item after the refused writes");
         stop?.();
-        same(batches, 0, "the batches of observe() for the refused writes");
+        assert.deepStrictEqual(batches, 0, "the batches of observe() for the refused writes");
         if (storage.getChangesSince && before !== undefined) {
             const after = await storage.getChangesSince(before);
-            same({ changed: after.changed, deleted: after.deleted }, { changed: [], deleted: [] }, "the changes after the refused writes");
+            assert.deepStrictEqual({ changed: after.changed, deleted: after.deleted }, { changed: [], deleted: [] }, "the changes after the refused writes");
         }
     }));
     add("the expected version null expects no item", () => withStorage(versioned, async (storage) => {
         await storage.set("b", item("b", 1), { expectedVersion: null });
-        same(await storage.get("b"), item("b", 1), "set() with expectedVersion null of a missing id");
+        assert.deepStrictEqual(await storage.get("b"), item("b", 1), "set() with expectedVersion null of a missing id");
         const exists = await rejects(() => storage.set("b", item("b", 2), { expectedVersion: null }), "set() with expectedVersion null of an existing id");
-        same(conflictsOfRejection(exists, "set() with expectedVersion null of an existing id"), [{ id: "b", expected: null, found: true, value: item("b", 1), version: "v1" }], "the conflict of an existing id");
+        assert.deepStrictEqual(conflictsOfRejection(exists, "set() with expectedVersion null of an existing id"), [{ id: "b", expected: null, found: true, value: item("b", 1), version: "v1" }], "the conflict of an existing id");
         const missing = await rejects(() => storage.set("c", item("c", 1), { expectedVersion: "v1" }), "set() with a version of a missing id");
-        same(conflictsOfRejection(missing, "set() with a version of a missing id"), [{ id: "c", expected: "v1", found: false, version: null }], "the conflict of a missing id");
-        same(await storage.has("c"), false, "the missing id after the refused set()");
-        same(await storage.delete("x", { expectedVersion: null }), false, "delete() with expectedVersion null of a missing id");
+        assert.deepStrictEqual(conflictsOfRejection(missing, "set() with a version of a missing id"), [{ id: "c", expected: "v1", found: false, version: null }], "the conflict of a missing id");
+        assert.deepStrictEqual(await storage.has("c"), false, "the missing id after the refused set()");
+        assert.deepStrictEqual(await storage.delete("x", { expectedVersion: null }), false, "delete() with expectedVersion null of a missing id");
     }));
     add("setBatch() tests the expected version of each id, and a conflict changes no item", () => withStorage(versioned, async (storage) => {
         await storage.setBatch([["a", item("a", 1)], ["b", item("b", 1)]]);
         const error = await rejects(() => storage.setBatch([["a", item("a", 2)], ["b", item("b", 2)], ["c", item("c", 1)]], { expectedVersions: [["a", "v1"], ["b", "v9"]] }), "setBatch() with one stale version");
-        same(conflictsOfRejection(error, "setBatch() with one stale version"), [{ id: "b", expected: "v9", found: true, value: item("b", 1), version: "v1" }], "the conflicts of setBatch()");
-        same(await storage.getBatch(["a", "b", "c"]), new Map([["a", item("a", 1)], ["b", item("b", 1)]]), "the items after the refused batch");
+        assert.deepStrictEqual(conflictsOfRejection(error, "setBatch() with one stale version"), [{ id: "b", expected: "v9", found: true, value: item("b", 1), version: "v1" }], "the conflicts of setBatch()");
+        assert.deepStrictEqual(await storage.getBatch(["a", "b", "c"]), new Map([["a", item("a", 1)], ["b", item("b", 1)]]), "the items after the refused batch");
         // An id without an expected version has no precondition
         await storage.setBatch([["a", item("a", 2)], ["b", item("b", 2)], ["c", item("c", 1)]], { expectedVersions: [["a", "v1"], ["b", "v1"]] });
-        same(await storage.getBatch(["a", "b", "c"]), new Map([["a", item("a", 2)], ["b", item("b", 2)], ["c", item("c", 1)]]), "the items after the batch");
+        assert.deepStrictEqual(await storage.getBatch(["a", "b", "c"]), new Map([["a", item("a", 2)], ["b", item("b", 2)], ["c", item("c", 1)]]), "the items after the batch");
     }));
     add("two writes with the same expected version at the same time: one writes, and the other gets VERSION_CONFLICT", () => withStorage(versioned, async (storage) => {
         await storage.set("a", item("a", 1));
@@ -1099,11 +1106,11 @@ function addPreconditionCases(add, create, createWithVersions) {
             storage.set("a", item("a", 3), { expectedVersion: "v1" }),
         ]);
         const won = results.flatMap((result, index) => (result.status === "fulfilled" ? [index] : []));
-        same(won.length, 1, "the number of writes that won");
+        assert.deepStrictEqual(won.length, 1, "the number of writes that won");
         const lost = results.find((result) => result.status === "rejected");
         const conflicts = conflictsOfRejection(lost.reason, "the write that lost");
-        same(conflicts.map((conflict) => conflict.id), ["a"], "the conflict of the write that lost");
-        same(await storage.get("a"), item("a", won[0] === 0 ? 2 : 3), "the item of the write that won");
+        assert.deepStrictEqual(conflicts.map((conflict) => conflict.id), ["a"], "the conflict of the write that lost");
+        assert.deepStrictEqual(await storage.get("a"), item("a", won[0] === 0 ? 2 : 3), "the item of the write that won");
     }));
 }
 /**