npm - @enbox/dwn-sdk-js - Versions diffs - 0.0.1 → 0.0.3 - Mend

@enbox/dwn-sdk-js 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (601) hide show

package/dist/esm/tests/store/index-level.spec.js CHANGED Viewed

@@ -16,14 +16,12 @@ import { SortDirection } from '../../src/types/query-types.js';
 import { Temporal } from '@js-temporal/polyfill';
 import { TestDataGenerator } from '../utils/test-data-generator.js';
 import { v4 as uuid } from 'uuid';
-import chaiAsPromised from 'chai-as-promised';
-import chai, { expect } from 'chai';
-chai.use(chaiAsPromised);
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'bun:test';
 describe('IndexLevel', () => {
     let testIndex;
     const tenant = 'did:alice:index-test';
     describe('put', () => {
-        before(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
@@ -33,28 +31,27 @@ describe('IndexLevel', () => {
         beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.clear();
         }));
-        after(() => __awaiter(void 0, void 0, void 0, function* () {
+        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.close();
         }));
         describe('fails to index with no indexable properties', () => {
             it('fails on empty indexes', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id = uuid();
                 const failedIndexPromise = testIndex.put(tenant, id, {});
-                yield expect(failedIndexPromise).to.eventually.be.rejectedWith(DwnErrorCode.IndexMissingIndexableProperty);
+                yield expect(failedIndexPromise).rejects.toThrow(DwnErrorCode.IndexMissingIndexableProperty);
             }));
         });
         it('successfully indexes', () => __awaiter(void 0, void 0, void 0, function* () {
             const id = uuid();
-            const successfulIndex = testIndex.put(tenant, id, {
+            yield testIndex.put(tenant, id, {
                 id,
                 foo: 'foo',
                 digit: 12,
                 toggle: false,
                 tag: ['bar', 'baz']
             });
-            yield expect(successfulIndex).to.eventually.not.be.rejected;
             const results = yield testIndex.query(tenant, [{ id: id }], { sortProperty: 'id' });
-            expect(results[0].messageCid).to.equal(id);
+            expect(results[0].messageCid).toBe(id);
         }));
         it('adds one index key per property value, aside from id', () => __awaiter(void 0, void 0, void 0, function* () {
             const id = uuid(); // 1 key for reverse lookup
@@ -65,7 +62,7 @@ describe('IndexLevel', () => {
                 dateCreated, // 1 key
             });
             let keys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(keys.length).to.equal(5);
+            expect(keys.length).toBe(5);
             yield testIndex.clear();
             yield testIndex.put(tenant, id, {
                 'a': 'b', // 1 key
@@ -74,7 +71,7 @@ describe('IndexLevel', () => {
                 dateCreated, // 1 key
             });
             keys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(keys.length).to.equal(6);
+            expect(keys.length).toBe(6);
         }));
         it('should not put anything if aborted beforehand', () => __awaiter(void 0, void 0, void 0, function* () {
             const controller = new AbortController();
@@ -85,13 +82,13 @@ describe('IndexLevel', () => {
                 foo: 'bar'
             };
             const indexPromise = testIndex.put(tenant, id, index, { signal: controller.signal });
-            yield expect(indexPromise).to.eventually.rejectedWith('reason');
+            yield expect(indexPromise).rejects.toThrow('reason');
             const entries = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(entries.length).to.equal(0);
+            expect(entries.length).toBe(0);
         }));
     });
     describe('query', () => {
-        before(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
@@ -101,7 +98,7 @@ describe('IndexLevel', () => {
         beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.clear();
         }));
-        after(() => __awaiter(void 0, void 0, void 0, function* () {
+        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.close();
         }));
         it('works', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -130,8 +127,8 @@ describe('IndexLevel', () => {
                     'a': 'b',
                     'c': 'e'
                 }], { sortProperty: 'id' });
-            expect(entries.length).to.equal(1);
-            expect(entries[0].messageCid).to.equal(id3);
+            expect(entries.length).toBe(1);
+            expect(entries[0].messageCid).toBe(id3);
         }));
         it('should return all records if an empty filter array is passed', () => __awaiter(void 0, void 0, void 0, function* () {
             const items = ['b', 'a', 'd', 'c'];
@@ -140,10 +137,10 @@ describe('IndexLevel', () => {
             }
             // empty array
             let allResults = yield testIndex.query(tenant, [], { sortProperty: 'letter' });
-            expect(allResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+            expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
             // empty filter
             allResults = yield testIndex.query(tenant, [{}], { sortProperty: 'letter' });
-            expect(allResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+            expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
         }));
         describe('queryWithIteratorPaging()', () => {
             it('paginates using cursor', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -159,28 +156,28 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
                 const results = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(results.length).to.equal(2);
-                expect(results.map(({ messageCid }) => messageCid)).to.eql(['a', 'b']);
+                expect(results.length).toBe(2);
+                expect(results.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, default (ascending)
                 const resultsAfterCursor = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                expect(resultsAfterCursor.length).to.equal(2);
-                expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['c', 'd']);
+                expect(resultsAfterCursor.length).toBe(2);
+                expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, explicit ascending
                 const ascResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(ascResults.length).to.equal(2);
-                expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b']);
+                expect(ascResults.length).toBe(2);
+                expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, explicit ascending
                 const ascResultsAfterCursor = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                expect(ascResultsAfterCursor.length).to.equal(2);
-                expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['c', 'd']);
+                expect(ascResultsAfterCursor.length).toBe(2);
+                expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, descending
                 const descResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
-                expect(descResults.length).to.equal(2);
-                expect(descResults.map(({ messageCid }) => messageCid)).to.eql(['d', 'c']);
+                expect(descResults.length).toBe(2);
+                expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c']);
                 // query with cursor, descending
                 const descResultsAfterCursor = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
-                expect(descResultsAfterCursor.length).to.equal(2);
-                expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['b', 'a']);
+                expect(descResultsAfterCursor.length).toBe(2);
+                expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['b', 'a']);
             }));
             it('returns empty array if sort property is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
                 const testVals = ['b', 'd', 'c', 'a'];
@@ -195,10 +192,10 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
                 const validResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val' });
-                expect(validResults.length).to.equal(4);
+                expect(validResults.length).toBe(4);
                 // sort by invalid property returns no results
                 const invalidResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'invalid' });
-                expect(invalidResults.length).to.equal(0);
+                expect(invalidResults.length).toBe(0);
             }));
             it('cursor is valid but out of range of matched results', () => __awaiter(void 0, void 0, void 0, function* () {
                 const testVals = ['b', 'd', 'c']; // a is missing
@@ -214,11 +211,11 @@ describe('IndexLevel', () => {
                 // cursor `a-id` doesn't actually exist, but the value `a` is sorted prior to the result set.
                 const cursorA = { messageCid: 'a-id', value: 'a' };
                 const allResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: cursorA });
-                expect(allResults.map(({ messageCid }) => messageCid)).to.eql(['b-id', 'c-id', 'd-id']);
+                expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['b-id', 'c-id', 'd-id']);
                 // cursor `e-id` doesn't actually exist, but the value `e` is sorted after to the result set.
                 const cursorE = { messageCid: 'e-id', value: 'e' };
                 const noResults = yield testIndex.queryWithIteratorPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
-                expect(noResults.length).to.eql(0);
+                expect(noResults.length).toEqual(0);
             }));
         });
         describe('array values', () => {
@@ -241,12 +238,12 @@ describe('IndexLevel', () => {
                 }
                 const filterForItemTag = [{ tag: 'item' }];
                 const allResults = yield testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                expect(allResults.length).to.equal(4);
-                expect(allResults.map(item => item.messageCid)).to.have.members(items.map(item => item.id));
+                expect(allResults.length).toBe(4);
+                expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                 const filterForItem3 = [{ tag: 'item3' }];
                 const item3Results = yield testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                expect(item3Results.length).to.equal(1);
-                expect(item3Results.map(item => item.messageCid)).to.has.members([items[2].id]);
+                expect(item3Results.length).toBe(1);
+                expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
             }));
             it('query items with number array values', () => __awaiter(void 0, void 0, void 0, function* () {
                 const items = [{
@@ -267,16 +264,16 @@ describe('IndexLevel', () => {
                 }
                 const filterForItemTag = [{ tag: 1 }];
                 const allResults = yield testIndex.queryWithIteratorPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                expect(allResults.length).to.equal(4);
-                expect(allResults.map(item => item.messageCid)).to.have.members(items.map(item => item.id));
+                expect(allResults.length).toBe(4);
+                expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                 const filterForItem3 = [{ tag: 3 }];
                 const item3Results = yield testIndex.queryWithIteratorPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                expect(item3Results.length).to.equal(1);
-                expect(item3Results.map(item => item.messageCid)).to.have.members([items[2].id]);
+                expect(item3Results.length).toBe(1);
+                expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                 const filterForRange = [{ tag: { gt: 1, lt: 4 } }];
                 const rangeItems = yield testIndex.queryWithIteratorPaging(tenant, filterForRange, { sortProperty: 'id' });
-                expect(rangeItems.length).to.equal(2);
-                expect(rangeItems.map(item => item.messageCid)).to.have.members([items[1].id, items[2].id]);
+                expect(rangeItems.length).toBe(2);
+                expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
             }));
         });
         describe('queryWithInMemoryPaging()', () => {
@@ -293,28 +290,28 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // query with limit, default (ascending)
                 const results = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(results.length).to.equal(2);
-                expect(results.map(({ messageCid }) => messageCid)).to.eql(['a', 'b']);
+                expect(results.length).toBe(2);
+                expect(results.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, default (ascending)
                 const resultsAfterCursor = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                expect(resultsAfterCursor.length).to.equal(2);
-                expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['c', 'd']);
+                expect(resultsAfterCursor.length).toBe(2);
+                expect(resultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, explicit ascending
                 const ascResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 2 });
-                expect(ascResults.length).to.equal(2);
-                expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b']);
+                expect(ascResults.length).toBe(2);
+                expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                 // query with cursor, explicit ascending
                 const ascResultsAfterCursor = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                expect(ascResultsAfterCursor.length).to.equal(2);
-                expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['c', 'd']);
+                expect(ascResultsAfterCursor.length).toBe(2);
+                expect(ascResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 // query with limit, descending
                 const descResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', limit: 2 });
-                expect(descResults.length).to.equal(2);
-                expect(descResults.map(({ messageCid }) => messageCid)).to.eql(['d', 'c']);
+                expect(descResults.length).toBe(2);
+                expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c']);
                 // query with cursor, descending
                 const descResultsAfterCursor = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortDirection: SortDirection.Descending, sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
-                expect(descResultsAfterCursor.length).to.equal(2);
-                expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql(['b', 'a']);
+                expect(descResultsAfterCursor.length).toBe(2);
+                expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual(['b', 'a']);
             }));
             it('returns empty array if sort property is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
                 const testVals = ['b', 'd', 'c', 'a'];
@@ -329,10 +326,10 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 // control test: return all results
                 const validResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', limit: 3 });
-                expect(validResults.length).to.equal(3);
+                expect(validResults.length).toBe(3);
                 // sort by invalid property returns no results
                 const invalidResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'invalid' });
-                expect(invalidResults.length).to.equal(0);
+                expect(invalidResults.length).toBe(0);
             }));
             it('cursor is valid but out of range of matched results', () => __awaiter(void 0, void 0, void 0, function* () {
                 const testVals = ['b', 'd', 'c', 'a'];
@@ -347,10 +344,10 @@ describe('IndexLevel', () => {
                 const filters = [{ schema: 'schema', published: true }];
                 const cursorA = { messageCid: 'a', value: 'a' }; // before results
                 const allResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: cursorA });
-                expect(allResults.map(({ messageCid }) => messageCid)).to.eql(['b', 'c', 'd']);
+                expect(allResults.map(({ messageCid }) => messageCid)).toEqual(['b', 'c', 'd']);
                 const cursorE = { messageCid: 'e', value: 'e' }; // after results
                 const noResults = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'val', cursor: cursorE });
-                expect(noResults.length).to.eql(0);
+                expect(noResults.length).toEqual(0);
             }));
             it('supports range queries', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id = uuid();
@@ -378,8 +375,8 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = yield testIndex.queryWithInMemoryPaging(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(2);
-                expect(entries.map(({ messageCid }) => messageCid)).to.have.members([id2, id3]);
+                expect(entries.length).toBe(2);
+                expect(entries.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([id2, id3]));
                 // only upper bounds
                 const lteFilter = [{
                         value: {
@@ -387,8 +384,8 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const lteReply = yield testIndex.queryWithInMemoryPaging(tenant, lteFilter, { sortProperty: 'id' });
-                expect(lteReply.length).to.equal(3);
-                expect(lteReply.map(({ messageCid }) => messageCid)).to.have.members([id, id2, id3]);
+                expect(lteReply.length).toBe(3);
+                expect(lteReply.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([id, id2, id3]));
             }));
             describe('array values', () => {
                 it('query items with string array values', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -410,12 +407,12 @@ describe('IndexLevel', () => {
                     }
                     const filterForItemTag = [{ tag: 'item' }];
                     const allResults = yield testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                    expect(allResults.length).to.equal(4);
-                    expect(allResults.map(item => item.messageCid)).to.have.members(items.map(item => item.id));
+                    expect(allResults.length).toBe(4);
+                    expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                     const filterForItem3 = [{ tag: 'item3' }];
                     const item3Results = yield testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                    expect(item3Results.length).to.equal(1);
-                    expect(item3Results.map(item => item.messageCid)).to.has.members([items[2].id]);
+                    expect(item3Results.length).toBe(1);
+                    expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                 }));
                 it('query items with number array values', () => __awaiter(void 0, void 0, void 0, function* () {
                     const items = [{
@@ -436,16 +433,16 @@ describe('IndexLevel', () => {
                     }
                     const filterForItemTag = [{ tag: 1 }];
                     const allResults = yield testIndex.queryWithInMemoryPaging(tenant, filterForItemTag, { sortProperty: 'id' });
-                    expect(allResults.length).to.equal(4);
-                    expect(allResults.map(item => item.messageCid)).to.have.members(items.map(item => item.id));
+                    expect(allResults.length).toBe(4);
+                    expect(allResults.map(item => item.messageCid)).toEqual(expect.arrayContaining(items.map(item => item.id)));
                     const filterForItem3 = [{ tag: 3 }];
                     const item3Results = yield testIndex.queryWithInMemoryPaging(tenant, filterForItem3, { sortProperty: 'id' });
-                    expect(item3Results.length).to.equal(1);
-                    expect(item3Results.map(item => item.messageCid)).to.have.members([items[2].id]);
+                    expect(item3Results.length).toBe(1);
+                    expect(item3Results.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[2].id]));
                     const filterForRange = [{ tag: { gt: 1, lt: 4 } }];
                     const rangeItems = yield testIndex.queryWithInMemoryPaging(tenant, filterForRange, { sortProperty: 'id' });
-                    expect(rangeItems.length).to.equal(2);
-                    expect(rangeItems.map(item => item.messageCid)).to.have.members([items[1].id, items[2].id]);
+                    expect(rangeItems.length).toBe(2);
+                    expect(rangeItems.map(item => item.messageCid)).toEqual(expect.arrayContaining([items[1].id, items[2].id]));
                 }));
             });
         });
@@ -459,7 +456,7 @@ describe('IndexLevel', () => {
                 yield testIndex.put(tenant, id, doc);
                 const filters = [{ value: 'foo' }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(0);
+                expect(entries.length).toBe(0);
             }));
             it('supports OR queries', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id1 = uuid();
@@ -484,9 +481,9 @@ describe('IndexLevel', () => {
                         a: ['a', 'b']
                     }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(2);
-                expect(entries.map(({ messageCid }) => messageCid)).to.include(id1);
-                expect(entries.map(({ messageCid }) => messageCid)).to.include(id2);
+                expect(entries.length).toBe(2);
+                expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
+                expect(entries.map(({ messageCid }) => messageCid)).toContain(id2);
             }));
             it('supports range queries', () => __awaiter(void 0, void 0, void 0, function* () {
                 for (let i = -5; i < 5; ++i) {
@@ -503,7 +500,7 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(5);
+                expect(entries.length).toBe(5);
             }));
             it('supports prefixed range queries', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id = uuid();
@@ -518,8 +515,8 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(1);
-                expect(entries.map(({ messageCid }) => messageCid)).to.include(id);
+                expect(entries.length).toBe(1);
+                expect(entries.map(({ messageCid }) => messageCid)).toContain(id);
             }));
             it('supports suffixed range queries', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id1 = uuid();
@@ -540,8 +537,8 @@ describe('IndexLevel', () => {
                         }
                     }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(1);
-                expect(entries.map(({ messageCid }) => messageCid)).to.include(id1);
+                expect(entries.length).toBe(1);
+                expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
             }));
             it('treats strings differently', () => __awaiter(void 0, void 0, void 0, function* () {
                 const id1 = uuid();
@@ -560,8 +557,8 @@ describe('IndexLevel', () => {
                         foo: true
                     }];
                 const entries = yield testIndex.query(tenant, filters, { sortProperty: 'id' });
-                expect(entries.length).to.equal(1);
-                expect(entries.map(({ messageCid }) => messageCid)).to.include(id1);
+                expect(entries.length).toBe(1);
+                expect(entries.map(({ messageCid }) => messageCid)).toContain(id1);
             }));
             describe('numbers', () => {
                 const positiveDigits = Array(10).fill({}).map(_ => TestDataGenerator.randomInt(0, Number.MAX_SAFE_INTEGER)).sort((a, b) => a - b);
@@ -577,8 +574,8 @@ describe('IndexLevel', () => {
                             digit: testNumbers.at(index)
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
-                    expect(entries.length).to.equal(1);
-                    expect((_a = entries.at(0)) === null || _a === void 0 ? void 0 : _a.messageCid).to.equal(testNumbers.at(index).toString());
+                    expect(entries.length).toBe(1);
+                    expect((_a = entries.at(0)) === null || _a === void 0 ? void 0 : _a.messageCid).toBe(testNumbers.at(index).toString());
                 }));
                 it('should not return records that do not match provided number equality filter', () => __awaiter(void 0, void 0, void 0, function* () {
                     // remove the potential (but unlikely) negative test result
@@ -587,7 +584,7 @@ describe('IndexLevel', () => {
                     }
                     const filters = [{ digit: 1 }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
-                    expect(entries.length).to.equal(0);
+                    expect(entries.length).toBe(0);
                 }));
                 it('supports range queries with positive numbers inclusive', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -603,7 +600,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n >= lowerBound && n <= upperBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
                 it('supports range queries with negative numbers inclusive', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -619,7 +616,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n >= lowerBound && n <= upperBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
                 it('should return numbers gt a negative digit', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -633,7 +630,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n > lowerBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
                 it('should return numbers gt a digit', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -647,7 +644,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n > lowerBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
                 it('should return numbers lt a negative digit', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -661,7 +658,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n < upperBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
                 it('should return numbers lt a digit', () => __awaiter(void 0, void 0, void 0, function* () {
                     for (const digit of testNumbers) {
@@ -675,7 +672,7 @@ describe('IndexLevel', () => {
                         }];
                     const entries = yield testIndex.query(tenant, filters, { sortProperty: 'digit' });
                     const testResults = testNumbers.filter(n => n < upperBound).map(n => n.toString());
-                    expect(entries.map(({ messageCid }) => messageCid)).to.eql(testResults);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(testResults);
                 }));
             });
             describe('booleans', () => {
@@ -697,18 +694,18 @@ describe('IndexLevel', () => {
                     const bothFilter = [{ schema: 'schema' }];
                     // control
                     const entries = yield testIndex.query(tenant, bothFilter, { sortProperty: 'id' });
-                    expect(entries.length).to.equal(2);
-                    expect(entries.map(({ messageCid }) => messageCid)).to.have.members([itemTrueId, itemFalseId]);
+                    expect(entries.length).toBe(2);
+                    expect(entries.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemTrueId, itemFalseId]));
                     const trueFilter = [{ published: true, schema: 'schema' }];
                     // equality true
                     const respTrue = yield testIndex.query(tenant, trueFilter, { sortProperty: 'id' });
-                    expect(respTrue.length).to.equal(1);
-                    expect(respTrue.map(({ messageCid }) => messageCid)).to.have.members([itemTrueId]);
+                    expect(respTrue.length).toBe(1);
+                    expect(respTrue.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemTrueId]));
                     const falseFilter = [{ published: false, schema: 'schema' }];
                     // equality false
                     const respFalse = yield testIndex.query(tenant, falseFilter, { sortProperty: 'id' });
-                    expect(respFalse.length).to.equal(1);
-                    expect(respFalse.map(({ messageCid }) => messageCid)).to.have.members([itemFalseId]);
+                    expect(respFalse.length).toBe(1);
+                    expect(respFalse.map(({ messageCid }) => messageCid)).toEqual(expect.arrayContaining([itemFalseId]));
                 }));
             });
             describe('sort, limit and cursor', () => {
@@ -720,12 +717,12 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // limit results without cursor
                     let ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2 });
-                    expect(ascResults.length).to.equal(2);
-                    expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b']);
+                    expect(ascResults.length).toBe(2);
+                    expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b']);
                     // limit results with a cursor
                     ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 2, cursor: IndexLevel.createCursorFromLastArrayItem(ascResults, 'val') });
-                    expect(ascResults.length).to.equal(2);
-                    expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['c', 'd']);
+                    expect(ascResults.length).toBe(2);
+                    expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['c', 'd']);
                 }));
                 it('can sort by any indexed property', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testVals = ['b', 'd', 'c', 'a'];
@@ -735,20 +732,20 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort by value ascending
                     const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).to.equal(testVals.length);
-                    expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+                    expect(ascResults.length).toBe(testVals.length);
+                    expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // sort by index ascending
                     const ascIndexResults = yield testIndex.query(tenant, filters, { sortProperty: 'index' });
-                    expect(ascIndexResults.length).to.equal(testVals.length);
-                    expect(ascIndexResults.map(({ messageCid }) => messageCid)).eql(testVals);
+                    expect(ascIndexResults.length).toBe(testVals.length);
+                    expect(ascIndexResults.map(({ messageCid }) => messageCid)).toEqual(testVals);
                     // sort by value descending
                     const descResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).to.equal(testVals.length);
-                    expect(descResults.map(({ messageCid }) => messageCid)).to.eql(['d', 'c', 'b', 'a']);
+                    expect(descResults.length).toBe(testVals.length);
+                    expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c', 'b', 'a']);
                     // sort by index descending
                     const descIndexResults = yield testIndex.query(tenant, filters, { sortProperty: 'index', sortDirection: SortDirection.Descending });
-                    expect(descIndexResults.length).to.equal(testVals.length);
-                    expect(descIndexResults.map(({ messageCid }) => messageCid)).eql([...testVals].reverse());
+                    expect(descIndexResults.length).toBe(testVals.length);
+                    expect(descIndexResults.map(({ messageCid }) => messageCid)).toEqual([...testVals].reverse());
                 }));
                 it('sorts lexicographic', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testVals = ['b', 'a', 'd', 'c'];
@@ -758,12 +755,12 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
                     const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).to.equal(4);
-                    expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+                    expect(ascResults.length).toBe(4);
+                    expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // sort descending
                     const descResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).to.equal(4);
-                    expect(descResults.map(({ messageCid }) => messageCid)).to.eql(['d', 'c', 'b', 'a']);
+                    expect(descResults.length).toBe(4);
+                    expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['d', 'c', 'b', 'a']);
                 }));
                 it('sorts numeric with and without a cursor', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testVals = [-2, -1, 0, 1, 2, 3, 4];
@@ -773,12 +770,12 @@ describe('IndexLevel', () => {
                     const filters = [{ schema: 'schema' }];
                     // sort ascending
                     const ascResults = yield testIndex.query(tenant, filters, { sortProperty: 'val' });
-                    expect(ascResults.length).to.equal(testVals.length);
-                    expect(ascResults.map(({ messageCid }) => messageCid)).to.eql(['-2', '-1', '0', '1', '2', '3', '4']);
+                    expect(ascResults.length).toBe(testVals.length);
+                    expect(ascResults.map(({ messageCid }) => messageCid)).toEqual(['-2', '-1', '0', '1', '2', '3', '4']);
                     // sort descending
                     const descResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending });
-                    expect(descResults.length).to.eql(testVals.length);
-                    expect(descResults.map(({ messageCid }) => messageCid)).to.eql(['4', '3', '2', '1', '0', '-1', '-2']);
+                    expect(descResults.length).toEqual(testVals.length);
+                    expect(descResults.map(({ messageCid }) => messageCid)).toEqual(['4', '3', '2', '1', '0', '-1', '-2']);
                 }));
                 it('sorts range queries with or without a cursor', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testItems = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
@@ -796,16 +793,16 @@ describe('IndexLevel', () => {
                         }];
                     // ascending without a cursor
                     let response = yield testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['b', 'c', 'd', 'e']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['b', 'c', 'd', 'e']);
                     // ascending with a cursor
                     response = yield testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['f', 'g']); // should only return greater than e
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['f', 'g']); // should only return greater than e
                     // descending without a cursor
                     response = yield testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['g', 'f', 'e', 'd']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['g', 'f', 'e', 'd']);
                     // descending with a cursor
                     response = yield testIndex.query(tenant, bothBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['c', 'b']); // should only return less than d
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['c', 'b']); // should only return less than d
                     // test only upper bounds
                     const upperBoundsFilters = [{
                             letter: {
@@ -814,16 +811,16 @@ describe('IndexLevel', () => {
                         }];
                     // ascending without a cursor
                     response = yield testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // ascending with a cursor
                     response = yield testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['e', 'f', 'g']); // should only return items greater than d
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['e', 'f', 'g']); // should only return items greater than d
                     // descending without a cursor
                     response = yield testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['g', 'f', 'e', 'd']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['g', 'f', 'e', 'd']);
                     // descending with a cursor
                     response = yield testIndex.query(tenant, upperBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['c', 'b', 'a']); // should only return items less than c
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['c', 'b', 'a']); // should only return items less than c
                     // test only lower bounds
                     const lowerBoundsFilters = [{
                             letter: {
@@ -832,16 +829,16 @@ describe('IndexLevel', () => {
                         }];
                     // ascending without a cursor
                     response = yield testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['b', 'c', 'd', 'e']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['b', 'c', 'd', 'e']);
                     // ascending with a cursor
                     response = yield testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['f', 'g', 'h']); // should only return items greater than e
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['f', 'g', 'h']); // should only return items greater than e
                     // descending without a cursor
                     response = yield testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['h', 'g', 'f', 'e']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['h', 'g', 'f', 'e']);
                     // descending with a cursor
                     response = yield testIndex.query(tenant, lowerBoundsFilters, { sortProperty: 'letter', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(response, 'letter') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['d', 'c', 'b']); // should only return items less than e
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['d', 'c', 'b']); // should only return items less than e
                 }));
                 it('sorts range queries negative integers with or without a cursor', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testNumbers = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5];
@@ -857,11 +854,11 @@ describe('IndexLevel', () => {
                             }
                         }];
                     let results = yield testIndex.query(tenant, filters, { sortProperty: 'digit', limit: 4 });
-                    expect(results.map(({ messageCid }) => messageCid)).to.eql(['-2', '-1', '0', '1']);
+                    expect(results.map(({ messageCid }) => messageCid)).toEqual(['-2', '-1', '0', '1']);
                     const cursor = IndexLevel.createCursorFromLastArrayItem(results, 'digit');
-                    expect(typeof (cursor === null || cursor === void 0 ? void 0 : cursor.value)).to.equal('number'); // the cursor value is a number, as it was indexed
+                    expect(typeof (cursor === null || cursor === void 0 ? void 0 : cursor.value)).toBe('number'); // the cursor value is a number, as it was indexed
                     results = yield testIndex.query(tenant, filters, { sortProperty: 'digit', cursor });
-                    expect(results.map(({ messageCid }) => messageCid)).to.eql(['2', '3']);
+                    expect(results.map(({ messageCid }) => messageCid)).toEqual(['2', '3']);
                 }));
                 it('sorts range queries with remaining results in lte after cursor', () => __awaiter(void 0, void 0, void 0, function* () {
                     // create an array with unique IDs but multiple items representing the same digit.
@@ -903,7 +900,7 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             },
                         }], { sortProperty: 'id', limit: 3 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['b', 'c', 'd']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['b', 'c', 'd']);
                     // this cursor should ony return results from the 'lte' part of the filter
                     response = yield testIndex.query(tenant, [{
                             digit: {
@@ -911,14 +908,14 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             },
                         }], { sortProperty: 'id', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'id') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['e', 'f', 'g']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['e', 'f', 'g']);
                     // issue a range with no lower bounds but a limit
                     response = yield testIndex.query(tenant, [{
                             digit: {
                                 lte: upperBound
                             },
                         }], { sortProperty: 'id', limit: 4 });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['a', 'b', 'c', 'd']);
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['a', 'b', 'c', 'd']);
                     // with no lower bounds
                     // ascending with a cursor
                     // this cursor should ony return results from the 'lte' part of the filter
@@ -927,7 +924,7 @@ describe('IndexLevel', () => {
                                 lte: upperBound
                             },
                         }], { sortProperty: 'id', cursor: IndexLevel.createCursorFromLastArrayItem(response, 'id') });
-                    expect(response.map(({ messageCid }) => messageCid)).to.eql(['e', 'f', 'g']); // should only return three matching items
+                    expect(response.map(({ messageCid }) => messageCid)).toEqual(['e', 'f', 'g']); // should only return three matching items
                 }));
                 it('sorts OR queries with or without a cursor', () => __awaiter(void 0, void 0, void 0, function* () {
                     const testValsSchema1 = ['a1', 'b1', 'c1', 'd1'];
@@ -943,10 +940,10 @@ describe('IndexLevel', () => {
                         }];
                     // sort ascending without cursor
                     let results = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 4 });
-                    expect(results.map(({ messageCid }) => messageCid)).to.eql(['a1', 'a2', 'b1', 'b2']);
+                    expect(results.map(({ messageCid }) => messageCid)).toEqual(['a1', 'a2', 'b1', 'b2']);
                     // sort ascending from b2 onwards
                     results = yield testIndex.query(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                    expect(results.map(({ messageCid }) => messageCid)).to.eql(['c1', 'c2', 'd1', 'd2']);
+                    expect(results.map(({ messageCid }) => messageCid)).toEqual(['c1', 'c2', 'd1', 'd2']);
                 }));
                 it('supports multiple filtered queries', () => __awaiter(void 0, void 0, void 0, function* () {
                     const items = [];
@@ -978,22 +975,22 @@ describe('IndexLevel', () => {
                     ];
                     // query in ascending order.
                     const results = yield testIndex.query(tenant, filters, { sortProperty: 'val', limit: 10 });
-                    expect(results.length).to.be.lte(10);
-                    expect(results.map(({ messageCid }) => messageCid)).to.eql([...compareResults].slice(0, 10), 'results ascending');
+                    expect(results.length).toBeLessThanOrEqual(10);
+                    expect(results.map(({ messageCid }) => messageCid)).toEqual([...compareResults].slice(0, 10));
                     // query in ascending order with cursor.
                     const resultsWithCursor = yield testIndex.query(tenant, filters, { sortProperty: 'val', cursor: IndexLevel.createCursorFromLastArrayItem(results, 'val') });
-                    expect(resultsWithCursor.map(({ messageCid }) => messageCid)).to.eql([...compareResults].slice(10), 'results after cursor ascending');
+                    expect(resultsWithCursor.map(({ messageCid }) => messageCid)).toEqual([...compareResults].slice(10));
                     const descResults = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending, limit: 10 });
-                    expect(descResults.length).to.be.lte(10);
-                    expect(descResults.map(({ messageCid }) => messageCid)).to.eql([...compareResults].reverse().slice(0, 10), 'results descending');
+                    expect(descResults.length).toBeLessThanOrEqual(10);
+                    expect(descResults.map(({ messageCid }) => messageCid)).toEqual([...compareResults].reverse().slice(0, 10));
                     const descResultsAfterCursor = yield testIndex.query(tenant, filters, { sortProperty: 'val', sortDirection: SortDirection.Descending, cursor: IndexLevel.createCursorFromLastArrayItem(descResults, 'val') });
-                    expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).to.eql([...compareResults].reverse().slice(10), 'results after cursor descending');
+                    expect(descResultsAfterCursor.map(({ messageCid }) => messageCid)).toEqual([...compareResults].reverse().slice(10));
                 }));
             });
         });
     });
     describe('delete', () => {
-        before(() => __awaiter(void 0, void 0, void 0, function* () {
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
             testIndex = new IndexLevel({
                 createLevelDatabase,
                 location: 'TEST-INDEX',
@@ -1003,7 +1000,7 @@ describe('IndexLevel', () => {
         beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.clear();
         }));
-        after(() => __awaiter(void 0, void 0, void 0, function* () {
+        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
             yield testIndex.close();
         }));
         it('purges indexes', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -1022,14 +1019,14 @@ describe('IndexLevel', () => {
             yield testIndex.put(tenant, id1, doc1);
             yield testIndex.put(tenant, id2, doc2);
             let result = yield testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
-            expect(result.length).to.equal(2);
-            expect(result.map(({ messageCid }) => messageCid)).to.contain(id1);
+            expect(result.length).toBe(2);
+            expect(result.map(({ messageCid }) => messageCid)).toContain(id1);
             yield testIndex.delete(tenant, id1);
             result = yield testIndex.query(tenant, [{ 'a': 'b', 'c': 'e' }], { sortProperty: 'id' });
-            expect(result.length).to.equal(1);
+            expect(result.length).toBe(1);
             yield testIndex.delete(tenant, id2);
             const allKeys = yield ArrayUtility.fromAsyncGenerator(testIndex.db.keys());
-            expect(allKeys.length).to.equal(0);
+            expect(allKeys.length).toBe(0);
         }));
         it('should not delete anything if aborted beforehand', () => __awaiter(void 0, void 0, void 0, function* () {
             const controller = new AbortController();
@@ -1044,11 +1041,11 @@ describe('IndexLevel', () => {
                 yield testIndex.delete(tenant, id, { signal: controller.signal });
             }
             catch (e) {
-                expect(e).to.equal('reason');
+                expect(e).toBe('reason');
             }
             const result = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(result.length).to.equal(1);
-            expect(result.map(({ messageCid }) => messageCid)).to.contain(id);
+            expect(result.length).toBe(1);
+            expect(result.map(({ messageCid }) => messageCid)).toContain(id);
         }));
         it('does nothing when attempting to purge key that does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
             const controller = new AbortController();
@@ -1062,8 +1059,8 @@ describe('IndexLevel', () => {
             // attempt purge an invalid id
             yield testIndex.delete(tenant, 'invalidCid');
             const result = yield testIndex.query(tenant, [{ foo: 'bar' }], { sortProperty: 'id' });
-            expect(result.length).to.equal(1);
-            expect(result.map(({ messageCid }) => messageCid)).to.contain(id);
+            expect(result.length).toBe(1);
+            expect(result.map(({ messageCid }) => messageCid)).toContain(id);
         }));
     });
     describe('createCursorFromItem', () => {
@@ -1076,8 +1073,8 @@ describe('IndexLevel', () => {
                     sortPropertyArray: [1, 2, 3],
                 }
             };
-            expect(() => IndexLevel.createCursorFromItem(item, 'sortPropertyBool')).to.throw(DwnErrorCode.IndexInvalidCursorValueType);
-            expect(() => IndexLevel.createCursorFromItem(item, 'sortPropertyArray')).to.throw(DwnErrorCode.IndexInvalidCursorValueType);
+            expect(() => IndexLevel.createCursorFromItem(item, 'sortPropertyBool')).toThrow(DwnErrorCode.IndexInvalidCursorValueType);
+            expect(() => IndexLevel.createCursorFromItem(item, 'sortPropertyArray')).toThrow(DwnErrorCode.IndexInvalidCursorValueType);
         }));
         it('throws if sort property is not defined within the IndexedItem', () => __awaiter(void 0, void 0, void 0, function* () {
             const item = {
@@ -1086,7 +1083,7 @@ describe('IndexLevel', () => {
                     sortProperty: 1234,
                 }
             };
-            expect(() => IndexLevel.createCursorFromItem(item, 'unknownProperty')).to.throw(DwnErrorCode.IndexInvalidCursorSortProperty);
+            expect(() => IndexLevel.createCursorFromItem(item, 'unknownProperty')).toThrow(DwnErrorCode.IndexInvalidCursorSortProperty);
         }));
         it('returns numeric type cursor value', () => __awaiter(void 0, void 0, void 0, function* () {
             const item = {
@@ -1096,7 +1093,7 @@ describe('IndexLevel', () => {
                 }
             };
             const cursor = IndexLevel.createCursorFromItem(item, 'sortProperty');
-            expect(cursor.value).to.equal(1234);
+            expect(cursor.value).toBe(1234);
         }));
         it('returns string type cursor value', () => __awaiter(void 0, void 0, void 0, function* () {
             const item = {
@@ -1106,13 +1103,13 @@ describe('IndexLevel', () => {
                 }
             };
             const cursor = IndexLevel.createCursorFromItem(item, 'sortProperty');
-            expect(cursor.value).to.equal('1234');
+            expect(cursor.value).toBe('1234');
         }));
     });
     describe('createCursorFromLastArrayItem', () => {
         it('returns undefined if an empty array is provided', () => __awaiter(void 0, void 0, void 0, function* () {
             const cursor = IndexLevel.createCursorFromLastArrayItem([], 'someProperty');
-            expect(cursor).to.equal(undefined);
+            expect(cursor).toBe(undefined);
         }));
         it('returns a PaginationCursor for the last item given a valid sort property', () => __awaiter(void 0, void 0, void 0, function* () {
             const items = [{
@@ -1131,78 +1128,431 @@ describe('IndexLevel', () => {
                     }
                 }];
             const cursor = IndexLevel.createCursorFromLastArrayItem(items, 'date');
-            expect(cursor === null || cursor === void 0 ? void 0 : cursor.messageCid).to.equal('cid-2'); // expect the cursor to equal the messageCid
-            expect(cursor === null || cursor === void 0 ? void 0 : cursor.value).to.equal('2023-12-14T11:22:33.000000Z');
+            expect(cursor === null || cursor === void 0 ? void 0 : cursor.messageCid).toBe('cid-2'); // expect the cursor to equal the messageCid
+            expect(cursor === null || cursor === void 0 ? void 0 : cursor.value).toBe('2023-12-14T11:22:33.000000Z');
         }));
     });
     describe('encodeValue', () => {
         it('should wrap string in quotes', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.encodeValue('test')).to.equal(`"test"`);
+            expect(IndexLevel.encodeValue('test')).toBe(`"test"`);
         }));
         it('should return string encoded number using encodeNumberValue()', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.encodeValue(10)).to.equal(IndexLevel.encodeNumberValue(10));
+            expect(IndexLevel.encodeValue(10)).toBe(IndexLevel.encodeNumberValue(10));
         }));
         it('should return stringified boolean', () => {
-            expect(IndexLevel.encodeValue(true)).to.equal('true');
-            expect(IndexLevel.encodeValue(false)).to.equal('false');
+            expect(IndexLevel.encodeValue(true)).toBe('true');
+            expect(IndexLevel.encodeValue(false)).toBe('false');
         });
     });
     describe('encodeNumberValue', () => {
         it('should encode positive digits and pad with leading zeros', () => {
             const expectedLength = String(Number.MAX_SAFE_INTEGER).length; //16
             const encoded = IndexLevel.encodeNumberValue(100);
-            expect(encoded.length).to.equal(expectedLength);
-            expect(encoded).to.equal('0000000000000100');
+            expect(encoded.length).toBe(expectedLength);
+            expect(encoded).toBe('0000000000000100');
         });
         it('should encode negative digits as an offset with a prefix', () => {
             const expectedPrefix = '!';
             // expected length is maximum padding + the prefix.
             const expectedLength = (expectedPrefix + String(Number.MAX_SAFE_INTEGER)).length; //17
             const encoded = IndexLevel.encodeNumberValue(-100);
-            expect(encoded.length).to.equal(String(Number.MIN_SAFE_INTEGER).length);
-            expect(encoded.length).to.equal(expectedLength);
-            expect(encoded).to.equal('!9007199254740891');
+            expect(encoded.length).toBe(String(Number.MIN_SAFE_INTEGER).length);
+            expect(encoded.length).toBe(expectedLength);
+            expect(encoded).toBe('!9007199254740891');
         });
         it('should encode digits to sort using lexicographical comparison', () => {
             const digits = [-1000, -100, -10, 10, 100, 1000].sort((a, b) => a - b);
             const encodedDigits = digits.map(d => IndexLevel.encodeNumberValue(d))
                 .sort((a, b) => lexicographicalCompare(a, b));
-            digits.forEach((n, i) => expect(encodedDigits.at(i)).to.equal(IndexLevel.encodeNumberValue(n)));
+            digits.forEach((n, i) => expect(encodedDigits.at(i)).toBe(IndexLevel.encodeNumberValue(n)));
         });
     });
     describe('isFilterConcise', () => {
         const queryOptionsWithCursor = { sortProperty: 'sort', cursor: { messageCid: 'messageCid', value: 'value' } };
         const queryOptionsWithoutCursor = { sortProperty: 'sort' };
         it('recordId is always concise', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithoutCursor)).to.equal(true);
+            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithoutCursor)).toBe(true);
         }));
         it('other than if `recordId` exists, if a cursor exists it is never concise', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithCursor)).to.equal(false);
+            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithCursor)).toBe(false);
             // control
-            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithoutCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithCursor)).to.equal(true);
+            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithoutCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ recordId: 'record-id' }, queryOptionsWithCursor)).toBe(true);
         }));
         it('if there is no cursor -  protocolPath, contextId, parentId, or schema return a concise filter', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.isFilterConcise({ protocolPath: 'protocolPath' }, queryOptionsWithoutCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ protocolPath: 'protocolPath' }, queryOptionsWithCursor)).to.equal(false); // control
-            expect(IndexLevel.isFilterConcise({ contextId: 'contextId' }, queryOptionsWithoutCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ contextId: 'contextId' }, queryOptionsWithCursor)).to.equal(false); // control
-            expect(IndexLevel.isFilterConcise({ contextId: 'parentId' }, queryOptionsWithoutCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ contextId: 'parentId' }, queryOptionsWithCursor)).to.equal(false); // control
-            expect(IndexLevel.isFilterConcise({ contextId: 'schema' }, queryOptionsWithoutCursor)).to.equal(true);
-            expect(IndexLevel.isFilterConcise({ contextId: 'schema' }, queryOptionsWithCursor)).to.equal(false); // control
+            expect(IndexLevel.isFilterConcise({ protocolPath: 'protocolPath' }, queryOptionsWithoutCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ protocolPath: 'protocolPath' }, queryOptionsWithCursor)).toBe(false); // control
+            expect(IndexLevel.isFilterConcise({ contextId: 'contextId' }, queryOptionsWithoutCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ contextId: 'contextId' }, queryOptionsWithCursor)).toBe(false); // control
+            expect(IndexLevel.isFilterConcise({ contextId: 'parentId' }, queryOptionsWithoutCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ contextId: 'parentId' }, queryOptionsWithCursor)).toBe(false); // control
+            expect(IndexLevel.isFilterConcise({ contextId: 'schema' }, queryOptionsWithoutCursor)).toBe(true);
+            expect(IndexLevel.isFilterConcise({ contextId: 'schema' }, queryOptionsWithCursor)).toBe(false); // control
         }));
         it('if there is no cursor, and it is not one of the conditions, return not concise', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.isFilterConcise({ dataSize: { gt: 123 } }, queryOptionsWithoutCursor)).to.equal(false);
+            expect(IndexLevel.isFilterConcise({ dataSize: { gt: 123 } }, queryOptionsWithoutCursor)).toBe(false);
             // control
-            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithoutCursor)).to.equal(true);
+            expect(IndexLevel.isFilterConcise({ schema: 'schema', contextId: 'contextId', parentId: 'parentId' }, queryOptionsWithoutCursor)).toBe(true);
         }));
         it('if protocol filter exists by itself it is not a concise filter', () => __awaiter(void 0, void 0, void 0, function* () {
-            expect(IndexLevel.isFilterConcise({ protocol: 'protocol' }, queryOptionsWithoutCursor)).to.equal(false);
+            expect(IndexLevel.isFilterConcise({ protocol: 'protocol' }, queryOptionsWithoutCursor)).toBe(false);
             // control
-            expect(IndexLevel.isFilterConcise({ protocol: 'protocol', protocolPath: 'path/to' }, queryOptionsWithoutCursor)).to.equal(true);
+            expect(IndexLevel.isFilterConcise({ protocol: 'protocol', protocolPath: 'path/to' }, queryOptionsWithoutCursor)).toBe(true);
+        }));
+    });
+    describe('compound indexes', () => {
+        const compoundIndexes = [
+            {
+                name: 'protocol-protocolPath-messageTimestamp',
+                properties: ['protocol', 'protocolPath'],
+                sortProperty: 'messageTimestamp',
+            },
+            {
+                name: 'schema-dateCreated',
+                properties: ['schema'],
+                sortProperty: 'dateCreated',
+            },
+        ];
+        let compoundIndex;
+        const compoundTenant = 'did:alice:compound-test';
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+            compoundIndex = new IndexLevel({
+                createLevelDatabase,
+                location: 'TEST-COMPOUND-INDEX',
+                compoundIndexes: compoundIndexes,
+            });
+            yield compoundIndex.open();
+        }));
+        beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield compoundIndex.clear();
+        }));
+        afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
+            yield compoundIndex.close();
         }));
+        describe('put and delete lifecycle', () => {
+            it('should create compound index entries during put', () => __awaiter(void 0, void 0, void 0, function* () {
+                const id = uuid();
+                yield compoundIndex.put(compoundTenant, id, {
+                    protocol: 'https://protocol.xyz',
+                    protocolPath: 'chat/message',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                    schema: 'https://schema.org/Message',
+                    dateCreated: '2024-01-15T10:00:00.000000Z',
+                });
+                // query using compound index (protocol + protocolPath sorted by messageTimestamp)
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(1);
+                expect(results[0].messageCid).toBe(id);
+            }));
+            it('should delete compound index entries during delete', () => __awaiter(void 0, void 0, void 0, function* () {
+                const id = uuid();
+                yield compoundIndex.put(compoundTenant, id, {
+                    protocol: 'https://protocol.xyz',
+                    protocolPath: 'chat/message',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                    schema: 'https://schema.org/Message',
+                    dateCreated: '2024-01-15T10:00:00.000000Z',
+                });
+                // verify it exists
+                let results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(1);
+                // delete
+                yield compoundIndex.delete(compoundTenant, id);
+                // verify compound index entries are removed
+                results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://protocol.xyz', protocolPath: 'chat/message' }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(0);
+            }));
+            it('should skip compound index entries when required properties are missing', () => __awaiter(void 0, void 0, void 0, function* () {
+                const id = uuid();
+                // only has schema, not protocol+protocolPath
+                yield compoundIndex.put(compoundTenant, id, {
+                    schema: 'https://schema.org/Message',
+                    dateCreated: '2024-01-15T10:00:00.000000Z',
+                });
+                // the protocol+protocolPath compound index should not have entries
+                // query via the schema compound index should still work
+                const schemaResults = yield compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Message' }], { sortProperty: 'dateCreated' });
+                expect(schemaResults.length).toBe(1);
+                expect(schemaResults[0].messageCid).toBe(id);
+            }));
+        });
+        describe('queryWithCompoundIndex()', () => {
+            it('should return results sorted ascending by the sort property', () => __awaiter(void 0, void 0, void 0, function* () {
+                const ids = ['msg-c', 'msg-a', 'msg-b'];
+                const timestamps = [
+                    '2024-01-15T12:00:00.000000Z',
+                    '2024-01-15T10:00:00.000000Z',
+                    '2024-01-15T11:00:00.000000Z',
+                ];
+                for (let i = 0; i < ids.length; i++) {
+                    yield compoundIndex.put(compoundTenant, ids[i], {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'thread/post',
+                        messageTimestamp: timestamps[i],
+                    });
+                }
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(3);
+                expect(results.map(r => r.messageCid)).toEqual(['msg-a', 'msg-b', 'msg-c']);
+            }));
+            it('should return results sorted descending by the sort property', () => __awaiter(void 0, void 0, void 0, function* () {
+                const ids = ['msg-c', 'msg-a', 'msg-b'];
+                const timestamps = [
+                    '2024-01-15T12:00:00.000000Z',
+                    '2024-01-15T10:00:00.000000Z',
+                    '2024-01-15T11:00:00.000000Z',
+                ];
+                for (let i = 0; i < ids.length; i++) {
+                    yield compoundIndex.put(compoundTenant, ids[i], {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'thread/post',
+                        messageTimestamp: timestamps[i],
+                    });
+                }
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending });
+                expect(results.length).toBe(3);
+                expect(results.map(r => r.messageCid)).toEqual(['msg-c', 'msg-b', 'msg-a']);
+            }));
+            it('should support limit', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 5; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', limit: 3 });
+                expect(results.length).toBe(3);
+                expect(results.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
+            }));
+            it('should support cursor pagination ascending', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 6; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                // first page
+                const page1 = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', limit: 3 });
+                expect(page1.length).toBe(3);
+                expect(page1.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
+                // second page using cursor
+                const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'messageTimestamp');
+                const page2 = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', cursor });
+                expect(page2.length).toBe(3);
+                expect(page2.map(r => r.messageCid)).toEqual(['msg-3', 'msg-4', 'msg-5']);
+            }));
+            it('should support cursor pagination descending', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 6; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                // first page descending
+                const page1 = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending, limit: 3 });
+                expect(page1.length).toBe(3);
+                expect(page1.map(r => r.messageCid)).toEqual(['msg-5', 'msg-4', 'msg-3']);
+                // second page descending using cursor
+                const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'messageTimestamp');
+                const page2 = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp', sortDirection: SortDirection.Descending, cursor });
+                expect(page2.length).toBe(3);
+                expect(page2.map(r => r.messageCid)).toEqual(['msg-2', 'msg-1', 'msg-0']);
+            }));
+            it('should verify residual filter properties in memory', () => __awaiter(void 0, void 0, void 0, function* () {
+                // insert records with same protocol+protocolPath but different 'published' values
+                for (let i = 0; i < 4; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                        published: i % 2 === 0, // msg-0: true, msg-1: false, msg-2: true, msg-3: false
+                    });
+                }
+                // compound index covers protocol+protocolPath+messageTimestamp but NOT published
+                // published should be verified as a residual filter
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items', published: true }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(2);
+                expect(results.map(r => r.messageCid)).toEqual(['msg-0', 'msg-2']);
+            }));
+            it('should only return results matching the specific filter values', () => __awaiter(void 0, void 0, void 0, function* () {
+                // insert records with different protocol paths
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/post',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                });
+                yield compoundIndex.put(compoundTenant, 'msg-2', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/reply',
+                    messageTimestamp: '2024-01-15T11:00:00.000000Z',
+                });
+                yield compoundIndex.put(compoundTenant, 'msg-3', {
+                    protocol: 'https://other.xyz',
+                    protocolPath: 'thread/post',
+                    messageTimestamp: '2024-01-15T12:00:00.000000Z',
+                });
+                // query for only protocol.xyz + thread/post
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'thread/post' }], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(1);
+                expect(results[0].messageCid).toBe('msg-1');
+            }));
+            it('should fall back to non-compound strategy for OR (multi-filter) queries', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/post',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                });
+                yield compoundIndex.put(compoundTenant, 'msg-2', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/reply',
+                    messageTimestamp: '2024-01-15T11:00:00.000000Z',
+                });
+                // OR queries (multiple filters) should still work via fallback strategies
+                const results = yield compoundIndex.query(compoundTenant, [
+                    { protocol: 'https://proto.xyz', protocolPath: 'thread/post' },
+                    { protocol: 'https://proto.xyz', protocolPath: 'thread/reply' },
+                ], { sortProperty: 'messageTimestamp' });
+                expect(results.length).toBe(2);
+            }));
+            it('should prefer the compound index with the most properties', () => __awaiter(void 0, void 0, void 0, function* () {
+                // both compound indexes could potentially match a query with schema + dateCreated
+                // but only the schema-dateCreated one actually applies
+                // also, the protocol-protocolPath-messageTimestamp index should be preferred over
+                // a hypothetical single-property index when both protocol and protocolPath are present
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'items',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                    schema: 'https://schema.org/Item',
+                    dateCreated: '2024-01-15T10:00:00.000000Z',
+                });
+                // query using schema compound index
+                const schemaResults = yield compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated' });
+                expect(schemaResults.length).toBe(1);
+                expect(schemaResults[0].messageCid).toBe('msg-1');
+                // query using protocol+protocolPath compound index
+                const protocolResults = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp' });
+                expect(protocolResults.length).toBe(1);
+                expect(protocolResults[0].messageCid).toBe('msg-1');
+            }));
+            it('should not use compound index when sort property does not match', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'items',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                    schema: 'https://schema.org/Item',
+                    dateCreated: '2024-01-15T10:00:00.000000Z',
+                });
+                // query with protocol+protocolPath but sort by dateCreated (not messageTimestamp)
+                // this should NOT use the protocol-protocolPath-messageTimestamp compound index
+                // it should still return correct results via fallback strategy
+                const results = yield compoundIndex.query(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'dateCreated' });
+                expect(results.length).toBe(1);
+            }));
+        });
+        describe('count()', () => {
+            it('should count items matching a compound index filter', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 10; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                // add some non-matching records
+                for (let i = 0; i < 5; i++) {
+                    yield compoundIndex.put(compoundTenant, `other-${i}`, {
+                        protocol: 'https://other.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                const count = yield compoundIndex.count(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp' });
+                expect(count).toBe(10);
+            }));
+            it('should count items with residual filter verification', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 6; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                        published: i % 2 === 0, // msg-0: true, msg-1: false, msg-2: true, msg-3: false, msg-4: true, msg-5: false
+                    });
+                }
+                const count = yield compoundIndex.count(compoundTenant, [{ protocol: 'https://proto.xyz', protocolPath: 'items', published: true }], { sortProperty: 'messageTimestamp' });
+                expect(count).toBe(3); // msg-0, msg-2, msg-4
+            }));
+            it('should return 0 when no items match', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'items',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                });
+                const count = yield compoundIndex.count(compoundTenant, [{ protocol: 'https://nonexistent.xyz', protocolPath: 'items' }], { sortProperty: 'messageTimestamp' });
+                expect(count).toBe(0);
+            }));
+            it('should fall back to full query for non-compound-index filters', () => __awaiter(void 0, void 0, void 0, function* () {
+                for (let i = 0; i < 4; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        protocol: 'https://proto.xyz',
+                        protocolPath: 'items',
+                        messageTimestamp: `2024-01-15T1${i}:00:00.000000Z`,
+                        published: i < 2,
+                    });
+                }
+                // filter by 'published' alone — no compound index covers this
+                const count = yield compoundIndex.count(compoundTenant, [{ published: true }], { sortProperty: 'messageTimestamp' });
+                expect(count).toBe(2);
+            }));
+            it('should count correctly with OR (multi-filter) queries', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield compoundIndex.put(compoundTenant, 'msg-1', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/post',
+                    messageTimestamp: '2024-01-15T10:00:00.000000Z',
+                });
+                yield compoundIndex.put(compoundTenant, 'msg-2', {
+                    protocol: 'https://proto.xyz',
+                    protocolPath: 'thread/reply',
+                    messageTimestamp: '2024-01-15T11:00:00.000000Z',
+                });
+                yield compoundIndex.put(compoundTenant, 'msg-3', {
+                    protocol: 'https://other.xyz',
+                    protocolPath: 'thread/post',
+                    messageTimestamp: '2024-01-15T12:00:00.000000Z',
+                });
+                // OR query — compound index can't serve this, falls back
+                const count = yield compoundIndex.count(compoundTenant, [
+                    { protocol: 'https://proto.xyz', protocolPath: 'thread/post' },
+                    { protocol: 'https://proto.xyz', protocolPath: 'thread/reply' },
+                ], { sortProperty: 'messageTimestamp' });
+                expect(count).toBe(2);
+            }));
+        });
+        describe('query() dispatch selects compound index when available', () => {
+            it('should use compound index for matching single-filter queries with cursor', () => __awaiter(void 0, void 0, void 0, function* () {
+                // compound indexes support cursors natively, unlike in-memory paging
+                // which would normally reject a cursor with "concise" filters
+                for (let i = 0; i < 6; i++) {
+                    yield compoundIndex.put(compoundTenant, `msg-${i}`, {
+                        schema: 'https://schema.org/Item',
+                        dateCreated: `2024-01-15T1${i}:00:00.000000Z`,
+                    });
+                }
+                // first page
+                const page1 = yield compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated', limit: 3 });
+                expect(page1.length).toBe(3);
+                expect(page1.map(r => r.messageCid)).toEqual(['msg-0', 'msg-1', 'msg-2']);
+                // second page with cursor — this should still use the compound index
+                const cursor = IndexLevel.createCursorFromLastArrayItem(page1, 'dateCreated');
+                const page2 = yield compoundIndex.query(compoundTenant, [{ schema: 'https://schema.org/Item' }], { sortProperty: 'dateCreated', cursor });
+                expect(page2.length).toBe(3);
+                expect(page2.map(r => r.messageCid)).toEqual(['msg-3', 'msg-4', 'msg-5']);
+            }));
+        });
     });
 });
 //# sourceMappingURL=index-level.spec.js.map