@peerbit/indexer-tests 3.0.5 → 3.0.7

package/dist/src/tie-parity.d.ts

@@ -0,0 +1,3 @@
+import { type Indices } from "@peerbit/indexer-interface";
+export declare const tieParityTests: (createIndicies: (directory?: string) => Indices | Promise<Indices>) => Mocha.Suite;
+//# sourceMappingURL=tie-parity.d.ts.map

package/dist/src/tie-parity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tie-parity.d.ts","sourceRoot":"","sources":["../../src/tie-parity.ts"],"names":[],"mappings":"AACA,OAAO,EACN,KAAK,OAAO,EAKZ,MAAM,4BAA4B,CAAC;AAiEpC,eAAO,MAAM,cAAc,GAC1B,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,gBAgElE,CAAC"}

package/dist/src/tie-parity.js

@@ -0,0 +1,214 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { field, variant } from "@dao-xyz/borsh";
+import { Sort, SortDirection, getIdProperty, id, } from "@peerbit/indexer-interface";
+import { expect } from "chai";
+// Cross-backend SORT TIE-BREAK parity: @peerbit/indexer-simple (HashmapIndex) and
+// @peerbit/indexer-sqlite3 must break ties on equal sort keys IDENTICALLY, in the
+// document primary-key id's natural typed order:
+//   - string ids    -> UTF-8 byte order   (sqlite TEXT / BINARY collation)
+//   - integer ids    -> NUMERIC order       (sqlite INTEGER: 2 < 10, not "10" < "2")
+//   - Uint8Array ids -> raw-byte memcmp     (sqlite BLOB: 0x00 < 0xff, not base64)
+// and REVERSE that id order when the (single) sort field is DESC.
+//
+// Every document shares sortKey=1 so the whole result set is one tie group, which
+// forces the id tie-break for every row. Simple historically ordered ties by
+// INSERTION order (direction-independent), matching neither sqlite nor a stable
+// content order; this suite locks simple == sqlite.
+let StringIdDoc = (() => {
+    let _classDecorators = [variant("tie_str")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _sortKey_decorators;
+    let _sortKey_initializers = [];
+    let _sortKey_extraInitializers = [];
+    var StringIdDoc = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [id({ type: "string" })];
+            _sortKey_decorators = [field({ type: "u32" })];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _sortKey_decorators, { kind: "field", name: "sortKey", static: false, private: false, access: { has: obj => "sortKey" in obj, get: obj => obj.sortKey, set: (obj, value) => { obj.sortKey = value; } }, metadata: _metadata }, _sortKey_initializers, _sortKey_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            StringIdDoc = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        sortKey = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _sortKey_initializers, void 0));
+        constructor(id) {
+            __runInitializers(this, _sortKey_extraInitializers);
+            this.id = id;
+            this.sortKey = 1;
+        }
+    };
+    return StringIdDoc = _classThis;
+})();
+let BigIntIdDoc = (() => {
+    let _classDecorators = [variant("tie_bigint")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _sortKey_decorators;
+    let _sortKey_initializers = [];
+    let _sortKey_extraInitializers = [];
+    var BigIntIdDoc = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [id({ type: "u64" })];
+            _sortKey_decorators = [field({ type: "u32" })];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _sortKey_decorators, { kind: "field", name: "sortKey", static: false, private: false, access: { has: obj => "sortKey" in obj, get: obj => obj.sortKey, set: (obj, value) => { obj.sortKey = value; } }, metadata: _metadata }, _sortKey_initializers, _sortKey_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BigIntIdDoc = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        sortKey = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _sortKey_initializers, void 0));
+        constructor(id) {
+            __runInitializers(this, _sortKey_extraInitializers);
+            this.id = id;
+            this.sortKey = 1;
+        }
+    };
+    return BigIntIdDoc = _classThis;
+})();
+let BytesIdDoc = (() => {
+    let _classDecorators = [variant("tie_bytes")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _sortKey_decorators;
+    let _sortKey_initializers = [];
+    let _sortKey_extraInitializers = [];
+    var BytesIdDoc = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [id({ type: Uint8Array })];
+            _sortKey_decorators = [field({ type: "u32" })];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _sortKey_decorators, { kind: "field", name: "sortKey", static: false, private: false, access: { has: obj => "sortKey" in obj, get: obj => obj.sortKey, set: (obj, value) => { obj.sortKey = value; } }, metadata: _metadata }, _sortKey_initializers, _sortKey_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BytesIdDoc = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        sortKey = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _sortKey_initializers, void 0));
+        constructor(id) {
+            __runInitializers(this, _sortKey_extraInitializers);
+            this.id = id;
+            this.sortKey = 1;
+        }
+    };
+    return BytesIdDoc = _classThis;
+})();
+const fmt = (value) => value instanceof Uint8Array
+    ? Array.from(value)
+        .map((x) => x.toString(16).padStart(2, "0"))
+        .join("")
+    : String(value);
+export const tieParityTests = (createIndicies) => {
+    return describe("sort tie-break parity", () => {
+        let indices;
+        afterEach(async () => {
+            await indices?.stop?.();
+            await indices?.drop?.();
+            indices = undefined;
+        });
+        const collect = async (schema, docs) => {
+            indices = await createIndicies();
+            await indices.start();
+            const store = await indices.init({
+                schema,
+                indexBy: getIdProperty(schema) || ["id"],
+            });
+            for (const doc of docs) {
+                await store.put(doc);
+            }
+            const order = async (direction) => {
+                const results = await store
+                    .iterate({
+                    query: [],
+                    sort: [new Sort({ key: "sortKey", direction })],
+                })
+                    .all();
+                return results.map((r) => fmt(r.value.id));
+            };
+            const asc = await order(SortDirection.ASC);
+            const desc = await order(SortDirection.DESC);
+            await store.stop?.();
+            await indices.stop?.();
+            await indices.drop?.();
+            indices = undefined;
+            return { asc, desc };
+        };
+        it("orders string-id ties by UTF-8 bytes, both directions", async () => {
+            const docs = ["c", "a", "b", "aa", "A", "Z"].map((s) => new StringIdDoc(s));
+            const { asc, desc } = await collect(StringIdDoc, docs);
+            // UTF-8 byte order: uppercase (A, Z) before lowercase (a, aa, b, c).
+            expect(asc).to.deep.equal(["A", "Z", "a", "aa", "b", "c"]);
+            expect(desc).to.deep.equal(["c", "b", "aa", "a", "Z", "A"]);
+        });
+        it("orders bigint-id ties numerically, both directions", async () => {
+            const docs = [10n, 2n, 21n, 9n, 100n, 300n].map((n) => new BigIntIdDoc(n));
+            const { asc, desc } = await collect(BigIntIdDoc, docs);
+            expect(asc).to.deep.equal(["2", "9", "10", "21", "100", "300"]);
+            expect(desc).to.deep.equal(["300", "100", "21", "10", "9", "2"]);
+        });
+        it("orders Uint8Array-id ties by raw bytes, both directions", async () => {
+            const docs = [[0xff], [0x00], [0x0a], [0x3e], [0xf8], [0xfb]].map((b) => new BytesIdDoc(new Uint8Array(b)));
+            const { asc, desc } = await collect(BytesIdDoc, docs);
+            // Raw-byte memcmp: 0x00 < 0x0a < 0x3e < 0xf8 < 0xfb < 0xff.
+            expect(asc).to.deep.equal(["00", "0a", "3e", "f8", "fb", "ff"]);
+            expect(desc).to.deep.equal(["ff", "fb", "f8", "3e", "0a", "00"]);
+        });
+    });
+};
+//# sourceMappingURL=tie-parity.js.map

package/dist/src/tie-parity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tie-parity.js","sourceRoot":"","sources":["../../src/tie-parity.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbit/indexer-tests",
-  "version": "3.0.5",
+  "version": "3.0.7",
   "description": "Tests document store index engines",
   "sideEffects": false,
   "type": "module",
@@ -52,17 +52,17 @@
   "publishConfig": {
     "access": "public"
   },
-  "author": "dao.xyz",
+  "author": "Peerbit contributors",
   "license": "MIT",
   "dependencies": {
     "@dao-xyz/borsh": "^6.0.0",
+    "benchmark": "^2.1.4",
     "libsodium-wrappers": "0.7.15",
     "uint8arrays": "^5.1.0",
-    "benchmark": "^2.1.4",
-    "uuid": "^10.0.0",
-    "@peerbit/crypto": "3.1.2",
-    "@peerbit/indexer-interface": "3.0.5",
-    "@peerbit/time": "3.0.0"
+    "uuid": "^11.1.1",
+    "@peerbit/crypto": "3.1.3",
+    "@peerbit/time": "3.0.1",
+    "@peerbit/indexer-interface": "3.0.7"
   },
   "scripts": {
     "clean": "aegir clean",

package/src/index.ts

@@ -1,2 +1,3 @@
 export { tests } from "./tests.js";
+export { tieParityTests } from "./tie-parity.js";
 export { benchmarks } from "./benchmarks.js";

package/src/tests.ts

@@ -4048,6 +4048,273 @@ export const tests = (
 				expect(await iterator.pending()).to.eq(0);
 			});
 
+			it("all after partial next returns only remaining sorted results", async () => {
+				await put(0);
+				await put(1);
+				await put(2);
+
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.name)).to.deep.equal(
+					["0"],
+				);
+				expect((await iterator.all()).map((x) => x.value.name)).to.deep.equal([
+					"1",
+					"2",
+				]);
+				expect(iterator.done()).to.be.true;
+			});
+
+			it("deleting an already yielded sorted result does not skip the next result", async () => {
+				await put(0);
+				await put(1);
+				await put(2);
+
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.name)).to.deep.equal(
+					["0"],
+				);
+				await store.del({
+					query: new StringMatch({
+						key: "id",
+						value: "0",
+						method: StringMatchMethod.exact,
+						caseInsensitive: false,
+					}),
+				});
+
+				expect((await iterator.next(2)).map((x) => x.value.name)).to.deep.equal(
+					["1", "2"],
+				);
+				expect(iterator.done()).to.be.true;
+			});
+
+			it("inserting before an already yielded sorted result does not duplicate it", async () => {
+				await put(1);
+				await put(2);
+
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.name)).to.deep.equal(
+					["1"],
+				);
+				await put(0);
+
+				const rest = (await iterator.next(3)).map((x) => x.value.name);
+				expect(new Set(rest).size).to.equal(rest.length);
+				expect(rest).to.not.include("1");
+				expect(rest).to.include("2");
+			});
+
+			it("keeps a mutated iterator open while unseen sorted results remain", async () => {
+				await put(0);
+				await put(2);
+
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.name)).to.deep.equal(
+					["0"],
+				);
+				await put(1);
+
+				if (properties.iteratorsMutable) {
+					expect(
+						(await iterator.next(1)).map((x) => x.value.name),
+					).to.deep.equal(["1"]);
+					expect(iterator.done()).to.be.false;
+					expect(await iterator.pending()).to.equal(1);
+					expect(
+						(await iterator.next(1)).map((x) => x.value.name),
+					).to.deep.equal(["2"]);
+				} else {
+					expect(
+						(await iterator.next(1)).map((x) => x.value.name),
+					).to.deep.equal(["2"]);
+				}
+				expect(iterator.done()).to.be.true;
+			});
+
+			it("next Infinity sees inserts after an initially empty page", async () => {
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect(await iterator.next(1)).to.deep.equal([]);
+				await put(0);
+
+				const rest = (await iterator.next(Infinity)).map((x) => x.value.name);
+				expect(rest).to.deep.equal(properties.iteratorsMutable ? ["0"] : []);
+			});
+
+			it("keeps an explicitly closed iterator terminal across mutations", async () => {
+				await put(0);
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				await iterator.close();
+				await put(1);
+
+				expect(await iterator.next(1)).to.deep.equal([]);
+				expect(await iterator.all()).to.deep.equal([]);
+				expect(await iterator.pending()).to.equal(0);
+				expect(iterator.done()).to.be.true;
+			});
+
+			it("can continue a mutable iterator after all and a later insert", async () => {
+				await put(0);
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.all()).map((x) => x.value.name)).to.deep.equal([
+					"0",
+				]);
+				await put(1);
+
+				expect((await iterator.next(1)).map((x) => x.value.name)).to.deep.equal(
+					properties.iteratorsMutable ? ["1"] : [],
+				);
+			});
+
+			it("refreshes pending after an exhausted mutable iterator mutates", async () => {
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect(await iterator.next(1)).to.deep.equal([]);
+				await put(0);
+
+				expect(await iterator.pending()).to.equal(
+					properties.iteratorsMutable ? 1 : 0,
+				);
+				if (properties.iteratorsMutable) {
+					expect(iterator.done()).to.be.false;
+					expect(
+						(await iterator.next(1)).map((x) => x.value.name),
+					).to.deep.equal(["0"]);
+				}
+			});
+
+			it("can mark live results delivered outside the iterator as yielded", async () => {
+				if (!properties.iteratorsMutable) {
+					return;
+				}
+
+				await put(0);
+				await put(1);
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "name" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.id)).to.deep.equal([
+					"0",
+				]);
+				await put(2);
+				expect(iterator.markYielded).to.be.a("function");
+				await iterator.markYielded!([toId("2")]);
+
+				expect(await iterator.pending()).to.equal(1);
+				expect((await iterator.next(2)).map((x) => x.value.id)).to.deep.equal([
+					"1",
+				]);
+				expect(await iterator.pending()).to.equal(0);
+				expect(iterator.done()).to.be.true;
+			});
+
+			it("tracks filtered updates without duplicates", async () => {
+				if (!properties.iteratorsMutable) {
+					return;
+				}
+
+				await put(0, { name: "match" });
+				await put(1, { name: "miss" });
+				await put(2, { name: "match" });
+				const iterator = store.iterate({
+					query: new StringMatch({
+						key: "name",
+						value: "match",
+						method: StringMatchMethod.exact,
+						caseInsensitive: false,
+					}),
+					sort: [new Sort({ direction: SortDirection.ASC, key: "number" })],
+				});
+
+				expect((await iterator.next(1)).map((x) => x.value.id)).to.deep.equal([
+					"0",
+				]);
+				await put(1, { name: "match" });
+				await put(2, { name: "miss" });
+				await put(0, { name: "match" });
+				await put(3, { name: "match" });
+
+				expect((await iterator.all()).map((x) => x.value.id)).to.deep.equal([
+					"1",
+					"3",
+				]);
+			});
+
+			it("rescans beyond 128 yielded rows after a mutation", async () => {
+				if (!properties.iteratorsMutable) {
+					return;
+				}
+
+				for (let i = 0; i < 140; i++) {
+					await put(i);
+				}
+				const iterator = store.iterate({
+					query: [],
+					sort: [new Sort({ direction: SortDirection.ASC, key: "number" })],
+				});
+				expect(await iterator.next(130)).to.have.length(130);
+
+				await store.del({
+					query: new StringMatch({
+						key: "id",
+						value: "0",
+						method: StringMatchMethod.exact,
+						caseInsensitive: false,
+					}),
+				});
+				await put(200);
+
+				expect((await iterator.next(1)).map((x) => x.value.id)).to.deep.equal([
+					"130",
+				]);
+				const remaining = (await iterator.all()).map((x) => x.value.id);
+				expect(remaining).to.deep.equal([
+					"131",
+					"132",
+					"133",
+					"134",
+					"135",
+					"136",
+					"137",
+					"138",
+					"139",
+					"200",
+				]);
+				expect(new Set(remaining).size).to.equal(remaining.length);
+			});
+
 			describe("close", () => {
 				it("by invoking close()", async () => {
 					await put(0);

package/src/tie-parity.ts

@@ -0,0 +1,138 @@
+import { field, variant } from "@dao-xyz/borsh";
+import {
+	type Indices,
+	Sort,
+	SortDirection,
+	getIdProperty,
+	id,
+} from "@peerbit/indexer-interface";
+import { expect } from "chai";
+
+// Cross-backend SORT TIE-BREAK parity: @peerbit/indexer-simple (HashmapIndex) and
+// @peerbit/indexer-sqlite3 must break ties on equal sort keys IDENTICALLY, in the
+// document primary-key id's natural typed order:
+//   - string ids    -> UTF-8 byte order   (sqlite TEXT / BINARY collation)
+//   - integer ids    -> NUMERIC order       (sqlite INTEGER: 2 < 10, not "10" < "2")
+//   - Uint8Array ids -> raw-byte memcmp     (sqlite BLOB: 0x00 < 0xff, not base64)
+// and REVERSE that id order when the (single) sort field is DESC.
+//
+// Every document shares sortKey=1 so the whole result set is one tie group, which
+// forces the id tie-break for every row. Simple historically ordered ties by
+// INSERTION order (direction-independent), matching neither sqlite nor a stable
+// content order; this suite locks simple == sqlite.
+
+@variant("tie_str")
+class StringIdDoc {
+	@id({ type: "string" })
+	id: string;
+
+	@field({ type: "u32" })
+	sortKey: number;
+
+	constructor(id: string) {
+		this.id = id;
+		this.sortKey = 1;
+	}
+}
+
+@variant("tie_bigint")
+class BigIntIdDoc {
+	@id({ type: "u64" })
+	id: bigint;
+
+	@field({ type: "u32" })
+	sortKey: number;
+
+	constructor(id: bigint) {
+		this.id = id;
+		this.sortKey = 1;
+	}
+}
+
+@variant("tie_bytes")
+class BytesIdDoc {
+	@id({ type: Uint8Array })
+	id: Uint8Array;
+
+	@field({ type: "u32" })
+	sortKey: number;
+
+	constructor(id: Uint8Array) {
+		this.id = id;
+		this.sortKey = 1;
+	}
+}
+
+const fmt = (value: string | number | bigint | Uint8Array): string =>
+	value instanceof Uint8Array
+		? Array.from(value)
+				.map((x) => x.toString(16).padStart(2, "0"))
+				.join("")
+		: String(value);
+
+export const tieParityTests = (
+	createIndicies: (directory?: string) => Indices | Promise<Indices>,
+) => {
+	return describe("sort tie-break parity", () => {
+		let indices: Indices | undefined;
+
+		afterEach(async () => {
+			await indices?.stop?.();
+			await indices?.drop?.();
+			indices = undefined;
+		});
+
+		const collect = async (schema: any, docs: any[]) => {
+			indices = await createIndicies();
+			await indices.start();
+			const store = await indices.init({
+				schema,
+				indexBy: getIdProperty(schema) || ["id"],
+			});
+			for (const doc of docs) {
+				await store.put(doc);
+			}
+			const order = async (direction: SortDirection) => {
+				const results = await store
+					.iterate({
+						query: [],
+						sort: [new Sort({ key: "sortKey", direction })],
+					})
+					.all();
+				return results.map((r) => fmt(r.value.id));
+			};
+			const asc = await order(SortDirection.ASC);
+			const desc = await order(SortDirection.DESC);
+			await store.stop?.();
+			await indices.stop?.();
+			await indices.drop?.();
+			indices = undefined;
+			return { asc, desc };
+		};
+
+		it("orders string-id ties by UTF-8 bytes, both directions", async () => {
+			const docs = ["c", "a", "b", "aa", "A", "Z"].map((s) => new StringIdDoc(s));
+			const { asc, desc } = await collect(StringIdDoc, docs);
+			// UTF-8 byte order: uppercase (A, Z) before lowercase (a, aa, b, c).
+			expect(asc).to.deep.equal(["A", "Z", "a", "aa", "b", "c"]);
+			expect(desc).to.deep.equal(["c", "b", "aa", "a", "Z", "A"]);
+		});
+
+		it("orders bigint-id ties numerically, both directions", async () => {
+			const docs = [10n, 2n, 21n, 9n, 100n, 300n].map((n) => new BigIntIdDoc(n));
+			const { asc, desc } = await collect(BigIntIdDoc, docs);
+			expect(asc).to.deep.equal(["2", "9", "10", "21", "100", "300"]);
+			expect(desc).to.deep.equal(["300", "100", "21", "10", "9", "2"]);
+		});
+
+		it("orders Uint8Array-id ties by raw bytes, both directions", async () => {
+			const docs = [[0xff], [0x00], [0x0a], [0x3e], [0xf8], [0xfb]].map(
+				(b) => new BytesIdDoc(new Uint8Array(b)),
+			);
+			const { asc, desc } = await collect(BytesIdDoc, docs);
+			// Raw-byte memcmp: 0x00 < 0x0a < 0x3e < 0xf8 < 0xfb < 0xff.
+			expect(asc).to.deep.equal(["00", "0a", "3e", "f8", "fb", "ff"]);
+			expect(desc).to.deep.equal(["ff", "fb", "f8", "3e", "0a", "00"]);
+		});
+	});
+};